Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

📫 fix: Route Azure Astra Through Responses API (#15845)

Joseph Licata27acf97ad915
diff --git a/packages/api/src/agents/__tests__/initialize.test.ts b/packages/api/src/agents/__tests__/initialize.test.ts
index 7ee63434de..51ea605bab 100644
--- a/packages/api/src/agents/__tests__/initialize.test.ts
+++ b/packages/api/src/agents/__tests__/initialize.test.ts
@@ -286,6 +286,46 @@ describe('initializeAgent — execution context', () => {
jest.clearAllMocks();
});
+ it('carries request-resolved Azure identity to the run without changing persisted agent fields', async () => {
+ const { agent, req, res, loadTools, db } = createMocks({
+ provider: EModelEndpoint.azureOpenAI,
+ model: 'gpt-6-astra',
+ });
+ const azureOptions = {
+ azureOpenAIApiKey: 'request-key',
+ azureOpenAIApiInstanceName: 'request-instance',
+ azureOpenAIApiDeploymentName: 'deployment',
+ azureOpenAIApiVersion: '2024-10-21',
+ };
+ mockGetProviderConfig.mockReturnValue({
+ overrideProvider: Providers.AZURE,
+ getOptions: jest.fn().mockResolvedValue({
+ azureOptions,
+ llmConfig: {
+ model: 'gpt-6-astra',
+ useResponsesApi: true,
+ apiKey: 'request-key',
+ modelKwargs: { model: 'deployment' },
+ },
+ }),
+ });
+ const result = await initializeAgent(
+ {
+ req,
+ res,
+ agent,
+ loadTools,
+ endpointOption: { endpoint: EModelEndpoint.agents },
+ allowedProviders: new Set([EModelEndpoint.azureOpenAI]),
+ isInitialAgent: true,
+ },
+ db,
+ );
+ expect(result.azureOptions).toEqual(azureOptions);
+ expect(result.model_parameters).not.toHaveProperty('azureOpenAIApiInstanceName');
+ expect(agent).not.toHaveProperty('azureOptions');
+ });
+
it('initializes without Express request or response objects', async () => {
const { agent, loadTools, db } = createMocks();
const previousReqDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'req');
diff --git a/packages/api/src/agents/__tests__/run-summarization.test.ts b/packages/api/src/agents/__tests__/run-summarization.test.ts
index a3ff8797b9..ede0868eb4 100644
--- a/packages/api/src/agents/__tests__/run-summarization.test.ts
+++ b/packages/api/src/agents/__tests__/run-summarization.test.ts
@@ -1,4 +1,5 @@
import { encryptV3, logger } from '@librechat/data-schemas';
+import { HumanMessage, AIMessage } from '@langchain/core/messages';
import { CallbackManager } from '@langchain/core/callbacks/manager';
import {
EModelEndpoint,
@@ -6,12 +7,16 @@ import {
MAX_SUBAGENT_DEPTH,
MAX_SUBAGENT_RUN_CONFIGS,
} from 'librechat-data-provider';
-import type { CompactionSemanticIndex, SubagentTaskConfig } from '@librechat/agents';
+import type { CompactionSemanticIndex, SubagentTaskConfig, AgentInputs } from '@librechat/agents';
import type { SummarizationConfig, TEndpoint } from 'librechat-data-provider';
import type { AppConfig, IUser } from '@librechat/data-schemas';
import type { BaseMessage } from '@langchain/core/messages';
+import type { OpenAI } from 'openai';
import type { ModelBoundChatModelCallback } from '~/middleware/modelBoundContent';
+import type { OpenAIConfiguration, AzureOptions } from '~/types';
import { createRun, isAskUserQuestionAdminDisabled } from '~/agents/run';
+import { initializeOpenAI } from '~/endpoints/openai/initialize';
+import { getOpenAIConfig } from '~/endpoints/openai/config';
// Mock winston logger — `format` must be callable so @librechat/data-schemas
// dist module-load completes cleanly; see api/test/__mocks__/logger.js.
@@ -190,6 +195,7 @@ async function callAndCapture(
modelCallbacks?: readonly ModelBoundChatModelCallback[];
user?: IUser;
tenantId?: string;
+ requestBody?: Parameters<typeof createRun>[0]['requestBody'];
} = {},
) {
const agents = opts.agents ?? [makeAgent()];
@@ -209,6 +215,7 @@ async function callAndCapture(
modelCallbacks: opts.modelCallbacks,
user: opts.user,
tenantId: opts.tenantId,
+ requestBody: opts.requestBody,
streaming: true,
streamUsage: true,
});
@@ -762,12 +769,14 @@ const ADAPTIVE_CLAUDE_MODEL = 'anthropic/claude-sonnet-4.6';
/** Agent whose resolved client options already carry a reasoning configuration. */
function makeReasoningAgent(overrides: {
+ azureOptions?: AzureOptions;
provider: string;
endpoint: string;
model: string;
model_parameters: Record<string, unknown>;
}) {
return makeAgent({
+ ...overrides,
provider: overrides.provider as never,
endpoint: overrides.endpoint,
model: overrides.model,
@@ -971,6 +980,1035 @@ describe('summarization reasoning effort', () => {
});
});
+type CapturedRequest = {
+ url: URL;
+ headers: Headers;
+ body: OpenAI.ChatCompletionCreateParams & OpenAI.Responses.ResponseCreateParams;
+};
+
+async function compactSummary(
+ agents: Array<Record<string, unknown>>,
+ requests: CapturedRequest[] = [],
+) {
+ const summaryConfig = agents[0].summarizationConfig as NonNullable<
+ AgentInputs['summarizationConfig']
+ >;
+ const clientOptions = agents[0].clientOptions as { configuration?: OpenAIConfiguration };
+ const configuration = {
+ ...((summaryConfig.parameters?.configuration ??
+ clientOptions.configuration) as OpenAIConfiguration),
+ };
+ summaryConfig.parameters = { ...summaryConfig.parameters, configuration };
+ configuration.fetch = async (url, init) => {
+ requests.push({
+ url: new URL(String(url)),
+ headers: new Headers(init?.headers),
+ body: JSON.parse(String(init?.body)),
+ });
+ const text = 'The user asked for arithmetic and the assistant calculated four.';
+ return Response.json({
+ id: 'summary-response',
+ model: 'summary-production',
+ object: 'response',
+ status: 'completed',
+ choices: [{ index: 0, message: { role: 'assistant', content: text }, finish_reason: 'stop' }],
+ output: [
+ {
+ type: 'message',
+ id: 'msg_summary',
+ role: 'assistant',
+ status: 'completed',
+ content: [{ type: 'output_text', text, annotations: [] }],
+ },
+ ],
+ usage: {
+ prompt_tokens: 20,
+ completion_tokens: 10,
+ input_tokens: 20,
+ output_tokens: 10,
+ total_tokens: 30,
+ },
+ });
+ };
+ const actual = jest.requireActual<typeof import('@librechat/agents')>('@librechat/agents');
+ const runConfig = (Run.create as jest.Mock).mock.calls[0][0] as Parameters<typeof Run.create>[0];
+ const run = await actual.Run.create({
+ ...runConfig,
+ graphConfig: { ...runConfig.graphConfig, agents: agents as unknown as AgentInputs[] },
+ tokenCounter: (message) => String(message.content).length,
+ });
+ await run.processStream(
+ { messages: [new HumanMessage('Compute 2 + 2.'), new AIMessage('4')] },
+ { version: 'v2', configurable: { thread_id: 'azure-summary-test' } },
+ );
+
+ return { requests };
+}
+
+describe('Azure deployment alias', () => {
+ /** `initializeAgent` maps an Azure Responses agent to the OpenAI provider. */
+ const azureAstraAgent = () => {
+ const { llmConfig, configOptions } = getOpenAIConfig(
+ 'test-azure-key',
+ {
+ azure: {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: 'production-deployment',
+ azureOpenAIApiVersion: '2025-04-01-preview',
+ azureOpenAIApiKey: 'test-azure-key',
+ },
+ modelOptions: { model: 'gpt-6-astra', max_tokens: 2048 },
+ },
+ EModelEndpoint.azureOpenAI,
+ );
+ return makeReasoningAgent({
+ provider: EModelEndpoint.openAI,
+ endpoint: EModelEndpoint.azureOpenAI,
+ model: 'gpt-6-astra',
+ model_parameters: { ...llmConfig, configuration: configOptions },
+ });
+ };
+
+ /** The SDK spreads `parameters` onto the agent's client options, then sets `model`. */
+ const summaryRequestModel = (
+ clientOptions: Record<string, unknown>,
+ summaryConfig: Record<string, unknown>,
+ ) => {
+ const summaryModel = new ChatOpenAI({
+ ...clientOptions,
+ ...((summaryConfig.parameters as Record<string, unknown> | undefined) ?? {}),
+ apiKey: 'test-key',
+ model: summaryConfig.model as string,
+ } as never);
+ return (summaryModel.invocationParams() as Record<string, unknown>).model;
+ };
+
+ it("keeps the Astra agent's API mode and deployment alias out of a custom-endpoint summarizer", async () => {
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig: makeAppConfig([
+ {
+ name: 'Gateway',
+ apiKey: 'gateway-key',
+ baseURL: 'https://gateway.example/v1',
+ models: { default: ['gpt-4.1-mini'] },
+ },
+ ]),
+ summarizeOnly: true,
+ summarizationConfig: {
+ provider: 'Gateway',
+ model: 'gpt-4.1-mini',
+ parameters: { streaming: false },
+ },
+ });
+
+ expect((agents[0].clientOptions as Record<string, unknown>).modelKwargs).toEqual({
+ model: 'production-deployment',
+ max_output_tokens: 2048,
+ });
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ const { url, headers, body } = requests[0];
+ expect(url.origin + url.pathname).toBe('https://gateway.example/v1/chat/completions');
+ expect(headers.get('api-key')).toBeNull();
+ expect(body.model).toBe('gpt-4.1-mini');
+ expect(body).not.toHaveProperty('include');
+ });
+
+ it.each([
+ { useModelAsDeploymentName: undefined, deployment: 'env-deployment' },
+ { useModelAsDeploymentName: 'true', deployment: 'gpt-41-mini' },
+ ])(
+ 'resolves a different summary model through the legacy Azure environment to $deployment',
+ async ({ useModelAsDeploymentName, deployment }) => {
+ jest.replaceProperty(process, 'env', {
+ ...process.env,
+ AZURE_API_KEY: 'env-key',
+ AZURE_OPENAI_API_INSTANCE_NAME: 'env-instance',
+ AZURE_OPENAI_API_DEPLOYMENT_NAME: 'env-deployment',
+ AZURE_OPENAI_API_VERSION: '2024-10-21',
+ AZURE_USE_MODEL_AS_DEPLOYMENT_NAME: useModelAsDeploymentName,
+ });
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig: makeAppConfig([]),
+ summarizeOnly: true,
+ summarizationConfig: { model: 'gpt-4.1-mini', parameters: { streaming: false } },
+ });
+
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ const { url, headers, body } = requests[0];
+ expect(url.origin + url.pathname).toBe(
+ `https://env-instance.openai.azure.com/openai/deployments/${deployment}/chat/completions`,
+ );
+ expect(headers.get('api-key')).toBe('env-key');
+ expect(body.model).toBe(deployment);
+ },
+ );
+
+ it('applies summarization base URL and API key overrides to an Azure summary deployment', async () => {
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints![EModelEndpoint.azureOpenAI] = {
+ isValid: true,
+ errors: [],
+ modelNames: ['gpt-6-astra', 'gpt-4.1-mini'],
+ modelGroupMap: { 'gpt-6-astra': { group: 'main' }, 'gpt-4.1-mini': { group: 'summary' } },
+ groupMap: {
+ main: {
+ apiKey: 'test-azure-key',
+ instanceName: 'test-instance',
+ version: '2025-04-01-preview',
+ models: { 'gpt-6-astra': { deploymentName: 'production-deployment' } },
+ },
+ summary: {
+ apiKey: 'summary-key',
+ instanceName: 'summary-instance',
+ version: '2024-10-21',
+ models: { 'gpt-4.1-mini': { deploymentName: 'summary-production' } },
+ },
+ },
+ };
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig,
+ summarizeOnly: true,
+ summarizationConfig: {
+ model: 'gpt-4.1-mini',
+ parameters: {
+ streaming: false,
+ apiKey: 'gateway-key',
+ baseURL: 'https://summary-gateway.example/openai/deployments/${DEPLOYMENT_NAME}',
+ },
+ },
+ });
+
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ const { url, headers } = requests[0];
+ expect(url.origin + url.pathname).toBe(
+ 'https://summary-gateway.example/openai/deployments/summary-production/chat/completions',
+ );
+ expect(headers.get('api-key')).toBe('gateway-key');
+ });
+
+ it.each([
+ { model: 'gpt-6-astra', initialResponses: true, useResponsesApi: true },
+ { model: 'gpt-4.1', initialResponses: false, useResponsesApi: false },
+ { model: 'gpt-6-astra', initialResponses: true, useResponsesApi: false },
+ { model: 'gpt-4.1', initialResponses: false, useResponsesApi: true },
+ ])(
+ 'uses same-model Azure transport overrides for $model',
+ async ({ model, initialResponses, useResponsesApi }) => {
+ const { llmConfig, configOptions } = getOpenAIConfig(
+ 'resolved-user-key',
+ {
+ azure: {
+ azureOpenAIApiKey: 'resolved-user-key',
+ azureOpenAIApiInstanceName: 'user-instance',
+ azureOpenAIApiDeploymentName: 'user-deployment',
+ azureOpenAIApiVersion: '2024-10-21',
+ },
+ modelOptions: { model, max_tokens: 1536 },
+ headers: { 'X-Request': 'resolved-user-header' },
+ },
+ EModelEndpoint.azureOpenAI,
+ );
+ const agents = await callAndCapture({
+ agents: [
+ makeReasoningAgent({
+ endpoint: EModelEndpoint.azureOpenAI,
+ provider: initialResponses ? Providers.OPENAI : Providers.AZURE,
+ model,
+ model_parameters: { ...llmConfig, configuration: configOptions },
+ }),
+ ],
+ appConfig: makeAppConfig([]),
+ summarizeOnly: true,
+ summarizationConfig: {
+ model,
+ parameters: {
+ streaming: false,
+ apiKey: 'override-key',
+ useResponsesApi,
+ baseURL:
+ 'https://summary-instance.openai.azure.com/openai/deployments/${DEPLOYMENT_NAME}',
+ },
+ },
+ });
+ expect(agents[0].summarizationEnabled).toBe(true);
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ expect(requests[0].url.origin + requests[0].url.pathname).toBe(
+ useResponsesApi
+ ? 'https://summary-instance.openai.azure.com/openai/v1/responses'
+ : 'https://summary-instance.openai.azure.com/openai/deployments/user-deployment/chat/completions',
+ );
+ expect(requests[0].headers.get('api-key')).toBe('override-key');
+ expect(requests[0].headers.get('X-Request')).toBe('resolved-user-header');
+ expect(requests[0].body.model).toBe('user-deployment');
+ const chatTokenKey = model === 'gpt-6-astra' ? 'max_completion_tokens' : 'max_tokens';
+ expect(requests[0].body[useResponsesApi ? 'max_output_tokens' : chatTokenKey]).toBe(1536);
+ expect((agents[0].clientOptions as Record<string, unknown>).configuration).toEqual(
+ configOptions,
+ );
+ },
+ );
+
+ it.each(['root', 'lazy'])(
+ 'retains Azure identity and resolved headers for a %s self-summary',
+ async (kind) => {
+ jest.replaceProperty(process, 'env', {
+ ...process.env,
+ AZURE_API_KEY: 'user_provided',
+ SUMMARY_HEADER_SECRET: 'must-not-leak',
+ });
+ const user = { id: 'user-1', username: '${SUMMARY_HEADER_SECRET}' };
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints!.all = {
+ headers: {
+ 'X-Conversation': '{{LIBRECHAT_BODY_CONVERSATIONID}}',
+ 'X-Tenant': '{{LIBRECHAT_USER_TENANTID}}',
+ 'X-User': '{{LIBRECHAT_USER_USERNAME}}',
+ },
+ };
+ const getUserKeyValues = jest.fn().mockResolvedValue({
+ apiKey: JSON.stringify({
+ azureOpenAIApiKey: 'user-key',
+ azureOpenAIApiInstanceName: 'user-instance',
+ azureOpenAIApiDeploymentName: 'user-deployment',
+ azureOpenAIApiVersion: '2024-10-21',
+ }),
+ });
+ const options = await initializeOpenAI({
+ endpoint: EModelEndpoint.azureOpenAI,
+ model_parameters: { model: 'gpt-6-astra' },
+ runtime: { appConfig, user, requestBody: {} },
+ db: { getUserKeyValues },
+ } as unknown as Parameters<typeof initializeOpenAI>[0]);
+ const azureAgent = {
+ ...makeReasoningAgent({
+ endpoint: EModelEndpoint.azureOpenAI,
+ provider: Providers.OPENAI,
+ model: 'gpt-6-astra',
+ azureOptions: options.azureOptions,
+ model_parameters: { ...options.llmConfig, configuration: options.configOptions },
+ }),
+ id: 'azure-child',
+ };
+ const lazyParent = makeAgent({
+ id: 'parent',
+ summarization: { enabled: false },
+ subagents: { enabled: true, allowSelf: false },
+ lazySubagentConfigs: [
+ {
+ id: azureAgent.id,
+ name: 'Azure child',
+ description: 'Lazy Azure child',
+ configId: 'azure-child:1:test',
+ resolve: jest.fn().mockResolvedValue(azureAgent),
+ },
+ ],
+ });
+ const captured = await callAndCapture({
+ agents: kind === 'lazy' ? [lazyParent] : [azureAgent],
+ appConfig,
+ user: user as IUser,
+ tenantId: 'tenant-1',
+ requestBody: { conversationId: 'conversation-1' },
+ summarizeOnly: true,
+ summarizationConfig: {
+ parameters: {
+ streaming: false,
+ baseURL:
+ 'https://${INSTANCE_NAME}.openai.azure.com/openai/deployments/${DEPLOYMENT_NAME}',
+ },
+ },
+ });
+ let selected = captured[0];
+ if (kind === 'lazy') {
+ const [child] = captured[0].subagentConfigs as Array<Record<string, unknown>>;
+ selected = await (
+ child.resolveAgentInputs as (context: never) => Promise<Record<string, unknown>>
+ )({ signal: new AbortController().signal } as never);
+ selected.summarizeOnly = true;
+ }
+ const agents = [selected];
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ expect(requests[0].url.origin + requests[0].url.pathname).toBe(
+ 'https://user-instance.openai.azure.com/openai/v1/responses',
+ );
+ expect(requests[0].body.model).toBe('user-deployment');
+ expect(requests[0].headers.get('api-key')).toBe('user-key');
+ expect(requests[0].headers.get('X-Conversation')).toBe('conversation-1');
+ expect(requests[0].headers.get('X-Tenant')).toBe('tenant-1');
+ expect(requests[0].headers.get('X-User')).toBe('${SUMMARY_HEADER_SECRET}');
+ const mainConfiguration = (agents[0].clientOptions as Record<string, unknown>)
+ .configuration as OpenAIConfiguration;
+ expect(new Headers(mainConfiguration?.defaultHeaders as HeadersInit).get('X-User')).toBe(
+ '${SUMMARY_HEADER_SECRET}',
+ );
+ expect(getUserKeyValues).toHaveBeenCalledTimes(1);
+ },
+ );
+
+ it.each([
+ { parameterCap: undefined, expected: 512 },
+ { parameterCap: '128', expected: 512 },
+ { parameterCap: 0, expected: 512 },
+ { parameterCap: 256, expected: 256 },
+ ])(
+ 'honors the summary token cap with parameter cap $parameterCap',
+ async ({ parameterCap, expected }) => {
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ summarizeOnly: true,
+ summarizationConfig: {
+ maxSummaryTokens: 512,
+ parameters: {
+ streaming: false,
+ ...(parameterCap !== undefined ? { maxSummaryTokens: parameterCap } : {}),
+ },
+ },
+ });
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ expect(requests[0].body.max_output_tokens).toBe(expected);
+ expect(requests[0].body.model).toBe('production-deployment');
+ },
+ );
+
+ it.each([
+ { nested: false, useResponsesApi: true },
+ { nested: true, useResponsesApi: true },
+ { nested: false, useResponsesApi: false },
+ ])(
+ 'normalizes final Azure transport (nested: $nested, Responses: $useResponsesApi)',
+ async ({ nested, useResponsesApi }) => {
+ const model = 'gpt-4.1-mini';
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints!.azureOpenAI = {
+ isValid: true,
+ errors: [],
+ modelNames: [model],
+ modelGroupMap: { [model]: { group: 'summary' } },
+ groupMap: {
+ summary: {
+ apiKey: 'summary-key',
+ instanceName: 'summary-instance',
+ version: '2024-10-21',
+ models: { [model]: { deploymentName: 'summary-production' } },
+ addParams: { useResponsesApi: !useResponsesApi },
+ },
+ },
+ };
+ const baseURL =
+ 'https://${INSTANCE_NAME}.openai.azure.com/openai/deployments/${DEPLOYMENT_NAME}?api-version=2025-04-01-preview';
+ const parameters = {
+ streaming: false,
+ useResponsesApi,
+ ...(nested
+ ? { configuration: { baseURL, defaultHeaders: { 'X-Override': 'yes' } } }
+ : { baseURL }),
+ } as unknown as SummarizationConfig['parameters'];
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig,
+ summarizeOnly: true,
+ summarizationConfig: { model, parameters },
+ });
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ expect(requests[0].url.origin + requests[0].url.pathname).toBe(
+ useResponsesApi
+ ? 'https://summary-instance.openai.azure.com/openai/v1/responses'
+ : 'https://summary-instance.openai.azure.com/openai/deployments/summary-production/chat/completions',
+ );
+ expect(requests[0].headers.get('api-key')).toBe('summary-key');
+ expect(requests[0].body.model).toBe('summary-production');
+ if (nested) expect(requests[0].headers.get('X-Override')).toBe('yes');
+ if (useResponsesApi)
+ expect(requests[0].url.searchParams.get('api-version')).toBe('2025-04-01-preview');
+ },
+ );
+
+ it.each([EModelEndpoint.azureOpenAI, EModelEndpoint.openAI])(
+ 'disables an invalid %s summary URL before constructing a run client',
+ async (provider) => {
+ jest.replaceProperty(process, 'env', { ...process.env, OPENAI_API_KEY: 'summary-key' });
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig: makeAppConfig([]),
+ summarizeOnly: true,
+ summarizationConfig: {
+ provider,
+ model: 'gpt-6-astra',
+ parameters: { streaming: false, baseURL: 'not a URL' },
+ },
+ });
+ expect(agents[0].summarizationEnabled).toBe(false);
+ const requests: CapturedRequest[] = [];
+ await expect(compactSummary(agents, requests)).rejects.toThrow(
+ 'Compaction skipped: summarization is not enabled for this agent',
+ );
+ expect(requests).toHaveLength(0);
+ },
+ );
+
+ it('keeps the deployment alias when the summarizer runs the agent model', async () => {
+ const agents = await callAndCapture({ agents: [azureAstraAgent()] });
+
+ const mainClientOptions = agents[0].clientOptions as Record<string, unknown>;
+ const summaryConfig = agents[0].summarizationConfig as Record<string, unknown>;
+
+ expect(summaryConfig.parameters).toBeUndefined();
+ expect(summaryRequestModel(mainClientOptions, summaryConfig)).toBe('production-deployment');
+ });
+
+ it.each<{
+ model: string;
+ deployed: boolean;
+ proxy?: string;
+ parameters?: SummarizationConfig['parameters'];
+ }>([
+ { model: 'gpt-4.1-mini', deployed: false, proxy: undefined },
+ { model: 'gpt-4.1-mini', deployed: true, proxy: undefined },
+ { model: 'gpt-6-astra', deployed: true, proxy: undefined },
+ { model: 'gpt-4.1-mini', deployed: false, proxy: 'https://summary-gateway.example/v1' },
+ {
+ model: 'gpt-6-astra',
+ deployed: true,
+ parameters: { useResponsesApi: false, apiKey: 'override-key' },
+ },
+ {
+ model: 'gpt-4.1-mini',
+ deployed: false,
+ parameters: { baseURL: 'https://per-summary.example/v1', useResponsesApi: true },
+ },
+ ])(
+ 'honors explicit OpenAI for $model (Azure deployed: $deployed, proxy: $proxy)',
+ async ({ model, deployed, proxy, parameters }) => {
+ jest.replaceProperty(process, 'env', {
+ ...process.env,
+ OPENAI_API_KEY: 'openai-summary-key',
+ OPENAI_REVERSE_PROXY: proxy,
+ });
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints!.all = { headers: { 'X-Global': 'global' } };
+ appConfig.endpoints!.openAI = { headers: { 'X-Summary': 'openai' } };
+ appConfig.endpoints!.azureOpenAI = {
+ isValid: true,
+ errors: [],
+ modelNames: deployed ? [model] : [],
+ modelGroupMap: deployed ? { [model]: { group: 'azure' } } : {},
+ groupMap: {
+ azure: {
+ apiKey: 'test-azure-key',
+ instanceName: 'test-instance',
+ version: '2025-04-01-preview',
+ models: { [model]: { deploymentName: 'production-deployment' } },
+ },
+ },
+ };
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig,
+ summarizeOnly: true,
+ summarizationConfig: {
+ provider: EModelEndpoint.openAI,
+ model,
+ parameters: { streaming: false, ...parameters },
+ },
+ });
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ const { url, headers, body } = requests[0];
+ const baseURL = parameters?.baseURL ?? proxy;
+ expect(url.origin).toBe(
+ typeof baseURL === 'string' ? new URL(baseURL).origin : 'https://api.openai.com',
+ );
+ const usesResponses = parameters?.useResponsesApi ?? model === 'gpt-6-astra';
+ expect(url.pathname).toBe(usesResponses ? '/v1/responses' : '/v1/chat/completions');
+ expect(url.search).toBe('');
+ expect(headers.get('authorization')).toBe(
+ `Bearer ${parameters?.apiKey ?? 'openai-summary-key'}`,
+ );
+ expect(headers.has('api-key')).toBe(false);
+ expect(headers.get('X-Global')).toBe('global');
+ expect(headers.get('X-Summary')).toBe('openai');
+ expect(body.model).toBe(model);
+ expect(body).not.toHaveProperty('max_output_tokens', 2048);
+ expect((agents[0].clientOptions as OpenAIConfiguration)?.apiKey).toBe('test-azure-key');
+ },
+ );
+
+ it.each([
+ { setting: 'OPENAI_API_KEY', value: undefined, model: 'gpt-4.1-mini' },
+ { setting: 'OPENAI_API_KEY', value: 'user_provided', model: 'gpt-4.1-nano' },
+ { setting: 'OPENAI_REVERSE_PROXY', value: 'user_provided', model: 'gpt-4o-mini' },
+ ])(
+ 'runs the agent without summarization, not through Azure, when $setting is $value',
+ async ({ setting, value, model }) => {
+ jest.replaceProperty(process, 'env', {
+ ...process.env,
+ OPENAI_API_KEY: 'openai-summary-key',
+ [setting]: value,
+ });
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig: makeAppConfig([]),
+ summarizeOnly: true,
+ summarizationConfig: {
+ provider: EModelEndpoint.openAI,
+ model,
+ parameters: { streaming: false },
+ },
+ });
+
+ expect(agents[0].summarizationEnabled).toBe(false);
+ expect(logger.warn).toHaveBeenCalledWith(
+ `[createRun] Summarization with OpenAI model "${model}" is disabled for Azure OpenAI agents: it needs a server-configured OpenAI API key and base URL.`,
+ );
+ const requests: CapturedRequest[] = [];
+ await expect(compactSummary(agents, requests)).rejects.toThrow(
+ 'Compaction skipped: summarization is not enabled for this agent',
+ );
+ expect(requests).toHaveLength(0);
+ },
+ );
+
+ it('reports an unreachable OpenAI summarizer once per tenant across runs', async () => {
+ jest.replaceProperty(process, 'env', { ...process.env, OPENAI_API_KEY: undefined });
+ const run = (tenantId?: string) =>
+ callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig: makeAppConfig([]),
+ tenantId,
+ summarizationConfig: { provider: EModelEndpoint.openAI, model: 'o4-mini' },
+ });
+
+ for (const tenantId of [undefined, undefined, 'tenant-a', 'tenant-a', 'tenant-b']) {
+ (Run.create as jest.Mock).mockClear();
+ await run(tenantId);
+ }
+
+ const warnings = (logger.warn as jest.Mock).mock.calls.filter(([message]) =>
+ String(message).includes('"o4-mini"'),
+ );
+ expect(warnings.map(([, meta]) => meta)).toEqual([
+ undefined,
+ { tenantId: 'tenant-a' },
+ { tenantId: 'tenant-b' },
+ ]);
+ });
+
+ it('expands environment placeholders in OpenAI and Azure summarizer credentials', async () => {
+ jest.replaceProperty(process, 'env', {
+ ...process.env,
+ OPENAI_API_KEY: 'openai-summary-key',
+ SUMMARY_OPENAI_KEY: 'expanded-openai-key',
+ SUMMARY_OPENAI_URL: 'https://expanded-gateway.example/v1',
+ SUMMARY_AZURE_KEY: 'expanded-azure-key',
+ });
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints![EModelEndpoint.azureOpenAI] = {
+ isValid: true,
+ errors: [],
+ modelNames: ['gpt-6-astra', 'gpt-4.1-mini'],
+ modelGroupMap: { 'gpt-6-astra': { group: 'main' }, 'gpt-4.1-mini': { group: 'summary' } },
+ groupMap: {
+ main: {
+ apiKey: 'test-azure-key',
+ instanceName: 'test-instance',
+ version: '2025-04-01-preview',
+ models: { 'gpt-6-astra': { deploymentName: 'production-deployment' } },
+ },
+ summary: {
+ apiKey: 'summary-key',
+ instanceName: 'summary-instance',
+ version: '2024-10-21',
+ models: { 'gpt-4.1-mini': { deploymentName: 'summary-production' } },
+ },
+ },
+ };
+ const compact = async (summarizationConfig: SummarizationConfig) => {
+ (Run.create as jest.Mock).mockClear();
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig,
+ summarizeOnly: true,
+ summarizationConfig,
+ });
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ return requests[0];
+ };
+
+ const openAI = await compact({
+ provider: EModelEndpoint.openAI,
+ model: 'gpt-4.1-mini',
+ parameters: {
+ streaming: false,
+ apiKey: '${SUMMARY_OPENAI_KEY}',
+ baseURL: '${SUMMARY_OPENAI_URL}',
+ },
+ });
+ expect(openAI.url.origin).toBe('https://expanded-gateway.example');
+ expect(openAI.headers.get('authorization')).toBe('Bearer expanded-openai-key');
+
+ const azure = await compact({
+ model: 'gpt-4.1-mini',
+ parameters: { streaming: false, apiKey: '${SUMMARY_AZURE_KEY}' },
+ });
+ expect(azure.url.origin).toBe('https://summary-instance.openai.azure.com');
+ expect(azure.headers.get('api-key')).toBe('expanded-azure-key');
+ });
+
+ it("leaves Azure's reserved URL templates to the summary deployment", async () => {
+ jest.replaceProperty(process, 'env', {
+ ...process.env,
+ INSTANCE_NAME: 'host-instance',
+ DEPLOYMENT_NAME: 'host-deployment',
+ SUMMARY_GATEWAY_PATH: 'openai',
+ });
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints![EModelEndpoint.azureOpenAI] = {
+ isValid: true,
+ errors: [],
+ modelNames: ['gpt-6-astra', 'gpt-4.1-mini'],
+ modelGroupMap: { 'gpt-6-astra': { group: 'main' }, 'gpt-4.1-mini': { group: 'summary' } },
+ groupMap: {
+ main: {
+ apiKey: 'test-azure-key',
+ instanceName: 'test-instance',
+ version: '2025-04-01-preview',
+ models: { 'gpt-6-astra': { deploymentName: 'production-deployment' } },
+ },
+ summary: {
+ apiKey: 'summary-key',
+ instanceName: 'summary-instance',
+ version: '2024-10-21',
+ models: { 'gpt-4.1-mini': { deploymentName: 'summary-production' } },
+ },
+ },
+ };
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig,
+ summarizeOnly: true,
+ summarizationConfig: {
+ model: 'gpt-4.1-mini',
+ parameters: {
+ streaming: false,
+ baseURL:
+ 'https://${INSTANCE_NAME}.openai.azure.com/${SUMMARY_GATEWAY_PATH}/deployments/${DEPLOYMENT_NAME}',
+ },
+ },
+ });
+
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ const { url } = requests[0];
+ expect(url.origin + url.pathname).toBe(
+ 'https://summary-instance.openai.azure.com/openai/deployments/summary-production/chat/completions',
+ );
+ });
+
+ it('expands Azure-reserved names as ordinary variables for an OpenAI summarizer', async () => {
+ jest.replaceProperty(process, 'env', {
+ ...process.env,
+ OPENAI_API_KEY: 'openai-summary-key',
+ INSTANCE_NAME: 'gateway-host',
+ });
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig: makeAppConfig([]),
+ summarizeOnly: true,
+ summarizationConfig: {
+ provider: EModelEndpoint.openAI,
+ model: 'gpt-4.1-mini',
+ parameters: { streaming: false, baseURL: 'https://${INSTANCE_NAME}.example/v1' },
+ },
+ });
+
+ expect(agents[0].summarizationEnabled).toBe(true);
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ expect(requests[0].url.origin).toBe('https://gateway-host.example');
+ });
+
+ it('disables summarization when a credential placeholder has no environment value', async () => {
+ jest.replaceProperty(process, 'env', { ...process.env, OPENAI_API_KEY: 'openai-summary-key' });
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig: makeAppConfig([]),
+ summarizeOnly: true,
+ summarizationConfig: {
+ provider: EModelEndpoint.openAI,
+ model: 'gpt-4.1',
+ parameters: { streaming: false, apiKey: '${UNSET_SUMMARY_KEY}' },
+ },
+ });
+
+ expect(agents[0].summarizationEnabled).toBe(false);
+ const requests: CapturedRequest[] = [];
+ await expect(compactSummary(agents, requests)).rejects.toThrow(
+ 'Compaction skipped: summarization is not enabled for this agent',
+ );
+ expect(requests).toHaveLength(0);
+ });
+
+ it.each([
+ {
+ name: 'an inherited summary model absent from the Azure map',
+ agent: () => azureAstraAgent(),
+ summarizationConfig: { model: 'gpt-5.4-nano' },
+ env: {},
+ reason: 'Model named "gpt-5.4-nano" not found in configuration.',
+ },
+ {
+ name: 'an explicit Azure summary model absent from the map on a non-Azure agent',
+ agent: () => makeAgent(),
+ summarizationConfig: { provider: EModelEndpoint.azureOpenAI, model: 'gpt-5.4-mini' },
+ env: {},
+ reason: 'Model named "gpt-5.4-mini" not found in configuration.',
+ },
+ {
+ name: 'a mapped summary group whose base URL is user-provided',
+ agent: () => azureAstraAgent(),
+ summarizationConfig: { model: 'gpt-4.1' },
+ env: { AZURE_OPENAI_BASEURL: 'user_provided' },
+ reason: 'it needs a server-configured Azure OpenAI API key and base URL.',
+ },
+ {
+ name: 'a mapped summary group with an empty API key',
+ agent: () => azureAstraAgent(),
+ summarizationConfig: { model: 'gpt-4.1-nano' },
+ env: {},
+ summaryApiKey: '',
+ reason: 'it needs a server-configured Azure OpenAI API key and base URL.',
+ },
+ {
+ name: 'a legacy Azure environment whose key is user-provided',
+ agent: () => azureAstraAgent(),
+ summarizationConfig: { model: 'gpt-4o' },
+ env: { AZURE_API_KEY: 'user_provided' },
+ legacyEnvironment: true,
+ reason: 'it needs a server-configured Azure OpenAI API key and base URL.',
+ },
+ ])('disables summarization for $name', async (target) => {
+ const { agent, summarizationConfig, env, reason } = target;
+ jest.replaceProperty(process, 'env', { ...process.env, ...env });
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints![EModelEndpoint.azureOpenAI] = target.legacyEnvironment
+ ? undefined
+ : {
+ isValid: true,
+ errors: [],
+ modelNames: ['gpt-6-astra', 'gpt-4.1', 'gpt-4.1-nano'],
+ modelGroupMap: {
+ 'gpt-6-astra': { group: 'main' },
+ 'gpt-4.1': { group: 'summary' },
+ 'gpt-4.1-nano': { group: 'summary' },
+ },
+ groupMap: {
+ main: {
+ apiKey: 'test-azure-key',
+ instanceName: 'test-instance',
+ version: '2025-04-01-preview',
+ models: { 'gpt-6-astra': { deploymentName: 'production-deployment' } },
+ },
+ summary: {
+ apiKey: target.summaryApiKey ?? 'summary-key',
+ instanceName: 'summary-instance',
+ version: '2024-10-21',
+ models: {
+ 'gpt-4.1': { deploymentName: 'summary-production' },
+ 'gpt-4.1-nano': { deploymentName: 'summary-nano' },
+ },
+ },
+ },
+ };
+ const agents = await callAndCapture({
+ agents: [agent()],
+ appConfig,
+ summarizeOnly: true,
+ summarizationConfig: { ...summarizationConfig, parameters: { streaming: false } },
+ });
+
+ expect(agents[0].summarizationEnabled).toBe(false);
+ expect(logger.warn).toHaveBeenCalledWith(
+ `[createRun] Summarization with Azure OpenAI model "${summarizationConfig.model}" is disabled: ${reason}`,
+ );
+ const requests: CapturedRequest[] = [];
+ await expect(compactSummary(agents, requests)).rejects.toThrow(
+ 'Compaction skipped: summarization is not enabled for this agent',
+ );
+ expect(requests).toHaveLength(0);
+ });
+
+ it("sends a summary deployment to its own resource when only the agent's group sets a base URL", async () => {
+ const agentBaseURL =
+ 'https://agent-instance.openai.azure.com/openai/deployments/${DEPLOYMENT_NAME}';
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints![EModelEndpoint.azureOpenAI] = {
+ isValid: true,
+ errors: [],
+ modelNames: ['gpt-4.1', 'gpt-4.1-mini'],
+ modelGroupMap: { 'gpt-4.1': { group: 'main' }, 'gpt-4.1-mini': { group: 'summary' } },
+ groupMap: {
+ main: {
+ apiKey: 'test-azure-key',
+ instanceName: 'agent-instance',
+ baseURL: agentBaseURL,
+ version: '2024-10-21',
+ models: { 'gpt-4.1': { deploymentName: 'agent-deployment' } },
+ },
+ summary: {
+ apiKey: 'summary-key',
+ instanceName: 'summary-instance',
+ version: '2024-10-21',
+ models: { 'gpt-4.1-mini': { deploymentName: 'summary-production' } },
+ },
+ },
+ };
+ const { llmConfig, configOptions } = getOpenAIConfig(
+ 'test-azure-key',
+ {
+ reverseProxyUrl: agentBaseURL,
+ azure: {
+ azureOpenAIApiInstanceName: 'agent-instance',
+ azureOpenAIApiDeploymentName: 'agent-deployment',
+ azureOpenAIApiVersion: '2024-10-21',
+ azureOpenAIApiKey: 'test-azure-key',
+ },
+ modelOptions: { model: 'gpt-4.1' },
+ },
+ EModelEndpoint.azureOpenAI,
+ );
+ const agents = await callAndCapture({
+ agents: [
+ makeReasoningAgent({
+ provider: EModelEndpoint.azureOpenAI,
+ endpoint: EModelEndpoint.azureOpenAI,
+ model: 'gpt-4.1',
+ model_parameters: { ...llmConfig, configuration: configOptions },
+ }),
+ ],
+ appConfig,
+ summarizeOnly: true,
+ summarizationConfig: { model: 'gpt-4.1-mini', parameters: { streaming: false } },
+ });
+
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ const { url, headers, body } = requests[0];
+ expect(url.origin + url.pathname).toBe(
+ 'https://summary-instance.openai.azure.com/openai/deployments/summary-production/chat/completions',
+ );
+ expect(headers.get('api-key')).toBe('summary-key');
+ expect(body.model).toBe('summary-production');
+ });
+
+ it('sends no empty api-version to a serverless summary group without a version', async () => {
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints![EModelEndpoint.azureOpenAI] = {
+ isValid: true,
+ errors: [],
+ modelNames: ['gpt-6-astra', 'Phi-4'],
+ modelGroupMap: { 'gpt-6-astra': { group: 'main' }, 'Phi-4': { group: 'serverless' } },
+ groupMap: {
+ main: {
+ apiKey: 'test-azure-key',
+ instanceName: 'test-instance',
+ version: '2025-04-01-preview',
+ models: { 'gpt-6-astra': { deploymentName: 'production-deployment' } },
+ },
+ serverless: {
+ apiKey: 'serverless-key',
+ baseURL: 'https://phi-instance.services.ai.azure.com/models',
+ serverless: true,
+ models: { 'Phi-4': true },
+ },
+ },
+ };
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig,
+ summarizeOnly: true,
+ summarizationConfig: { model: 'Phi-4', parameters: { streaming: false } },
+ });
+
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ const { url, headers } = requests[0];
+ expect(url.origin + url.pathname).toBe(
+ 'https://phi-instance.services.ai.azure.com/models/chat/completions',
+ );
+ expect(url.search).toBe('');
+ expect(headers.get('api-key')).toBe('serverless-key');
+ });
+
+ it.each([
+ { summaryModel: 'gpt-4.1-mini', instance: 'test-instance', provider: undefined },
+ {
+ summaryModel: 'gpt-4.1-mini',
+ instance: 'summary-instance',
+ provider: EModelEndpoint.azureOpenAI,
+ },
+ { summaryModel: 'gpt-6-astra-2026-09-03', instance: 'summary-instance', provider: undefined },
+ ])(
+ 'compacts with $summaryModel on $instance using its configured deployment',
+ async ({ summaryModel, instance, provider }) => {
+ const appConfig = makeAppConfig([]);
+ appConfig.endpoints![EModelEndpoint.azureOpenAI] = {
+ isValid: true,
+ errors: [],
+ modelNames: ['gpt-6-astra', summaryModel],
+ modelGroupMap: { 'gpt-6-astra': { group: 'main' }, [summaryModel]: { group: 'summary' } },
+ groupMap: {
+ main: {
+ apiKey: 'test-azure-key',
+ instanceName: 'test-instance',
+ version: '2025-04-01-preview',
+ models: { 'gpt-6-astra': { deploymentName: 'production-deployment' } },
+ },
+ summary: {
+ apiKey: 'summary-key',
+ instanceName: instance,
+ baseURL: `https://${instance}.openai.azure.com`,
+ version: '2025-04-01-preview',
+ additionalHeaders: { 'X-Summary-Group': 'summary' },
+ models: { [summaryModel]: { deploymentName: 'summary-production' } },
+ },
+ },
+ };
+ const agents = await callAndCapture({
+ agents: [azureAstraAgent()],
+ appConfig,
+ summarizeOnly: true,
+ summarizationConfig: { model: summaryModel, provider, parameters: { streaming: false } },
+ });
+ const { requests } = await compactSummary(agents);
+ expect(requests).toHaveLength(1);
+ const { url, headers, body } = requests[0];
+ const usesResponses = summaryModel.startsWith('gpt-6-astra');
+ expect(url.origin).toBe(`https://${instance}.openai.azure.com`);
+ expect(url.pathname).toBe(
+ usesResponses
+ ? '/openai/v1/responses'
+ : '/openai/deployments/summary-production/chat/completions',
+ );
+ expect(headers.get('api-key')).toBe('summary-key');
+ expect(headers.get('X-Summary-Group')).toBe('summary');
+ expect(body.model).toBe('summary-production');
+ expect(body).not.toHaveProperty('max_output_tokens', 2048);
+ expect((agents[0].clientOptions as OpenAIConfiguration)?.apiKey).toBe('test-azure-key');
+ },
+ );
+});
+
// ---------------------------------------------------------------------------
// Suite 5: Multi-agent + per-agent overrides
// ---------------------------------------------------------------------------
diff --git a/packages/api/src/agents/initialize.ts b/packages/api/src/agents/initialize.ts
index c1e720392e..f36ffc49f5 100644
--- a/packages/api/src/agents/initialize.ts
+++ b/packages/api/src/agents/initialize.ts
@@ -605,6 +605,8 @@ function resolveProviderToolConflicts({
* Extended agent type with additional fields needed after initialization
*/
export type InitializedAgent = Agent & {
+ /** Request-resolved Azure identity for self-summarization; never persisted on the agent. */
+ azureOptions?: InitializeResultBase['azureOptions'];
tools: GenericTool[];
/** @deprecated use requestAttachments or agentContextAttachments based on sharing semantics. */
attachments: IMongoFile[];
@@ -2363,6 +2365,7 @@ export async function initializeAgent(
const initializedAgent: InitializedAgent = {
...agent,
+ azureOptions: options.azureOptions,
resendFiles,
imageDetail,
toolRegistry,
diff --git a/packages/api/src/agents/run.ts b/packages/api/src/agents/run.ts
index 2c95d4d5e6..c6287521cc 100644
--- a/packages/api/src/agents/run.ts
+++ b/packages/api/src/agents/run.ts
@@ -11,6 +11,7 @@ import {
extractEnvVariable,
providerEndpointMap,
normalizeEndpointName,
+ mapModelToAzureConfig,
resolveUseResponsesApi,
} from 'librechat-data-provider';
import type {
@@ -37,6 +38,7 @@ import type {
import type {
Agent,
ImageDetail,
+ TAzureConfig,
CodeApprovalMode,
TAgentsEndpoint,
AgentModelParameters,
@@ -106,11 +108,12 @@ import {
} from '~/agents/config';
import { applyCustomHandoffPromptKeyCompatibility } from '~/agents/handoffPromptKeyCompatibility';
import { stripIntentFromToolRegistry, stripIntentFromToolDefinitions } from '~/agents/intent';
+import { resolveConfigHeaders, resolveModelHeaders, mergeHeaders } from '~/utils/headers';
import { extractDefaultParams, resolveReasoningParams } from '~/endpoints/openai/llm';
import { getLLMConfig as getAnthropicLLMConfig } from '~/endpoints/anthropic/llm';
import { CREATE_FILE_TOOL_NAME, EDIT_FILE_TOOL_NAME } from '~/agents/tools';
-import { resolveConfigHeaders, resolveModelHeaders } from '~/utils/headers';
import { buildAgentInitialToolSessions } from '~/agents/codeFilesSession';
+import { getAzureCredentials, constructAzureURL } from '~/utils/azure';
import { getBuiltInBaseURL } from '~/endpoints/openai/initialize';
import { getProviderConfig } from '~/endpoints/config/providers';
import { buildToolApprovalHooks } from '~/agents/hitl/hooks';
@@ -413,6 +416,7 @@ export function shouldReplayReasoningContent(
}
type RunAgent = Omit<Agent, 'tools'> & {
+ azureOptions?: t.AzureOptions;
tools?: GenericTool[];
maxContextTokens?: number;
/** Pre-ratio context budget from initializeAgent. */
@@ -577,20 +581,68 @@ function normalizeAgentModelParameters(
* Merges user-supplied summarization parameters on top of endpoint-resolved
* overrides. User params win for top-level keys; `configuration` is
* deep-merged so user additions (e.g. `defaultQuery`) don't wipe out the
- * resolved `baseURL`/`defaultHeaders`/`fetchOptions`.
+ * resolved `baseURL`/`defaultHeaders`/`fetchOptions`. When transport resolution already
+ * consumed the user's URL, retain its normalized form instead of restoring the raw template.
*/
function mergeParameters(
overrides: SummarizationClientOverrides,
userParams: SummarizationConfig['parameters'],
+ resolvedTransport = false,
): Record<string, unknown> {
const merged: Record<string, unknown> = { ...overrides, ...(userParams ?? {}) };
const userConfiguration = (userParams as Record<string, unknown> | undefined)?.configuration;
if (isPlainObject(overrides.configuration) && isPlainObject(userConfiguration)) {
- merged.configuration = { ...overrides.configuration, ...userConfiguration };
+ merged.configuration = {
+ ...overrides.configuration,
+ ...userConfiguration,
+ ...(resolvedTransport ? { baseURL: overrides.configuration.baseURL } : {}),
+ defaultHeaders: mergeHeaders(
+ overrides.configuration.defaultHeaders as Record<string, string> | undefined,
+ userConfiguration.defaultHeaders as Record<string, string> | undefined,
+ ),
+ defaultQuery: {
+ ...(isPlainObject(overrides.configuration.defaultQuery)
+ ? overrides.configuration.defaultQuery
+ : {}),
+ ...(isPlainObject(userConfiguration.defaultQuery) ? userConfiguration.defaultQuery : {}),
+ },
+ };
}
return merged;
}
+/** `model_parameters` is the agent's resolved `llmConfig`, whose kwargs the schema type omits. */
+function agentModelKwargs(
+ modelParameters: AgentModelParameters | undefined,
+): Record<string, unknown> | undefined {
+ if (modelParameters == null || !('modelKwargs' in modelParameters)) {
+ return undefined;
+ }
+ return isPlainObject(modelParameters.modelKwargs) ? modelParameters.modelKwargs : undefined;
+}
+
+/**
+ * `getOpenAILLMConfig` carries an Azure Astra deployment alias in
+ * `modelKwargs.model`, which langchain spreads after `model`. The SDK's
+ * same-provider summarizer copies the agent's client options and overrides only
+ * `model`, so a summarizer on another model would still reach the agent's
+ * deployment. Hand it the agent's kwargs without the alias.
+ */
+function summarizationModelKwargs(
+ agentKwargs: Record<string, unknown> | undefined,
+ agentModel: string | undefined,
+ summarizationModel: string | undefined,
+): Record<string, unknown> | undefined {
+ if (agentKwargs == null || !('model' in agentKwargs)) {
+ return undefined;
+ }
+ if (!isNonEmptyString(summarizationModel) || summarizationModel === agentModel) {
+ return undefined;
+ }
+ const { model: _alias, ...kwargs } = agentKwargs;
+ return kwargs;
+}
+
/**
* Mirrors `getOpenAIConfig`'s `llmConfig` shape (plus its `configOptions`
* assigned to `configuration`). Index signature covers fields that the
@@ -701,6 +753,370 @@ function resolveBuiltInClientOverrides(
return Object.keys(shaping).length > 0 ? shaping : undefined;
}
+/**
+ * Memory bound for the warning deduplication below, not an operator setting: it only decides when a
+ * warning for one of more than this many distinct, concurrently recurring problems is logged again.
+ */
+const MAX_UNRESOLVED_SUMMARIZATION_WARNINGS = 256;
+/** Reported summarization misconfigurations per tenant, least recently seen first. */
+const unresolvedSummarizationWarnings = new Set<string>();
+
+function warnUnresolvedSummarization(message: string, tenantId?: string): void {
+ const key = `${tenantId ?? ''}\n${message}`;
+ if (unresolvedSummarizationWarnings.delete(key)) {
+ unresolvedSummarizationWarnings.add(key);
+ return;
+ }
+ if (unresolvedSummarizationWarnings.size >= MAX_UNRESOLVED_SUMMARIZATION_WARNINGS) {
+ const [leastRecentlySeen] = unresolvedSummarizationWarnings;
+ unresolvedSummarizationWarnings.delete(leastRecentlySeen);
+ }
+ unresolvedSummarizationWarnings.add(key);
+ if (tenantId == null) {
+ logger.warn(`[createRun] ${message}`);
+ return;
+ }
+ logger.warn(`[createRun] ${message}`, { tenantId });
+}
+
+/** Azure base URL templates the client fills from its own options rather than the environment. */
+const AZURE_URL_TEMPLATE = /(\$\{(?:INSTANCE_NAME|DEPLOYMENT_NAME)\})/;
+
+/** The URL's segments around Azure's reserved templates, which sit at the odd indexes. */
+function splitAzureURLTemplates(url: string): string[] {
+ return url.split(AZURE_URL_TEMPLATE);
+}
+
+/** Expands environment references in a URL, leaving Azure's reserved templates for an Azure client. */
+function expandTransportURL(url: string, targetsAzure: boolean): string {
+ if (!targetsAzure) {
+ return extractEnvVariable(url);
+ }
+ return splitAzureURLTemplates(url)
+ .map((segment, index) => (index % 2 === 1 ? segment : extractEnvVariable(segment)))
+ .join('');
+}
+
+/**
+ * Admin-authored transport values may reference environment variables, as endpoint credentials
+ * do. Expanded once, before resolution and before the parameters are layered over the client.
+ */
+function expandSummarizationTransport(
+ parameters: SummarizationConfig['parameters'],
+ targetsAzure: boolean,
+): SummarizationConfig['parameters'] {
+ if (!isPlainObject(parameters)) {
+ return parameters;
+ }
+ const params = parameters as Record<string, unknown>;
+ const expanded: Record<string, unknown> = { ...params };
+ if (typeof params.apiKey === 'string') {
+ expanded.apiKey = extractEnvVariable(params.apiKey);
+ }
+ if (typeof params.baseURL === 'string') {
+ expanded.baseURL = expandTransportURL(params.baseURL, targetsAzure);
+ }
+ if (isPlainObject(params.configuration) && typeof params.configuration.baseURL === 'string') {
+ expanded.configuration = {
+ ...params.configuration,
+ baseURL: expandTransportURL(params.configuration.baseURL, targetsAzure),
+ };
+ }
+ return expanded as SummarizationConfig['parameters'];
+}
+
+/** The base URL and API key a summarization target's own parameters set, which replace the resolved ones. */
+function summarizationTransportOverrides(parameters: SummarizationConfig['parameters']): {
+ baseURL?: string;
+ apiKey?: string;
+} {
+ const configuration = (parameters as Record<string, unknown> | undefined)?.configuration;
+ const configurationBaseURL =
+ isPlainObject(configuration) && typeof configuration.baseURL === 'string'
+ ? configuration.baseURL
+ : undefined;
+ return {
+ baseURL:
+ configurationBaseURL ??
+ (typeof parameters?.baseURL === 'string' ? parameters.baseURL : undefined),
+ apiKey: typeof parameters?.apiKey === 'string' ? parameters.apiKey : undefined,
+ };
+}
+
+/** Reject unusable transports while shaping the run, before a compaction client can fail it. */
+function isSummarizationURLAvailable(baseURL: string | undefined, azure?: t.AzureOptions): boolean {
+ if (baseURL == null) {
+ return azure == null || isNonEmptyString(azure.azureOpenAIApiInstanceName);
+ }
+ try {
+ const url = new URL(constructAzureURL({ baseURL, azureOptions: azure }));
+ return (
+ (url.protocol === 'https:' || url.protocol === 'http:') && !hasUnresolvedPlaceholder(url.href)
+ );
+ } catch {
+ return false;
+ }
+}
+
+/**
+ * Azure Responses shares OpenAI's SDK provider, so switching endpoints must replace its transport.
+ * Returns `undefined` when the OpenAI credentials cannot be resolved without a per-user lookup.
+ */
+function resolveOpenAISummarization(
+ model: string,
+ appConfig: AppConfig | undefined,
+ parameters: SummarizationConfig['parameters'],
+ headerContext: { user?: IUser; tenantId?: string; requestBody?: t.RequestBody },
+): { provider: string; clientOverrides: SummarizationClientOverrides } | undefined {
+ const overrides = summarizationTransportOverrides(parameters);
+ const baseURL = overrides.baseURL ?? getBuiltInBaseURL(EModelEndpoint.openAI);
+ const apiKey = overrides.apiKey ?? process.env.OPENAI_API_KEY;
+ if (
+ !apiKey ||
+ !isSummarizationURLAvailable(baseURL) ||
+ isUserProvided(baseURL) ||
+ isUserProvided(apiKey) ||
+ hasUnresolvedPlaceholder(apiKey) ||
+ (baseURL != null && hasUnresolvedPlaceholder(baseURL))
+ ) {
+ warnUnresolvedSummarization(
+ `Summarization with OpenAI model "${model}" is disabled for Azure OpenAI agents: it needs a server-configured OpenAI API key and base URL.`,
+ headerContext.tenantId,
+ );
+ return undefined;
+ }
+ const headers = mergeHeaders(
+ appConfig?.endpoints?.all?.headers,
+ appConfig?.endpoints?.openAI?.headers,
+ );
+ const { llmConfig, configOptions } = getOpenAIConfig(
+ apiKey,
+ {
+ modelOptions: {
+ model,
+ reasoning_effort: summarizationReasoningEffort(parameters),
+ useResponsesApi:
+ typeof parameters?.useResponsesApi === 'boolean' ? parameters.useResponsesApi : undefined,
+ },
+ reverseProxyUrl: baseURL,
+ proxy: process.env.PROXY ?? undefined,
+ headers: resolveModelHeaders({
+ headers: headers ?? {},
+ user: createSafeUser(headerContext.user),
+ tenantId: headerContext.tenantId,
+ body: headerContext.requestBody,
+ }),
+ },
+ EModelEndpoint.openAI,
+ );
+ return {
+ provider: Providers.OPENAI,
+ clientOverrides: {
+ ...llmConfig,
+ apiKey,
+ useResponsesApi: llmConfig.useResponsesApi ?? false,
+ firstPartyEndpoint: llmConfig.firstPartyEndpoint ?? false,
+ reasoning: llmConfig.reasoning,
+ modelKwargs: llmConfig.modelKwargs ?? {},
+ configuration: configOptions,
+ },
+ };
+}
+
+type AzureSummarizationTarget = Omit<ReturnType<typeof mapModelToAzureConfig>, 'azureOptions'> & {
+ azureOptions: t.AzureOptions;
+ group?: TAzureConfig['groupMap'][string];
+};
+
+/**
+ * The summary model's Azure credentials, resolved the way `initializeOpenAI` resolves an agent's:
+ * the `azureOpenAI` configuration when present, otherwise the legacy environment credentials.
+ * Returns `undefined` (reported once) when the configuration does not define the model.
+ */
+function resolveAzureSummarizationTarget(
+ model: string,
+ azureConfig: TAzureConfig | undefined,
+ tenantId: string | undefined,
+): AzureSummarizationTarget | undefined {
+ if (!azureConfig) {
+ return { azureOptions: getAzureCredentials() };
+ }
+ try {
+ const groupName = azureConfig.modelGroupMap[model]?.group;
+ return {
+ ...mapModelToAzureConfig({
+ modelName: model,
+ modelGroupMap: azureConfig.modelGroupMap,
+ groupMap: azureConfig.groupMap,
+ }),
+ group: groupName ? azureConfig.groupMap[groupName] : undefined,
+ };
+ } catch (error) {
+ warnUnresolvedSummarization(
+ `Summarization with Azure OpenAI model "${model}" is disabled: ${(error as Error).message}`,
+ tenantId,
+ );
+ return undefined;
+ }
+}
+
+/** Reuse request-resolved credentials for self-summaries, including user-provided Azure keys. */
+function azureSummarizationSource(agent: RunAgent): AzureSummarizationTarget {
+ const options = agent.model_parameters as Partial<t.OAIClientOptions> & t.AzureOptions;
+ const configuration = options.configuration;
+ const baseURL = configuration?.baseURL ?? options.azureOpenAIBasePath;
+ const deployment = agentModelKwargs(agent.model_parameters)?.model;
+ return {
+ serverless: agent.useLegacyContent === true,
+ baseURL: baseURL ?? undefined,
+ azureOptions: {
+ azureOpenAIApiKey:
+ options.azureOpenAIApiKey ??
+ (typeof options.apiKey === 'string' ? options.apiKey : undefined),
+ azureOpenAIApiInstanceName:
+ options.azureOpenAIApiInstanceName ?? agent.azureOptions?.azureOpenAIApiInstanceName,
+ azureOpenAIApiDeploymentName:
+ options.azureOpenAIApiDeploymentName ??
+ (typeof deployment === 'string' ? deployment : options.model),
+ azureOpenAIApiVersion:
+ options.azureOpenAIApiVersion ??
+ agent.azureOptions?.azureOpenAIApiVersion ??
+ configuration?.defaultQuery?.['api-version'] ??
+ undefined,
+ },
+ };
+}
+
+/**
+ * Resolve the summary model's deployment and transport before the SDK inherits agent options.
+ * A same-provider summarizer layers these over the agent's client options, so a summary group
+ * without a base path clears the agent's instead of sending its deployment to that resource.
+ * Returns `undefined` when the model cannot be resolved without a per-user lookup.
+ */
+function resolveAzureSummarization(
+ model: string,
+ appConfig: AppConfig | undefined,
+ parameters: SummarizationConfig['parameters'],
+ headerContext: { user?: IUser; tenantId?: string; requestBody?: t.RequestBody },
+ source?: RunAgent,
+): { provider: string; clientOverrides: SummarizationClientOverrides } | undefined {
+ const sourceOptions = source?.model_parameters as Partial<t.OAIClientOptions> | undefined;
+ const target = source
+ ? azureSummarizationSource(source)
+ : resolveAzureSummarizationTarget(
+ model,
+ appConfig?.endpoints?.[EModelEndpoint.azureOpenAI],
+ headerContext.tenantId,
+ );
+ if (!target) {
+ return undefined;
+ }
+ const { baseURL, headers, serverless, group } = target;
+ const overrides = summarizationTransportOverrides(parameters);
+ const azureOptions: t.AzureOptions = {
+ ...target.azureOptions,
+ azureOpenAIApiKey: overrides.apiKey ?? target.azureOptions.azureOpenAIApiKey,
+ };
+ const resolvedBaseURL =
+ overrides.baseURL ?? baseURL ?? getBuiltInBaseURL(EModelEndpoint.azureOpenAI);
+ if (
+ !azureOptions.azureOpenAIApiKey ||
+ !isSummarizationURLAvailable(resolvedBaseURL, serverless ? undefined : azureOptions) ||
+ Object.values(azureOptions).some(
+ (value) =>
+ typeof value === 'string' && (isUserProvided(value) || hasUnresolvedPlaceholder(value)),
+ ) ||
+ isUserProvided(resolvedBaseURL) ||
+ (resolvedBaseURL != null &&
+ splitAzureURLTemplates(resolvedBaseURL).some(
+ (segment, index) => index % 2 === 0 && hasUnresolvedPlaceholder(segment),
+ ))
+ ) {
+ warnUnresolvedSummarization(
+ `Summarization with Azure OpenAI model "${model}" is disabled: it needs a server-configured Azure OpenAI API key and base URL.`,
+ headerContext.tenantId,
+ );
+ return undefined;
+ }
+ const resolvedHeaders = sourceOptions
+ ? (sourceOptions.configuration?.defaultHeaders as Record<string, string> | undefined)
+ : resolveModelHeaders({
+ headers: mergeHeaders(appConfig?.endpoints?.all?.headers, headers) ?? {},
+ user: createSafeUser(headerContext.user),
+ tenantId: headerContext.tenantId,
+ body: headerContext.requestBody,
+ });
+ const { llmConfig, configOptions } = getOpenAIConfig(
+ azureOptions.azureOpenAIApiKey,
+ {
+ azure: serverless ? undefined : azureOptions,
+ reverseProxyUrl: resolvedBaseURL,
+ proxy: process.env.PROXY ?? undefined,
+ headers:
+ serverless || sourceOptions != null
+ ? { ...resolvedHeaders, 'api-key': azureOptions.azureOpenAIApiKey }
+ : resolvedHeaders,
+ defaultQuery:
+ serverless && azureOptions.azureOpenAIApiVersion
+ ? { 'api-version': azureOptions.azureOpenAIApiVersion }
+ : undefined,
+ modelOptions: {
+ model: source?.model ?? model,
+ reasoning_effort: summarizationReasoningEffort(parameters),
+ useResponsesApi:
+ typeof parameters?.useResponsesApi === 'boolean'
+ ? parameters.useResponsesApi
+ : sourceOptions?.useResponsesApi,
+ },
+ addParams: {
+ ...group?.addParams,
+ ...(typeof parameters?.useResponsesApi === 'boolean'
+ ? { useResponsesApi: parameters.useResponsesApi }
+ : {}),
+ },
+ dropParams: group?.dropParams?.filter(
+ (key) => key !== 'useResponsesApi' || typeof parameters?.useResponsesApi !== 'boolean',
+ ),
+ },
+ EModelEndpoint.azureOpenAI,
+ );
+ const sourceKwargs = agentModelKwargs(source?.model_parameters);
+ const preservesApiMode = !!sourceOptions?.useResponsesApi === !!llmConfig.useResponsesApi;
+ const sourceTokenLimit = sourceKwargs?.max_output_tokens ?? sourceKwargs?.max_completion_tokens;
+ const inheritedTokenLimit =
+ typeof sourceTokenLimit === 'number'
+ ? {
+ [llmConfig.useResponsesApi ? 'max_output_tokens' : 'max_completion_tokens']:
+ sourceTokenLimit,
+ }
+ : {};
+ return {
+ provider: !serverless && !llmConfig.useResponsesApi ? Providers.AZURE : Providers.OPENAI,
+ clientOverrides: {
+ ...sourceOptions,
+ azureOpenAIBasePath: undefined,
+ azureOpenAIApiKey: undefined,
+ azureOpenAIApiInstanceName: undefined,
+ azureOpenAIApiDeploymentName: undefined,
+ azureOpenAIApiVersion: undefined,
+ ...llmConfig,
+ apiKey: azureOptions.azureOpenAIApiKey,
+ useResponsesApi: llmConfig.useResponsesApi ?? false,
+ firstPartyEndpoint: llmConfig.firstPartyEndpoint ?? false,
+ reasoning: llmConfig.reasoning ?? (preservesApiMode ? sourceOptions?.reasoning : undefined),
+ modelKwargs: {
+ ...(preservesApiMode ? sourceKwargs : undefined),
+ ...inheritedTokenLimit,
+ ...llmConfig.modelKwargs,
+ model: llmConfig.modelKwargs?.model ?? llmConfig.model,
+ },
+ configuration: sourceOptions
+ ? { ...sourceOptions.configuration, ...configOptions }
+ : configOptions,
+ },
+ };
+}
+
/**
* Resolves a summarization provider string (which may be a custom-endpoint name
* like "Ollama") into the SDK-recognized provider and any client-option
@@ -861,10 +1277,19 @@ function resolveSummarizationProvider(
* agent flow builds for that endpoint (`initializeAgent` applies the same
* precedence).
*/
- return {
- provider: detectedProvider ?? overrideProvider,
- clientOverrides,
- };
+ const provider = detectedProvider ?? overrideProvider;
+ /**
+ * On the agent's provider the SDK layers these over the agent's own client options, so this
+ * different endpoint replaces the agent's API mode, first-party declaration, reasoning and
+ * request kwargs (an Azure Astra agent's Responses routing, for one) instead of inheriting them.
+ */
+ if (provider === target.agentProvider) {
+ clientOverrides.useResponsesApi ??= false;
+ clientOverrides.firstPartyEndpoint ??= false;
+ clientOverrides.modelKwargs ??= {};
+ clientOverrides.reasoning ??= undefined;
+ }
+ return { provider, clientOverrides };
} catch (error) {
logger.warn(
`[resolveSummarizationProvider] failed to resolve "${rawProvider}"; falling back to raw provider`,
@@ -882,6 +1307,7 @@ function shapeSummarizationConfig(
appConfig: AppConfig | undefined,
agentEndpoint: string | undefined,
headerContext: { user?: IUser; tenantId?: string; requestBody?: t.RequestBody },
+ agent?: RunAgent,
) {
const rawProvider = config?.provider ?? fallbackProvider;
/**
@@ -897,14 +1323,61 @@ function shapeSummarizationConfig(
normalizeEndpointName(rawProvider) === normalizeEndpointName(agentEndpoint);
const model = config?.model ?? fallbackModel;
-
- const { provider, clientOverrides } = isSameEndpointAsAgent
- ? { provider: fallbackProvider, clientOverrides: undefined }
- : resolveSummarizationProvider(rawProvider, appConfig, headerContext, {
+ const targetsAzure =
+ rawProvider === EModelEndpoint.azureOpenAI ||
+ (agentEndpoint === EModelEndpoint.azureOpenAI && config?.provider == null);
+ const userParameters = expandSummarizationTransport(config?.parameters, targetsAzure);
+
+ const selfAzureModel =
+ agentEndpoint === EModelEndpoint.azureOpenAI &&
+ (model === fallbackModel || model === agent?.model);
+ const transportOverrides = summarizationTransportOverrides(userParameters);
+ const overridesAzureTransport =
+ transportOverrides.baseURL != null ||
+ transportOverrides.apiKey != null ||
+ typeof userParameters?.useResponsesApi === 'boolean';
+ const selectsAzureDeployment =
+ targetsAzure &&
+ isNonEmptyString(model) &&
+ config?.enabled !== false &&
+ (agentEndpoint !== EModelEndpoint.azureOpenAI ||
+ model !== fallbackModel ||
+ overridesAzureTransport);
+ const azureOverrides = selectsAzureDeployment
+ ? resolveAzureSummarization(
model,
- parameters: config?.parameters,
- agentProvider: fallbackProvider,
- });
+ appConfig,
+ userParameters,
+ headerContext,
+ selfAzureModel ? agent : undefined,
+ )
+ : undefined;
+ const selectsOpenAIForAzureAgent =
+ agentEndpoint === EModelEndpoint.azureOpenAI &&
+ config?.provider === EModelEndpoint.openAI &&
+ config.enabled !== false &&
+ isNonEmptyString(model);
+ const openAIOverrides = selectsOpenAIForAzureAgent
+ ? resolveOpenAISummarization(model, appConfig, userParameters, headerContext)
+ : undefined;
+ /**
+ * A target resolved here is not handed to another client when resolution fails. Azure Responses
+ * shares the `openAI` provider, so the SDK would summarize an OpenAI target through the agent's
+ * Azure resource, and would send an unmapped Azure model name where a deployment belongs.
+ */
+ const targetUnavailable =
+ (selectsAzureDeployment && azureOverrides == null) ||
+ (selectsOpenAIForAzureAgent && openAIOverrides == null);
+ const { provider, clientOverrides } =
+ openAIOverrides ??
+ azureOverrides ??
+ (isSameEndpointAsAgent
+ ? { provider: fallbackProvider, clientOverrides: undefined }
+ : resolveSummarizationProvider(rawProvider, appConfig, headerContext, {
+ model,
+ parameters: userParameters,
+ agentProvider: fallbackProvider,
+ }));
const trigger =
config?.trigger?.type && typeof config?.trigger?.value === 'number'
? { type: config.trigger.type, value: config.trigger.value }
@@ -913,9 +1386,8 @@ function shapeSummarizationConfig(
/**
* Custom-endpoint overrides are merged into `parameters` so the SDK's
* `buildSummarizationClientConfig` spreads them onto the summarization
- * client options. Only applied when summarization targets a *different*
- * custom endpoint than the main agent; the same-endpoint case leaves
- * `parameters` untouched so `agentContext.clientOptions` wins.
+ * client options. Azure self-summaries with explicit transport overrides also resolve here,
+ * using the initialized agent's identity and credentials instead of a new configuration lookup.
*
* Order matters: `clientOverrides` supplies endpoint defaults (baseURL,
* apiKey, headers, transforms), then explicit user `summarization.parameters`
@@ -926,18 +1398,56 @@ function shapeSummarizationConfig(
*/
const mergedParameters =
clientOverrides != null
- ? mergeParameters(clientOverrides, config?.parameters)
- : config?.parameters;
+ ? mergeParameters(
+ clientOverrides,
+ userParameters,
+ azureOverrides != null || openAIOverrides != null,
+ )
+ : userParameters;
+ /** Placed first so an explicit user `modelKwargs` still replaces the agent's wholesale. */
+ const modelKwargs =
+ provider === fallbackProvider
+ ? summarizationModelKwargs(agentModelKwargs(agent?.model_parameters), fallbackModel, model)
+ : undefined;
/**
* A scalar `reasoning_effort` — the only reasoning shape the yaml schema
* accepts — is inert as a client option and leaves the summarizer running at
* whatever effort the main agent resolved. Translate it the way the main
* flow's `getOpenAIConfig` would for the summarization target.
*/
- const parameters = resolveReasoningParams({ provider, model, parameters: mergedParameters });
+ let parameters = resolveReasoningParams({
+ provider,
+ model,
+ parameters: modelKwargs != null ? { modelKwargs, ...mergedParameters } : mergedParameters,
+ });
+
+ /** The SDK sets maxTokens for this cap, but LangChain spreads modelKwargs after it. */
+ const parameterTokenCap = userParameters?.maxSummaryTokens;
+ const summaryTokenCap =
+ typeof parameterTokenCap === 'number' && parameterTokenCap > 0
+ ? parameterTokenCap
+ : config?.maxSummaryTokens;
+ const inheritedKwargs =
+ provider === fallbackProvider ? agentModelKwargs(agent?.model_parameters) : undefined;
+ const effectiveKwargs = isPlainObject(parameters?.modelKwargs)
+ ? parameters.modelKwargs
+ : inheritedKwargs;
+ if (typeof summaryTokenCap === 'number' && effectiveKwargs != null) {
+ const {
+ max_tokens: _maxTokens,
+ max_completion_tokens: _maxCompletionTokens,
+ max_output_tokens: _maxOutputTokens,
+ ...kwargs
+ } = effectiveKwargs;
+ parameters = { ...parameters, modelKwargs: kwargs };
+ }
return {
- enabled: config?.enabled !== false && isNonEmptyString(provider) && isNonEmptyString(model),
+ enabled:
+ !targetUnavailable &&
+ config?.enabled !== false &&
+ isNonEmptyString(provider) &&
+ isNonEmptyString(model),
config: {
trigger,
provider,
@@ -1820,6 +2330,21 @@ export async function createRun({
] as unknown as Providers) ?? agent.provider;
const selfModel = agent.model_parameters?.model ?? (agent.model as string | undefined);
+ /**
+ * Resolve request-based headers across provider-specific header locations
+ * (OpenAI `configuration.defaultHeaders`, Anthropic `clientOptions.defaultHeaders`,
+ * Google `customHeaders`). Done at this step because the request body may
+ * contain dynamic values (e.g. conversationId) that are only known after
+ * agent initialization. Resolve before a self-summary snapshots this configuration.
+ */
+ resolveConfigHeaders({
+ llmConfig: agent.model_parameters as Partial<t.RunLLMConfig>,
+ user: createSafeUser(user),
+ tenantId,
+ body: requestBody,
+ });
+
+ const modelParameters = normalizeAgentModelParameters(agent.model_parameters);
const shapedSummarization = shapeSummarizationConfig(
agent.summarization ?? summarizationConfig,
provider as string,
@@ -1827,6 +2352,7 @@ export async function createRun({
appConfig,
agent.endpoint ?? undefined,
{ user, tenantId, requestBody },
+ agent,
);
const summarization = modelCallbacks?.length
? {
@@ -1841,7 +2367,6 @@ export async function createRun({
}
: shapedSummarization;
- const modelParameters = normalizeAgentModelParameters(agent.model_parameters);
const hasExplicitStreamUsage = Object.prototype.hasOwnProperty.call(
modelParameters ?? {},
'streamUsage',
@@ -1873,20 +2398,6 @@ export async function createRun({
.join('\n')
.trim();
- /**
- * Resolve request-based headers across provider-specific header locations
- * (OpenAI `configuration.defaultHeaders`, Anthropic `clientOptions.defaultHeaders`,
- * Google `customHeaders`). Done at this step because the request body may
- * contain dynamic values (e.g. conversationId) that are only known after
- * agent initialization.
- */
- resolveConfigHeaders({
- llmConfig,
- user: createSafeUser(user),
- tenantId,
- body: requestBody,
- });
-
/** Resolves issues with new OpenAI usage field */
if (
customProviders.has(agent.provider) ||
diff --git a/packages/api/src/endpoints/openai/config.backward-compat.spec.ts b/packages/api/src/endpoints/openai/config.backward-compat.spec.ts
index f89482f534..3f905ba21a 100644
--- a/packages/api/src/endpoints/openai/config.backward-compat.spec.ts
+++ b/packages/api/src/endpoints/openai/config.backward-compat.spec.ts
@@ -165,6 +165,7 @@ describe('getOpenAIConfig - Backward Compatibility', () => {
streaming: true,
model: 'gpt-5',
useResponsesApi: true,
+ firstPartyEndpoint: true,
user: 'some_user_id',
apiKey: 'some_azure_key',
reasoning: {
diff --git a/packages/api/src/endpoints/openai/config.spec.ts b/packages/api/src/endpoints/openai/config.spec.ts
index 15f81ef034..980efafb0b 100644
--- a/packages/api/src/endpoints/openai/config.spec.ts
+++ b/packages/api/src/endpoints/openai/config.spec.ts
@@ -909,9 +909,9 @@ describe('getOpenAIConfig', () => {
reverseProxyUrl: 'https://${INSTANCE_NAME}.openai.azure.com/openai/v1',
});
- // The constructAzureURL should replace placeholders with actual values
+ // AzureChatOpenAI appends the deployment to its base path, including for a v1 resource URL.
expect((result.llmConfig as Record<string, unknown>).azureOpenAIBasePath).toBe(
- 'https://test-instance.openai.azure.com/openai/v1',
+ 'https://test-instance.openai.azure.com/openai/deployments',
);
});
diff --git a/packages/api/src/endpoints/openai/config.ts b/packages/api/src/endpoints/openai/config.ts
index ae2310de45..74aeb1118d 100644
--- a/packages/api/src/endpoints/openai/config.ts
+++ b/packages/api/src/endpoints/openai/config.ts
@@ -7,9 +7,9 @@ import { getGoogleConfig, stripGeminiFlashBlockedParams } from '~/endpoints/goog
import { getLLMConfig as getAnthropicLLMConfig } from '~/endpoints/anthropic/llm';
import { createSSRFSafeAgents, createSSRFSafeUndiciConnect } from '~/auth';
import { getOpenAILLMConfig, extractDefaultParams } from './llm';
+import { constructAzureResponsesURL } from '~/utils/azure';
import { transformToOpenAIConfig } from './transform';
import { getProxyDispatcher } from '~/utils/proxy';
-import { constructAzureURL } from '~/utils/azure';
import { createFetch } from '~/utils/generators';
import { mergeHeaders } from '~/utils/headers';
@@ -270,20 +270,21 @@ export function getOpenAIConfig(
return;
}
- const updatedUrl = configOptions.baseURL?.replace(/\/deployments(?:\/.*)?$/, '/v1');
-
- configOptions.baseURL = constructAzureURL({
- baseURL: updatedUrl || 'https://${INSTANCE_NAME}.openai.azure.com/openai/v1',
- azureOptions: azure,
- });
+ const responsesURL = constructAzureResponsesURL(configOptions.baseURL, azure);
+ const urlQuery = Object.fromEntries(responsesURL.searchParams);
+ responsesURL.search = '';
+ responsesURL.hash = '';
+ configOptions.baseURL = responsesURL.toString();
configOptions.defaultHeaders = {
...configOptions.defaultHeaders,
'api-key': apiKey,
};
configOptions.defaultQuery = {
+ ...urlQuery,
...configOptions.defaultQuery,
- 'api-version': configOptions.defaultQuery?.['api-version'] ?? 'preview',
+ 'api-version':
+ configOptions.defaultQuery?.['api-version'] ?? urlQuery['api-version'] ?? 'preview',
};
};
diff --git a/packages/api/src/endpoints/openai/initialize.ts b/packages/api/src/endpoints/openai/initialize.ts
index 7df6e1b996..16d412ed34 100644
--- a/packages/api/src/endpoints/openai/initialize.ts
+++ b/packages/api/src/endpoints/openai/initialize.ts
@@ -201,7 +201,10 @@ export async function initializeOpenAI(
modelOptions,
};
- const options = getOpenAIConfig(apiKey, finalClientOptions, endpoint);
+ const options: InitializeResultBase = getOpenAIConfig(apiKey, finalClientOptions, endpoint);
+ if (clientOptions.azure) {
+ options.azureOptions = { ...clientOptions.azure };
+ }
/** Set useLegacyContent for Azure serverless deployments */
if (isServerless) {
diff --git a/packages/api/src/endpoints/openai/llm.spec.ts b/packages/api/src/endpoints/openai/llm.spec.ts
index faa5edc25c..c422ce8683 100644
--- a/packages/api/src/endpoints/openai/llm.spec.ts
+++ b/packages/api/src/endpoints/openai/llm.spec.ts
@@ -801,12 +801,7 @@ describe('getOpenAILLMConfig', () => {
);
});
- /**
- * Astra is not documented as available on Azure OpenAI, and Azure's
- * first-party hosts do not satisfy the OpenAI-host check, so declaring it
- * there would claim a surface this cannot verify.
- */
- it('does not declare it for Azure OpenAI', () => {
+ it('does not declare it for Azure serverless without Azure OpenAI configuration', () => {
expect(configFor({ endpoint: EModelEndpoint.azureOpenAI }).llmConfig).not.toHaveProperty(
'firstPartyEndpoint',
);
@@ -825,6 +820,90 @@ describe('getOpenAILLMConfig', () => {
});
});
+ describe('Azure Astra routing', () => {
+ const azure = {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: 'production-deployment',
+ azureOpenAIApiVersion: '2025-04-01-preview',
+ azureOpenAIApiKey: 'test-api-key',
+ };
+ const azureConfig = (overrides: Partial<Parameters<typeof getOpenAILLMConfig>[0]> = {}) =>
+ getOpenAILLMConfig({
+ azure,
+ apiKey: 'test-api-key',
+ streaming: true,
+ endpoint: EModelEndpoint.azureOpenAI,
+ modelOptions: { model: 'gpt-6-astra', max_tokens: 2048 },
+ ...overrides,
+ });
+
+ it.each([
+ undefined,
+ 'https://${INSTANCE_NAME}.openai.azure.com/openai/deployments/${DEPLOYMENT_NAME}',
+ 'https://test-instance.openai.azure.com/openai/v1',
+ 'https://test-instance.services.ai.azure.com/openai/v1',
+ 'https://test-instance.cognitiveservices.azure.com/openai/v1',
+ 'https://test-instance.openai.azure.us/openai/v1',
+ 'https://test-instance.openai.azure.cn/openai/v1',
+ ])('routes Azure Astra to Responses at %s and retains its model identity', (baseURL) => {
+ expect(azureConfig({ baseURL }).llmConfig).toMatchObject({
+ model: 'gpt-6-astra',
+ useResponsesApi: true,
+ firstPartyEndpoint: true,
+ modelKwargs: { model: 'production-deployment', max_output_tokens: 2048 },
+ });
+ });
+
+ it.each([
+ { modelOptions: { model: 'gpt-6-astra-2026-09-03', max_tokens: 2048 } },
+ { modelOptions: { model: 'gpt-4.1', max_tokens: 2048 }, addParams: { model: 'gpt-6-astra' } },
+ { dropParams: ['reasoning_effort'] },
+ { reasoningFormat: ReasoningParameterFormat.disabled },
+ ])('routes using the effective model independently of reasoning: %j', (overrides) => {
+ expect(azureConfig(overrides).llmConfig.useResponsesApi).toBe(true);
+ });
+
+ it.each([
+ { modelOptions: { model: 'gpt-6-astra', max_tokens: 2048, useResponsesApi: false } },
+ { addParams: { useResponsesApi: false } },
+ { dropParams: ['useResponsesApi'] },
+ ])('keeps Astra constraints on an explicit Chat Completions opt-out: %j', (overrides) => {
+ const { llmConfig } = azureConfig(overrides);
+ expect(llmConfig.useResponsesApi).not.toBe(true);
+ expect(llmConfig).toMatchObject({
+ model: 'gpt-6-astra',
+ firstPartyEndpoint: true,
+ azureOpenAIApiDeploymentName: 'production-deployment',
+ modelKwargs: { model: 'production-deployment', max_completion_tokens: 2048 },
+ });
+ });
+
+ it.each([
+ { modelOptions: { model: 'gpt-5.4-mini' } },
+ { addParams: { model: 'gpt-5.4-mini' } },
+ ])('leaves other Azure models on the deployment name: %j', (overrides) => {
+ const { llmConfig } = azureConfig(overrides);
+ expect(llmConfig.useResponsesApi).not.toBe(true);
+ expect(llmConfig).toMatchObject({
+ model: 'production-deployment',
+ firstPartyEndpoint: true,
+ });
+ expect(llmConfig.modelKwargs?.model).toBeUndefined();
+ });
+
+ it.each([
+ 'https://gateway.internal/openai/v1',
+ 'https://test-instance.openai.azure.com.example.org/openai/v1',
+ 'https://openai.azure.com/openai/v1',
+ 'not-a-url',
+ ])('leaves gateway routing and request constraints unchanged: %s', (baseURL) => {
+ const { llmConfig } = azureConfig({ baseURL });
+ expect(llmConfig.useResponsesApi).not.toBe(true);
+ expect(llmConfig.firstPartyEndpoint).toBeUndefined();
+ expect(llmConfig.model).toBe('production-deployment');
+ });
+ });
+
describe('GPT-5.6 Responses API Requirement', () => {
it.each(['gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.6-sol', 'gpt-5.6'])(
'should default to Responses API for %s when reasoning_effort is set',
diff --git a/packages/api/src/endpoints/openai/llm.ts b/packages/api/src/endpoints/openai/llm.ts
index 04f02e1810..9aa23258dd 100644
--- a/packages/api/src/endpoints/openai/llm.ts
+++ b/packages/api/src/endpoints/openai/llm.ts
@@ -11,7 +11,14 @@ import type { AzureOpenAIInput } from '@librechat/agents/langchain/openai';
import type { SettingDefinition } from 'librechat-data-provider';
import type { OpenAI } from 'openai';
import type * as t from '~/types';
-import { sanitizeModelName, constructAzureURL } from '~/utils/azure';
+import {
+ sanitizeModelName,
+ constructAzureURL,
+ isCanonicalAzureURL,
+ getAzureDeploymentName,
+ constructAzureChatBasePath,
+ constructAzureInstanceBasePath,
+} from '~/utils/azure';
import { isEnabled } from '~/utils/common';
type OpenAILLMConfig = Omit<Partial<t.OAIClientOptions>, 'verbosity'> &
@@ -138,8 +145,8 @@ const responsesApiRequiredPattern = /\bgpt-5\.6\b/;
* Decided here rather than in the agents SDK at invocation time: the max-tokens
* field below is shaped from `useResponsesApi`, so a later switch would send
* `max_completion_tokens` to an endpoint expecting `max_output_tokens`. Config
- * time is also the only place that knows the model before Azure replaces it
- * with a deployment name.
+ * time is also where Azure decides whether the model keeps its identity, with
+ * the deployment as the wire model, or becomes the deployment name outright.
* @see https://developers.openai.com/api/docs/guides/latest-model
*/
const responsesApiPreferredPattern = /^gpt-6-astra(?:-|$)/i;
@@ -148,6 +155,16 @@ function prefersResponsesApi(model?: string): boolean {
return typeof model === 'string' && responsesApiPreferredPattern.test(model);
}
+function isCanonicalAzureBaseURL(baseURL?: string | null, azure?: false | t.AzureOptions): boolean {
+ if (!azure) {
+ return false;
+ }
+ if (!baseURL) {
+ return true;
+ }
+ return isCanonicalAzureURL(constructAzureURL({ baseURL, azureOptions: azure }));
+}
+
function requiresResponsesApiForReasoning({
model,
reasoningEffort,
@@ -874,10 +891,17 @@ export function getOpenAILLMConfig({
*/
const responsesApiExplicitlyOptedOut =
dropParams != null && dropParams.includes('useResponsesApi');
- if (
+ const firstPartyOpenAI =
+ !useOpenRouter && endpoint === EModelEndpoint.openAI && isCanonicalOpenAIBaseURL(baseURL);
+ const firstPartyAzure =
!useOpenRouter &&
- endpoint === EModelEndpoint.openAI &&
- isCanonicalOpenAIBaseURL(baseURL) &&
+ endpoint === EModelEndpoint.azureOpenAI &&
+ isCanonicalAzureBaseURL(baseURL, azure);
+ const firstPartyEndpoint = firstPartyOpenAI || firstPartyAzure;
+ /** Astra keeps its model identity on Azure, where the deployment becomes the wire model. */
+ const firstPartyAstra = firstPartyEndpoint && prefersResponsesApi(llmConfig.model);
+ if (
+ firstPartyOpenAI &&
reasoningFormat !== ReasoningParameterFormat.disabled &&
llmConfig.useResponsesApi == null &&
!responsesApiOptedOut &&
@@ -889,16 +913,9 @@ export function getOpenAILLMConfig({
/**
* Route GPT-6 Astra to the Responses API for every turn. Unlike the GPT-5.6
* rule above this does not depend on reasoning params: Astra serves tool calls
- * only from Responses, and OpenAI recommends it generally.
+ * only from Responses on both OpenAI and Azure OpenAI.
*/
- if (
- !useOpenRouter &&
- endpoint === EModelEndpoint.openAI &&
- isCanonicalOpenAIBaseURL(baseURL) &&
- llmConfig.useResponsesApi == null &&
- !responsesApiExplicitlyOptedOut &&
- prefersResponsesApi(llmConfig.model)
- ) {
+ if (firstPartyAstra && llmConfig.useResponsesApi == null && !responsesApiExplicitlyOptedOut) {
llmConfig.useResponsesApi = true;
}
@@ -908,13 +925,8 @@ export function getOpenAILLMConfig({
* above uses, so the decision lives in one place: OpenRouter and custom
* gateways route through endpoints whose contract is not OpenAI's, and only
* this layer can tell them apart.
- *
- * Scoped to the canonical OpenAI endpoint. Astra is not documented as
- * available on Azure OpenAI, and Azure's first-party hosts do not satisfy the
- * OpenAI-host check, so declaring it there would claim a surface this cannot
- * verify.
*/
- if (!useOpenRouter && endpoint === EModelEndpoint.openAI && isCanonicalOpenAIBaseURL(baseURL)) {
+ if (firstPartyEndpoint) {
llmConfig.firstPartyEndpoint = true;
}
@@ -1020,26 +1032,27 @@ export function getOpenAILLMConfig({
}
const useModelName = isEnabled(process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME);
+ const model = llmConfig.model;
const updatedAzure = { ...azure };
updatedAzure.azureOpenAIApiDeploymentName = useModelName
? sanitizeModelName(llmConfig.model || '')
- : azure.azureOpenAIApiDeploymentName;
+ : azure.azureOpenAIApiDeploymentName ||
+ getAzureDeploymentName(baseURL, azure) ||
+ (firstPartyAstra || llmConfig.useResponsesApi ? model : undefined);
if (process.env.AZURE_OPENAI_DEFAULT_MODEL) {
llmConfig.model = process.env.AZURE_OPENAI_DEFAULT_MODEL;
}
const constructAzureOpenAIBasePath = () => {
- if (!baseURL) {
+ if (baseURL) {
+ updatedAzure.azureOpenAIBasePath = constructAzureChatBasePath(baseURL, updatedAzure);
return;
}
- const azureURL = constructAzureURL({
- baseURL,
- azureOptions: updatedAzure,
- });
- updatedAzure.azureOpenAIBasePath = azureURL.split(
- `/${updatedAzure.azureOpenAIApiDeploymentName}`,
- )[0];
+ const instanceBasePath = constructAzureInstanceBasePath(updatedAzure);
+ if (instanceBasePath != null && updatedAzure.azureOpenAIBasePath == null) {
+ updatedAzure.azureOpenAIBasePath = instanceBasePath;
+ }
};
constructAzureOpenAIBasePath();
@@ -1060,6 +1073,15 @@ export function getOpenAILLMConfig({
constructAzureResponsesApi();
- llmConfig.model = updatedAzure.azureOpenAIApiDeploymentName;
+ /** Keep Astra's identity for SDK constraints; only the wire model is a deployment alias. */
+ if (firstPartyAstra) {
+ llmConfig.model = model;
+ llmConfig.modelKwargs = {
+ ...llmConfig.modelKwargs,
+ model: updatedAzure.azureOpenAIApiDeploymentName,
+ };
+ } else {
+ llmConfig.model = updatedAzure.azureOpenAIApiDeploymentName;
+ }
return { llmConfig, tools, azure: updatedAzure };
}
diff --git a/packages/api/src/endpoints/openai/requests.spec.ts b/packages/api/src/endpoints/openai/requests.spec.ts
new file mode 100644
index 0000000000..57cfe7bc59
--- /dev/null
+++ b/packages/api/src/endpoints/openai/requests.spec.ts
@@ -0,0 +1,227 @@
+import { Providers, initializeModel } from '@librechat/agents';
+import { EModelEndpoint, ReasoningEffort } from 'librechat-data-provider';
+import type { OpenAI } from 'openai';
+import type { OpenAIConfiguration } from '~/types';
+import { getOpenAIConfig } from './config';
+
+describe('Azure Astra requests', () => {
+ it.each([
+ { deploymentName: 'gpt-6-astra', wireModel: 'gpt-6-astra', baseURL: undefined },
+ {
+ deploymentName: 'production-deployment',
+ wireModel: 'production-deployment',
+ baseURL: undefined,
+ },
+ ...[
+ 'https://test-instance.openai.azure.com',
+ 'https://test-instance.openai.azure.com/',
+ 'https://test-instance.openai.azure.com/openai/',
+ 'https://test-instance.openai.azure.com/openai/v1/',
+ 'https://${INSTANCE_NAME}.openai.azure.com/openai/deployments/${DEPLOYMENT_NAME}',
+ ].map((baseURL) => ({
+ deploymentName: 'production-deployment',
+ wireModel: 'production-deployment',
+ baseURL,
+ })),
+ {
+ deploymentName: undefined,
+ wireModel: 'url-deployment',
+ baseURL:
+ 'https://test-instance.openai.azure.com/openai/deployments/url-deployment?api-version=2025-04-01-preview',
+ },
+ {
+ deploymentName: undefined,
+ wireModel: 'gpt-6-astra',
+ baseURL: 'https://test-instance.openai.azure.com/openai/v1',
+ },
+ ])(
+ 'sends tool requests to $wireModel from $baseURL with Astra constraints',
+ async ({ deploymentName, wireModel, baseURL }) => {
+ const requests: {
+ url: URL;
+ headers: Headers;
+ body: OpenAI.Responses.ResponseCreateParams;
+ }[] = [];
+ const fetch: NonNullable<NonNullable<OpenAIConfiguration>['fetch']> = async (url, init) => {
+ requests.push({
+ url: new URL(String(url)),
+ headers: new Headers(init?.headers),
+ body: JSON.parse(String(init?.body)),
+ });
+ return Response.json({
+ id: 'resp_test',
+ object: 'response',
+ status: 'completed',
+ model: wireModel,
+ output: [
+ {
+ type: 'function_call',
+ id: 'fc_test',
+ call_id: 'call_test',
+ name: 'calculator',
+ arguments: '{"input":"2 + 2"}',
+ status: 'completed',
+ },
+ ],
+ usage: { input_tokens: 10, output_tokens: 5, total_tokens: 15 },
+ });
+ };
+ const { llmConfig, configOptions } = getOpenAIConfig(
+ 'test-azure-key',
+ {
+ streaming: false,
+ reverseProxyUrl: baseURL,
+ azure: {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: deploymentName,
+ azureOpenAIApiVersion: '2025-04-01-preview',
+ azureOpenAIApiKey: 'test-azure-key',
+ },
+ modelOptions: {
+ model: 'gpt-6-astra',
+ reasoning_effort: ReasoningEffort.none,
+ max_tokens: 2048,
+ temperature: 0.7,
+ top_p: 0.9,
+ },
+ addParams: { logprobs: true, topLogprobs: 5, store: false },
+ },
+ EModelEndpoint.azureOpenAI,
+ );
+ expect(llmConfig).not.toHaveProperty('azureOpenAIApiInstanceName');
+ const model = initializeModel({
+ provider: Providers.OPENAI,
+ clientOptions: {
+ ...llmConfig,
+ verbosity: undefined,
+ configuration: { ...configOptions, fetch },
+ },
+ tools: [
+ {
+ type: 'function',
+ function: {
+ name: 'calculator',
+ description: 'Compute arithmetic',
+ parameters: {
+ type: 'object',
+ properties: { input: { type: 'string' } },
+ required: ['input'],
+ },
+ },
+ },
+ ],
+ });
+
+ const result = await model.invoke('Use the calculator to compute 2 + 2.');
+
+ expect(result.tool_calls).toEqual([
+ expect.objectContaining({ name: 'calculator', args: { input: '2 + 2' } }),
+ ]);
+ expect(requests).toHaveLength(1);
+ const { url, headers, body } = requests[0];
+ expect(url.origin + url.pathname).toBe(
+ 'https://test-instance.openai.azure.com/openai/v1/responses',
+ );
+ expect(headers.get('api-key')).toBe('test-azure-key');
+ if (baseURL?.includes('?api-version=')) {
+ expect(url.searchParams.get('api-version')).toBe('2025-04-01-preview');
+ }
+ expect(body).toMatchObject({
+ model: wireModel,
+ max_output_tokens: 2048,
+ reasoning: { effort: 'low' },
+ tools: [expect.objectContaining({ type: 'function', name: 'calculator' })],
+ include: expect.arrayContaining(['reasoning.encrypted_content']),
+ });
+ for (const key of [
+ 'max_tokens',
+ 'max_completion_tokens',
+ 'temperature',
+ 'top_p',
+ 'logprobs',
+ 'top_logprobs',
+ ]) {
+ expect(body).not.toHaveProperty(key);
+ }
+ expect(body.include).not.toContain('message.output_text.logprobs');
+ },
+ );
+});
+
+describe('Azure full-hostname instances', () => {
+ it.each([
+ {
+ baseURL: undefined,
+ model: 'gpt-6-astra',
+ provider: Providers.OPENAI,
+ path: '/openai/v1/responses',
+ },
+ {
+ baseURL: undefined,
+ model: 'gpt-4.1',
+ provider: Providers.AZURE,
+ path: '/openai/deployments/production-deployment/chat/completions',
+ },
+ {
+ baseURL: 'https://test-instance.cognitiveservices.azure.com/openai/v1',
+ model: 'gpt-4.1',
+ provider: Providers.AZURE,
+ path: '/openai/deployments/production-deployment/chat/completions',
+ },
+ ])('sends $model requests to the instance host (base URL: $baseURL)', async (target) => {
+ const urls: URL[] = [];
+ const fetch: NonNullable<NonNullable<OpenAIConfiguration>['fetch']> = async (url) => {
+ urls.push(new URL(String(url)));
+ const text = 'Four.';
+ return Response.json({
+ id: 'resp_test',
+ object: 'response',
+ status: 'completed',
+ model: 'production-deployment',
+ choices: [
+ { index: 0, message: { role: 'assistant', content: text }, finish_reason: 'stop' },
+ ],
+ output: [
+ {
+ type: 'message',
+ id: 'msg_test',
+ role: 'assistant',
+ status: 'completed',
+ content: [{ type: 'output_text', text, annotations: [] }],
+ },
+ ],
+ usage: { prompt_tokens: 5, completion_tokens: 1, input_tokens: 5, output_tokens: 1 },
+ });
+ };
+ const { llmConfig, configOptions } = getOpenAIConfig(
+ 'test-azure-key',
+ {
+ streaming: false,
+ reverseProxyUrl: target.baseURL,
+ azure: {
+ azureOpenAIApiInstanceName: 'test-instance.cognitiveservices.azure.com',
+ azureOpenAIApiDeploymentName: 'production-deployment',
+ azureOpenAIApiVersion: '2024-10-21',
+ azureOpenAIApiKey: 'test-azure-key',
+ },
+ modelOptions: { model: target.model },
+ },
+ EModelEndpoint.azureOpenAI,
+ );
+ const model = initializeModel({
+ provider: target.provider,
+ clientOptions: {
+ ...llmConfig,
+ verbosity: undefined,
+ configuration: { ...configOptions, fetch },
+ },
+ });
+
+ await model.invoke('What is 2 + 2?');
+
+ expect(urls).toHaveLength(1);
+ expect(urls[0].origin + urls[0].pathname).toBe(
+ `https://test-instance.cognitiveservices.azure.com${target.path}`,
+ );
+ });
+});
diff --git a/packages/api/src/types/endpoints.ts b/packages/api/src/types/endpoints.ts
index 39f20eabb9..88e54791c9 100644
--- a/packages/api/src/types/endpoints.ts
+++ b/packages/api/src/types/endpoints.ts
@@ -3,6 +3,7 @@ import type { AppConfig, IUser } from '@librechat/data-schemas';
import type { TConfig } from 'librechat-data-provider';
import type { RequestBody, ServerRequest } from './http';
import type { EndpointTokenConfig } from './tokens';
+import type { AzureOptions } from './azure';
export type TCustomEndpointsConfig = Partial<{ [key: string]: Omit<TConfig, 'order'> }>;
@@ -87,6 +88,8 @@ export function resolveEndpointRuntime(params: ProviderInitializeParams): Endpoi
* Using a more permissive type to accommodate different provider-specific results
*/
export interface InitializeResultBase {
+ /** Request-resolved Azure identity, retained when Responses removes the Azure client fields. */
+ azureOptions?: AzureOptions;
llmConfig: ClientOptions;
configOptions?: OpenAIClientOptions['configuration'];
endpointTokenConfig?: EndpointTokenConfig;
diff --git a/packages/api/src/types/openai.ts b/packages/api/src/types/openai.ts
index 8e05b0711b..0706a1ccb0 100644
--- a/packages/api/src/types/openai.ts
+++ b/packages/api/src/types/openai.ts
@@ -37,7 +37,7 @@ export type OAIClientOptions = Omit<OpenAIClientOptions, 'verbosity'> & {
promptCache?: boolean;
promptCacheTtl?: '5m' | '1h';
/**
- * Declares that this client talks to the first-party OpenAI surface, which is
+ * Declares that this client talks to a first-party OpenAI or Azure surface, which is
* what gates the agents SDK's model-specific request constraints (GPT-6
* Astra: Responses-only tool calls, rejected sampling parameters,
* unsupported reasoning efforts). The SDK defaults them off and takes this as
diff --git a/packages/api/src/utils/azure.ts b/packages/api/src/utils/azure.ts
index 1bbd0e29b2..f5a9011a22 100644
--- a/packages/api/src/utils/azure.ts
+++ b/packages/api/src/utils/azure.ts
@@ -1,5 +1,5 @@
-import { isEnabled } from './common';
import type { AzureOptions, GenericClient } from '~/types';
+import { isEnabled } from './common';
/**
* Sanitizes the model name to be used in the URL by removing or replacing disallowed characters.
@@ -124,3 +124,76 @@ export function constructAzureURL({
return finalURL;
}
+
+export function isCanonicalAzureURL(baseURL: string): boolean {
+ try {
+ return /\.(?:openai|cognitiveservices|services\.ai)\.azure\.(?:com|us|cn)$/i.test(
+ new URL(baseURL).hostname,
+ );
+ } catch {
+ return false;
+ }
+}
+
+function isAzureRootPath(pathname: string): boolean {
+ return /^\/(?:openai(?:\/v1)?\/?|v1\/?)?$/.test(pathname);
+}
+
+/** An instance name that is already a full Azure hostname, which `genAzureEndpoint` also accepts. */
+function getAzureInstanceHost(instanceName?: string): string | undefined {
+ return instanceName && isCanonicalAzureURL(`https://${instanceName}`) ? instanceName : undefined;
+}
+
+/**
+ * The deployments path for a full-hostname instance without a base URL. A resource name needs
+ * none: the client derives `<name>.openai.azure.com` itself, which a full hostname would double.
+ */
+export function constructAzureInstanceBasePath(azureOptions: AzureOptions): string | undefined {
+ const host = getAzureInstanceHost(azureOptions.azureOpenAIApiInstanceName);
+ return host ? `https://${host}/openai/deployments` : undefined;
+}
+
+export function constructAzureChatBasePath(baseURL: string, azureOptions: AzureOptions): string {
+ const resolvedURL = constructAzureURL({ baseURL, azureOptions });
+ if (isCanonicalAzureURL(resolvedURL)) {
+ const url = new URL(resolvedURL);
+ if (isAzureRootPath(url.pathname)) {
+ return `${url.origin}/openai/deployments`;
+ }
+ }
+ return resolvedURL.split(`/${azureOptions.azureOpenAIApiDeploymentName}`)[0];
+}
+
+/** Azure permits the deployment to be supplied entirely by the configured base URL. */
+export function getAzureDeploymentName(
+ baseURL?: string | null,
+ azureOptions?: AzureOptions,
+): string | undefined {
+ if (!baseURL) {
+ return undefined;
+ }
+ try {
+ const url = new URL(constructAzureURL({ baseURL, azureOptions }));
+ const deployment = url.pathname.match(/\/deployments\/([^/]+)/)?.[1];
+ return deployment ? decodeURIComponent(deployment) : undefined;
+ } catch {
+ return undefined;
+ }
+}
+
+export function constructAzureResponsesURL(
+ baseURL: string | null | undefined,
+ azureOptions: AzureOptions,
+): URL {
+ const instanceName = azureOptions.azureOpenAIApiInstanceName ?? '';
+ const instanceHost = getAzureInstanceHost(instanceName) ?? `${instanceName}.openai.azure.com`;
+ const resolvedURL = baseURL
+ ? constructAzureURL({ baseURL, azureOptions })
+ : `https://${instanceHost}/openai/v1`;
+ const url = new URL(resolvedURL);
+ url.pathname = url.pathname.replace(/\/deployments(?:\/.*)?$/, '/v1');
+ if (isCanonicalAzureURL(resolvedURL) && isAzureRootPath(url.pathname)) {
+ url.pathname = '/openai/v1';
+ }
+ return url;
+}
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index 8cfcbd03a3..ca70c35e70 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -3211,10 +3211,9 @@ const fitlerAssistantModels = (str: string) => {
const openAIModels = defaultModels[EModelEndpoint.openAI];
/**
- * The OpenAI catalog without the models only the first-party OpenAI endpoint
- * can run. Azure OpenAI shares this list, but Astra is neither routed to the
- * Responses API nor given its request constraints there, and listing it first
- * would let it become the default selection.
+ * Preserve Azure's fallback default selection when the OpenAI catalog gains
+ * Responses-preferred models. Configured Azure deployments supply their own
+ * model list, including Astra when deployed.
*/
const nonResponsesOnlyOpenAIModels = openAIModels.filter(
(model) => !responsesOnlyOpenAIModels.includes(model),