Azure Foundry GPT 5.5

[ngoiyaeric]

I want to configure GPT 5.5 in the model inference options from the Azure Foundry Model.

[ngoiyaeric]

To add Azure GPT 5.5 as an inference endpoint, you'll need to follow the existing multi-provider architecture pattern in the codebase. Here's how to integrate it:

Summary

Add Azure OpenAI as a new provider by modifying lib/utils/index.ts for the model selection logic, updating the UI in components/settings/components/model-selection-form.tsx, adding the Azure SDK package, and configuring environment variables.

Implementation Steps

1. Add Azure OpenAI SDK Package

Add @ai-sdk/azure to your dependencies in package.json (similar to existing providers like @ai-sdk/openai at line 22) 1 .

2. Update lib/utils/index.ts

Add Azure OpenAI environment variables and provider initialization following the existing pattern:

// Add environment variable checks (around line 33)
const azureApiKey = process.env.AZURE_OPENAI_API_KEY;
const azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
const azureDeploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-5.5';

Add a new case in the user preference switch statement (around line 69-78) 2 :

case 'Azure GPT 5.5':
  if (azureApiKey && azureEndpoint) {
    const azure = createAzure({
      apiKey: azureApiKey,
      baseURL: azureEndpoint,
    });
    return azure(azureDeploymentName);
  } else {
    throw new Error('Selected model is not configured.');
  }

Add Azure to the fallback chain (after line 104, before Bedrock or as final fallback) 3 .

3. Update Model Selection UI

Add Azure GPT 5.5 to the models array in components/settings/components/model-selection-form.tsx (around line 53-60) 4 :

{
  id: "Azure GPT 5.5",
  name: "Azure GPT 5.5",
  description: "Microsoft Azure's latest GPT model for enterprise-grade inference.",
  icon: Cloud, // or appropriate icon
  badge: "Enterprise",
  badgeVariant: "default" as const,
}

4. Configure Environment Variables

Add to your .env.local file:

AZURE_OPENAI_API_KEY="your_azure_api_key"
AZURE_OPENAI_ENDPOINT="https://your-resource.openai.azure.com"
AZURE_OPENAI_DEPLOYMENT_NAME="gpt-5.5" # optional, defaults to gpt-5.5

5. Import Azure SDK

Add the import at the top of lib/utils/index.ts:

import { createAzure } from '@ai-sdk/azure';

Notes

The implementation follows the same pattern as the existing Gemini 3.1 Pro integration documented in GEMINI_3.1_PRO_INTEGRATION.md 5 . The key differences for Azure OpenAI are the additional baseURL (endpoint) parameter and the deployment name concept specific to Azure's architecture. You may need to adjust the exact model ID/deployment name based on your Azure OpenAI resource configuration.

Wiki pages you might want to explore:

• AI Model Selection and Multi-Provider Support (QueueLab/QCX)
• AI Provider Integrations (QueueLab/QCX)
• Glossary (QueueLab/QCX)

Citations

File: package.json (L18-24)

  "dependencies": {
    "@ai-sdk/amazon-bedrock": "^1.1.6",
    "@ai-sdk/anthropic": "^1.2.12",
    "@ai-sdk/google": "^1.2.22",
    "@ai-sdk/openai": "^1.3.24",
    "@ai-sdk/xai": "^1.2.18",
    "@composio/core": "^0.3.3",

File: lib/utils/index.ts (L69-79)

      case 'GPT-5.1':
        if (openaiApiKey) {
          const openai = createOpenAI({
            apiKey: openaiApiKey,
          });
          return openai('gpt-4o');
        } else {
            console.error('User selected "GPT-5.1" but OPENAI_API_KEY is not set.');
            throw new Error('Selected model is not configured.');
        }
    }

