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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
📫 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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/googimport { 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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 asdiff --git a/packages/api/src/utils/azure.ts b/packages/api/src/utils/azure.tsindex 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.tsindex 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),