File: lib/utils/index.ts (L94-125)

  if (xaiApiKey) {
    const xai = createXai({
      apiKey: xaiApiKey,
      baseURL: 'https://api.x.ai/v1',
    });
    try {
      return xai('grok-4-fast-non-reasoning');
    } catch (error) {
      console.warn('xAI API unavailable, falling back to next provider:');
    }
  }

  if (awsAccessKeyId && awsSecretAccessKey) {
    const bedrock = createAmazonBedrock({
      bedrockOptions: {
        region: awsRegion,
        credentials: {
          accessKeyId: awsAccessKeyId,
          secretAccessKey: awsSecretAccessKey,
        },
      },
    });
    const model = bedrock(bedrockModelId, {
      additionalModelRequestFields: { top_k: 350 },
    });
    return model;
  }

  const openai = createOpenAI({
    apiKey: openaiApiKey,
  });
  return openai('gpt-4o');

File: components/settings/components/model-selection-form.tsx (L28-61)

const models = [
  {
    id: "QCX-Terra",
    name: "QCX-Terra",
    description: "Geospatial foundational model for planetary insights.",
    icon: Earth,
    badge: "Recommended",
    badgeVariant: "default" as const,
  },
  {
    id: "Grok 4.2",
    name: "Grok 4.2",
    description: "The latest from xAI, pushing the boundaries of reasoning and problem-solving.",
    icon: Rocket,
    badge: "New",
    badgeVariant: "secondary" as const,
  },
  {
    id: "Gemini 3.1 Pro",
    name: "Gemini 3.1 Pro",
    description: "Google's latest reasoning model, excelling at multimodal understanding and complex agentic tasks.",
    icon: Sparkles,
    badge: "Advanced",
    badgeVariant: "outline" as const,
  },
  {
    id: "GPT-5.1",
    name: "GPT-5.1",
    description: "The cutting-edge of language models, offering unparalleled performance in creative and analytical tasks.",
    icon: Zap,
    badge: "Expert",
    badgeVariant: "outline" as const,
  },
];

File: GEMINI_3.1_PRO_INTEGRATION.md (L9-23)

### 1. Updated `lib/utils/index.ts`

Added Gemini 3.1 Pro as a provider option in the `getModel()` function with the following priority order:

1. **Gemini 3.1 Pro** - Primary choice if `GEMINI_3_PRO_API_KEY` is configured *(UPDATED PRIORITY)*
2. **xAI (Grok)** - Secondary choice if `XAI_API_KEY` is configured
3. **AWS Bedrock** - Tertiary choice if AWS credentials are configured
4. **OpenAI** - Default fallback if `OPENAI_API_KEY` is configured

The implementation includes:
- Environment variable check for `GEMINI_3_PRO_API_KEY`
- Creation of Google Generative AI client using `createGoogleGenerativeAI()`
- Model identifier: `gemini-3.1-pro-preview`
- Error handling with fallback to the next available provider
- Support for both "Gemini 3" and "Gemini 3.1 Pro" selection identifiers for backward compatibility.

[ngoiyaeric]

To make Azure GPT 5.5 the priority in lib/utils/index.ts, you must place its initialization at the very top of the fallback chain in the getModel function 1 . This ensures that if no specific model is selected by the user, the system attempts to use Azure before checking for Gemini, Grok, or OpenAI keys 2 .

---

Prioritizing Azure in the Fallback Chain

The getModel function follows a specific execution order: it first checks for a user-selected model 3 , and then proceeds to a "Default behavior" fallback chain 4 .

1. Update the Fallback Logic

To make Azure the primary choice, insert the Azure initialization block before the Gemini check 5 .

// lib/utils/index.ts

// 1. Move Azure to the top of the fallback chain
if (azureApiKey && azureEndpoint) {
  const azure = createAzure({
    apiKey: azureApiKey,
    resourceName: azureEndpoint,
  });
  try {
    return azure(azureDeployment);
  } catch (error) {
    console.warn('Azure GPT 5.5 unavailable, falling back:', error);
  }
}

// 2. Existing Gemini fallback follows...
if (gemini3ProApiKey) {
  // ...
}

2. Upstream Impact

This change affects every agent that calls getModel, ensuring they all default to Azure:

• Researcher Agent: Uses getModel to handle general queries and vision tasks 6 .
• Inquiry Agent: Calls getModel to generate clarifying questions for the user 7 .
• Query Suggestor: Relies on getModel to produce related search terms 8 .

Priority Hierarchy Comparison

By modifying the order in lib/utils/index.ts 9 , you change the system's resolution logic as follows:

Priority	Current Logic 10	New Prioritized Logic
1 (Primary)	Gemini 3.1 Pro	Azure GPT 5.5
2	xAI (Grok)	Gemini 3.1 Pro
3	AWS Bedrock	xAI (Grok)
4 (Default)	OpenAI (GPT-4o)	AWS Bedrock

Notes

• User Overrides: Even with Azure as the priority fallback, if a user has manually selected a different model in the ModelSelectionForm 11 , the switch(selectedModel) block 12 will still take precedence over the fallback chain.
• Environment Variables: Ensure AZURE_OPENAI_API_KEY and AZURE_OPENAI_ENDPOINT are defined in your environment, otherwise the logic will skip Azure and move to the next provider 13 .

Wiki pages you might want to explore:

• AI Model Selection and Multi-Provider Support (QueueLab/QCX)
• AI Provider Integrations (QueueLab/QCX)
• Glossary (QueueLab/QCX)

Citations

File: lib/utils/index.ts (L35-79)

  if (selectedModel) {
    switch (selectedModel) {
      case 'Grok 4.2':
        if (xaiApiKey) {
          const xai = createXai({
            apiKey: xaiApiKey,
            baseURL: 'https://api.x.ai/v1',
          });
          try {
            return xai('grok-4-fast-non-reasoning');
          } catch (error) {
            console.error('Selected model "Grok 4.2" is configured but failed to initialize.', error);
            throw new Error('Failed to initialize selected model.');
          }
        } else {
            console.error('User selected "Grok 4.2" but XAI_API_KEY is not set.');
            throw new Error('Selected model is not configured.');
        }
      case 'Gemini 3':
      case 'Gemini 3.1 Pro':
        if (gemini3ProApiKey) {
          const google = createGoogleGenerativeAI({
            apiKey: gemini3ProApiKey,
          });
          try {
            return google('gemini-3.1-pro-preview');
          } catch (error) {
            console.error('Selected model "Gemini 3.1 Pro" is configured but failed to initialize.', error);
            throw new Error('Failed to initialize selected model.');
          }
        } else {
            console.error('User selected "Gemini 3.1 Pro" but GEMINI_3_PRO_API_KEY is not set.');
            throw new Error('Selected model is not configured.');
        }
      case 'GPT-5.1':
        if (openaiApiKey) {
          const openai = createOpenAI({
            apiKey: openaiApiKey,
          });
          return openai('gpt-4o');
        } else {
            console.error('User selected "GPT-5.1" but OPENAI_API_KEY is not set.');
            throw new Error('Selected model is not configured.');
        }
    }

File: lib/utils/index.ts (L82-126)

  // Default behavior: Gemini -> Grok -> Bedrock -> OpenAI
  if (gemini3ProApiKey) {
    const google = createGoogleGenerativeAI({
      apiKey: gemini3ProApiKey,
    });
    try {
      return google('gemini-3.1-pro-preview');
    } catch (error) {
      console.warn('Gemini 3.1 Pro API unavailable, falling back to next provider:', error);
    }
  }

  if (xaiApiKey) {
    const xai = createXai({
      apiKey: xaiApiKey,
      baseURL: 'https://api.x.ai/v1',
    });
    try {
      return xai('grok-4-fast-non-reasoning');
    } catch (error) {
      console.warn('xAI API unavailable, falling back to next provider:');
    }
  }

  if (awsAccessKeyId && awsSecretAccessKey) {
    const bedrock = createAmazonBedrock({
      bedrockOptions: {
        region: awsRegion,
        credentials: {
          accessKeyId: awsAccessKeyId,
          secretAccessKey: awsSecretAccessKey,
        },
      },
    });
    const model = bedrock(bedrockModelId, {
      additionalModelRequestFields: { top_k: 350 },
    });
    return model;
  }

  const openai = createOpenAI({
    apiKey: openaiApiKey,
  });
  return openai('gpt-4o');
}

File: lib/agents/researcher.tsx (L114-114)

    model: (await getModel(hasImage)) as LanguageModel,

File: lib/agents/inquire.tsx (L27-27)

    model: (await getModel()) as LanguageModel,

File: lib/agents/query-suggestor.tsx (L59-59)

    model: (await getModel()) as LanguageModel,

File: components/settings/components/model-selection-form.tsx (L28-61)

const models = [
  {
    id: "QCX-Terra",
    name: "QCX-Terra",
    description: "Geospatial foundational model for planetary insights.",
    icon: Earth,
    badge: "Recommended",
    badgeVariant: "default" as const,
  },
  {
    id: "Grok 4.2",
    name: "Grok 4.2",
    description: "The latest from xAI, pushing the boundaries of reasoning and problem-solving.",
    icon: Rocket,
    badge: "New",
    badgeVariant: "secondary" as const,
  },
  {
    id: "Gemini 3.1 Pro",
    name: "Gemini 3.1 Pro",
    description: "Google's latest reasoning model, excelling at multimodal understanding and complex agentic tasks.",
    icon: Sparkles,
    badge: "Advanced",
    badgeVariant: "outline" as const,
  },
  {
    id: "GPT-5.1",
    name: "GPT-5.1",
    description: "The cutting-edge of language models, offering unparalleled performance in creative and analytical tasks.",
    icon: Zap,
    badge: "Expert",
    badgeVariant: "outline" as const,
  },
];

[ngoiyaeric]

@coderabbitai plan

[coderabbitai]

Coding Plan

Summary

• Leverage the existing @ai-sdk/azure package which follows the same factory pattern as other AI SDK providers already in use
• Use baseURL configuration via AZURE_OPENAI_ENDPOINT for flexibility with various Azure deployment patterns
• Default deployment name to 'gpt-5.5' with optional AZURE_OPENAI_DEPLOYMENT_NAME override
• Insert Azure as the highest-priority fallback (before Gemini) when credentials are configured
• Extend the existing models array and getModel() switch statement rather than introducing new abstractions

Design Choices

Design Choice 1: Azure endpoint configuration approach

Options Considered:

1. Use resourceName configuration which constructs URLs automatically as https://{resourceName}.openai.azure.com/openai/v1
2. Use baseURL configuration via AZURE_OPENAI_ENDPOINT environment variable, allowing direct endpoint specification

Chosen Option: 2

Rationale: The baseURL approach via AZURE_OPENAI_ENDPOINT aligns with common Azure OpenAI configuration patterns, provides flexibility for Foundry and non-standard endpoint URLs, and follows the integration pattern established in GEMINI_3.1_PRO_INTEGRATION.md where credentials are explicitly configured via environment variables.

Design Choice 2: Azure deployment name configuration

Options Considered:

1. Hardcode a fixed deployment name in the codebase
2. Use an environment variable with a sensible default fallback

Chosen Option: 2

Rationale: Default to 'gpt-5.5' as the deployment name but allow override via AZURE_OPENAI_DEPLOYMENT_NAME environment variable. This provides a working default while maintaining flexibility across different Azure configurations.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Azure Provider Infrastructure

This phase establishes the foundational dependencies and configuration required for Azure Foundry integration. The goal is to install the Azure AI SDK package and define the necessary environment variables before any application code changes.

Task 1: Add Azure AI SDK Dependency

Install the Vercel AI SDK Azure provider package to enable Azure OpenAI/Foundry model inference.

• Add @ai-sdk/azure to the project dependencies in package.json
• This package provides the createAzure factory function following the same pattern as other AI SDK providers (createOpenAI, createGoogleGenerativeAI, etc.)

Task 2: Configure Azure Environment Variables

Define the Azure-specific credentials and configuration required for authentication and deployment routing.

• Add the following environment variables to .env.local.example with documentation comments:
  • AZURE_OPENAI_ENDPOINT — The Azure OpenAI/Foundry endpoint URL (e.g., https://your-resource.openai.azure.com)
  • AZURE_OPENAI_API_KEY — The API key for the Azure OpenAI resource
  • AZURE_OPENAI_DEPLOYMENT_NAME — (Optional) The deployment name for GPT 5.5; defaults to 'gpt-5.5' if not specified
• These variables follow common Azure OpenAI naming conventions and align with the existing provider credential patterns in the codebase

🤖 Prompt for AI agents

This phase sets up the foundational Azure provider dependency and environment
variable configuration before any application code changes.

- Add `@ai-sdk/azure` as a dependency in `package.json` (install the package to
make the `createAzure` factory function available, following the same pattern as
other AI SDK provider packages like `@ai-sdk/openai`, `@ai-sdk/google`, etc.)
- Update `.env.local.example` to include the following Azure-specific
environment variables with documentation comments:
- `AZURE_OPENAI_ENDPOINT` — The Azure OpenAI/Foundry endpoint URL (e.g.,
`https://your-resource.openai.azure.com`)
  - `AZURE_OPENAI_API_KEY` — The API key for the Azure OpenAI resource
- `AZURE_OPENAI_DEPLOYMENT_NAME` — (Optional) The deployment name for GPT 5.5;
defaults to `'gpt-5.5'` if not specified
- Follow the existing naming conventions already used for other providers (e.g.,
`OPENAI_API_KEY`, `XAI_API_KEY`) when formatting and placing the new variables

Phase 2: Azure GPT 5.5 Model Integration

This phase integrates Azure GPT 5.5 into the application's model selection system, making it available to users through the settings UI and functional at inference time.

Task 1: Add Azure GPT 5.5 to Model Selection UI

Extend the model picker interface to include Azure GPT 5.5 as a selectable option alongside existing models.

• Update the models array in components/settings/components/model-selection-form.tsx to include a new entry for Azure GPT 5.5
• The new model object should include:
  • id: "Azure GPT 5.5" (used as the stored value and switch case key)
  • name: "Azure GPT 5.5" (display label)
  • description: Brief description mentioning Azure Foundry and enterprise capabilities
  • icon: Select an appropriate Lucide icon (e.g., Cloud or similar)
  • badge and badgeVariant: Appropriate badge text (e.g., "Enterprise" or "Azure")
• Position the new model logically within the existing list

Task 2: Implement Azure Provider in Model Resolution Logic

Add Azure GPT 5.5 handling to the centralized model resolution function so the correct provider is instantiated when users select this model.

• Update lib/utils/index.ts to import createAzure from @ai-sdk/azure

• Read the Azure environment variables at the top of getModel() following the existing pattern:

  • AZURE_OPENAI_ENDPOINT — required for Azure provider
  • AZURE_OPENAI_API_KEY — required for authentication
  • AZURE_OPENAI_DEPLOYMENT_NAME — optional, defaults to 'gpt-5.5'

• Add a new case in the getModel() switch statement for "Azure GPT 5.5":

  • Check if AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY are set
  • Instantiate the Azure provider using createAzure({ baseURL: endpoint, apiKey })
  • Return the model instance by calling the provider with the deployment name: azure(deploymentName)
  • Apply the same try/catch + error throwing pattern used for other explicit model selections
  • Note: The switch(selectedModel) block takes precedence over the fallback chain—when a user explicitly selects "Azure GPT 5.5", only that provider is attempted (with error on failure)

• Add Azure GPT 5.5 to the default fallback chain with the following priority order:

  Priority	Provider	Condition
  1	Azure GPT 5.5	AZURE_OPENAI_ENDPOINT + AZURE_OPENAI_API_KEY set
  2	Gemini 3.1 Pro	GEMINI_3_PRO_API_KEY set
  3	xAI Grok	XAI_API_KEY set
  4	AWS Bedrock	AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY set
  5	OpenAI GPT-4o	Final fallback (unconditional)

• Implement the Azure fallback block using the same try/catch + console.warn pattern as Gemini and Grok:

  try { return azure(deploymentName); }
  catch (error) { console.warn('Azure GPT 5.5 unavailable, falling back...', error); }
  

  This allows silent fallback to the next provider if Azure fails at runtime

🤖 Prompt for AI agents

This phase integrates Azure GPT 5.5 into the model selection UI and the
centralized model resolution logic.

**Task 1 — Model Selection UI
(`components/settings/components/model-selection-form.tsx`):**
- Add a new entry to the `models` array with the following fields:
  - `id`: `"Azure GPT 5.5"`
  - `name`: `"Azure GPT 5.5"`
- `description`: A brief description mentioning Azure Foundry and enterprise
capabilities
  - `icon`: An appropriate Lucide icon such as `Cloud`
- `badge` and `badgeVariant`: Badge text such as `"Enterprise"` or `"Azure"`
with an appropriate variant
- Position the new entry logically within the existing model list

**Task 2 — Model Resolution Logic (`lib/utils/index.ts`):**
- Import `createAzure` from `@ai-sdk/azure` at the top of the file
- Read the following environment variables at the top of `getModel()`, following
the existing pattern used for other provider credentials:
  - `AZURE_OPENAI_ENDPOINT` — required for Azure provider
  - `AZURE_OPENAI_API_KEY` — required for authentication
  - `AZURE_OPENAI_DEPLOYMENT_NAME` — optional, defaults to `'gpt-5.5'`
- Add a new case for `"Azure GPT 5.5"` in the `getModel()` switch statement:
  - Check that `AZURE_OPENAI_ENDPOINT` and `AZURE_OPENAI_API_KEY` are set
  - Instantiate the Azure provider: `createAzure({ baseURL: endpoint, apiKey })`
- Return the model by calling the provider with the deployment name:
`azure(deploymentName)`
- Apply the same try/catch + error throwing pattern used for other explicit
model selections
- The `switch(selectedModel)` block takes precedence over the fallback
chain—when a user explicitly selects "Azure GPT 5.5", only that provider is
attempted (with error on failure)
- Add Azure GPT 5.5 as the highest-priority entry in the fallback chain, ahead
of Gemini, using this priority order:
1. **Azure GPT 5.5** — when `AZURE_OPENAI_ENDPOINT` + `AZURE_OPENAI_API_KEY` are
set
  2. Gemini 3.1 Pro — when `GEMINI_3_PRO_API_KEY` is set
  3. xAI Grok — when `XAI_API_KEY` is set
  4. AWS Bedrock — when `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` are set
  5. OpenAI GPT-4o — final unconditional fallback
- Implement the Azure fallback block using the same try/catch + `console.warn`
pattern as Gemini and Grok:
  ```
  try { return azure(deploymentName); }
catch (error) { console.warn('Azure GPT 5.5 unavailable, falling back...',
error); }
  ```

Research

The application uses a centralized model resolution pattern where lib/utils/index.ts contains a getModel() function that maps user-selected model names to AI SDK provider instances. Models are displayed in components/settings/components/model-selection-form.tsx via a hardcoded array, and user selection is persisted to the database through server actions in lib/actions/users.ts. Currently supported providers include OpenAI, Google, xAI, and AWS Bedrock—Azure is not yet integrated. The Vercel AI SDK's @ai-sdk/azure package provides Azure OpenAI/Foundry support using a createAzure() factory pattern consistent with other providers. All agents (Researcher, Inquire, Query Suggestor, Writer, Task Manager, Resolution Search) consume getModel() and will automatically benefit from Azure GPT 5.5 availability through both user selection and the fallback chain.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

This phase sets up the foundational Azure provider dependency and environment
variable configuration before any application code changes.

- Add `@ai-sdk/azure` as a dependency in `package.json` (install the package to
make the `createAzure` factory function available, following the same pattern as
other AI SDK provider packages like `@ai-sdk/openai`, `@ai-sdk/google`, etc.)
- Update `.env.local.example` to include the following Azure-specific
environment variables with documentation comments:
- `AZURE_OPENAI_ENDPOINT` — The Azure OpenAI/Foundry endpoint URL (e.g.,
`https://your-resource.openai.azure.com`)
  - `AZURE_OPENAI_API_KEY` — The API key for the Azure OpenAI resource
- `AZURE_OPENAI_DEPLOYMENT_NAME` — (Optional) The deployment name for GPT 5.5;
defaults to `'gpt-5.5'` if not specified
- Follow the existing naming conventions already used for other providers (e.g.,
`OPENAI_API_KEY`, `XAI_API_KEY`) when formatting and placing the new variables
===============================================================================

Task: 2

This phase integrates Azure GPT 5.5 into the model selection UI and the
centralized model resolution logic.

**Task 1 — Model Selection UI
(`components/settings/components/model-selection-form.tsx`):**
- Add a new entry to the `models` array with the following fields:
  - `id`: `"Azure GPT 5.5"`
  - `name`: `"Azure GPT 5.5"`
- `description`: A brief description mentioning Azure Foundry and enterprise
capabilities
  - `icon`: An appropriate Lucide icon such as `Cloud`
- `badge` and `badgeVariant`: Badge text such as `"Enterprise"` or `"Azure"`
with an appropriate variant
- Position the new entry logically within the existing model list

**Task 2 — Model Resolution Logic (`lib/utils/index.ts`):**
- Import `createAzure` from `@ai-sdk/azure` at the top of the file
- Read the following environment variables at the top of `getModel()`, following
the existing pattern used for other provider credentials:
  - `AZURE_OPENAI_ENDPOINT` — required for Azure provider
  - `AZURE_OPENAI_API_KEY` — required for authentication
  - `AZURE_OPENAI_DEPLOYMENT_NAME` — optional, defaults to `'gpt-5.5'`
- Add a new case for `"Azure GPT 5.5"` in the `getModel()` switch statement:
  - Check that `AZURE_OPENAI_ENDPOINT` and `AZURE_OPENAI_API_KEY` are set
  - Instantiate the Azure provider: `createAzure({ baseURL: endpoint, apiKey })`
- Return the model by calling the provider with the deployment name:
`azure(deploymentName)`
- Apply the same try/catch + error throwing pattern used for other explicit
model selections
- The `switch(selectedModel)` block takes precedence over the fallback
chain—when a user explicitly selects "Azure GPT 5.5", only that provider is
attempted (with error on failure)
- Add Azure GPT 5.5 as the highest-priority entry in the fallback chain, ahead
of Gemini, using this priority order:
1. **Azure GPT 5.5** — when `AZURE_OPENAI_ENDPOINT` + `AZURE_OPENAI_API_KEY` are
set
  2. Gemini 3.1 Pro — when `GEMINI_3_PRO_API_KEY` is set
  3. xAI Grok — when `XAI_API_KEY` is set
  4. AWS Bedrock — when `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` are set
  5. OpenAI GPT-4o — final unconditional fallback
- Implement the Azure fallback block using the same try/catch + `console.warn`
pattern as Gemini and Grok:
  ```
  try { return azure(deploymentName); }
catch (error) { console.warn('Azure GPT 5.5 unavailable, falling back...',
error); }
  ```

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!