Skip to content

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

🥣 fix: Apply Agent Shaping to Built-In Summarizers (#15599)

Danny Avila22a83bd4df8d
diff --git a/packages/api/src/agents/__tests__/run-summarization.test.ts b/packages/api/src/agents/__tests__/run-summarization.test.ts
index b29e85f476..bfb9ab13cd 100644
--- a/packages/api/src/agents/__tests__/run-summarization.test.ts
+++ b/packages/api/src/agents/__tests__/run-summarization.test.ts
@@ -1489,6 +1489,152 @@ describe('custom-endpoint provider resolution', () => {
});
});
+// ---------------------------------------------------------------------------
+// Suite: built-in provider request shaping (#15598)
+// ---------------------------------------------------------------------------
+/**
+ * A built-in provider produces no custom-endpoint config, so `getOpenAIConfig`
+ * was skipped entirely and the summarizer learned neither which API its model
+ * takes nor whether its endpoint is first-party. The agents SDK defaults its
+ * model-specific constraints off without that declaration, so configured
+ * parameters reached the model unshaped.
+ *
+ * These assert the declaration LibreChat emits, which is the half it owns; the
+ * SDK's honoring of it is covered by its own tests.
+ */
+describe('built-in provider request shaping', () => {
+ const anthropicAgent = () =>
+ makeAgent({
+ provider: 'anthropic',
+ endpoint: 'anthropic',
+ model: 'claude-sonnet-4.6',
+ model_parameters: { model: 'claude-sonnet-4.6' },
+ });
+
+ const summarizeWith = async (
+ parameters?: Record<string, unknown>,
+ model = 'gpt-6-astra',
+ ): Promise<Record<string, unknown>> => {
+ const agents = await callAndCapture({
+ agents: [anthropicAgent()],
+ appConfig: makeAppConfig([]),
+ summarizationConfig: {
+ provider: 'openAI',
+ model,
+ parameters: parameters as SummarizationConfig['parameters'],
+ },
+ });
+ const config = agents[0].summarizationConfig as Record<string, unknown>;
+ return config.parameters as Record<string, unknown>;
+ };
+
+ it('declares the first-party endpoint for a cross-provider built-in summarizer', async () => {
+ expect(await summarizeWith(undefined, 'gpt-4o')).toMatchObject({ firstPartyEndpoint: true });
+ });
+
+ it('routes a Responses-only model to the Responses API', async () => {
+ expect(await summarizeWith()).toMatchObject({
+ firstPartyEndpoint: true,
+ useResponsesApi: true,
+ });
+ });
+
+ it('keeps the declaration alongside a translated reasoning effort', async () => {
+ /**
+ * The reachable failure from #15598: `resolveReasoningParams` translates the
+ * scalar effort for the summarizer, and without the declaration an effort
+ * the model rejects reached it verbatim.
+ */
+ expect(await summarizeWith({ reasoning_effort: 'minimal' })).toMatchObject({
+ firstPartyEndpoint: true,
+ reasoning: { effort: 'minimal' },
+ });
+ });
+
+ it('does not claim a first-party endpoint behind a user configuration.baseURL', async () => {
+ expect(
+ await summarizeWith({ configuration: { baseURL: 'https://gateway.internal/v1' } }),
+ ).toEqual({ configuration: { baseURL: 'https://gateway.internal/v1' } });
+ });
+
+ it('does not claim a first-party endpoint behind a user baseURL', async () => {
+ expect(await summarizeWith({ baseURL: 'https://gateway.internal/v1' })).toEqual({
+ baseURL: 'https://gateway.internal/v1',
+ });
+ });
+
+ it('leaves credentials and transport to the client', async () => {
+ const parameters = await summarizeWith();
+ expect(parameters.apiKey).toBeUndefined();
+ expect(parameters.model).toBeUndefined();
+ expect(parameters.modelName).toBeUndefined();
+ expect(parameters.streaming).toBeUndefined();
+ expect(parameters.configuration).toBeUndefined();
+ });
+
+ it('leaves a same-endpoint summarizer on the agent client options', async () => {
+ const agents = await callAndCapture({
+ appConfig: makeAppConfig([]),
+ summarizationConfig: { provider: 'openAI', model: 'gpt-6-astra' },
+ });
+ const config = agents[0].summarizationConfig as Record<string, unknown>;
+ expect(config.parameters).toBeUndefined();
+ });
+
+ it('routes a reasoning model the way the agent flow would', async () => {
+ /** `getOpenAIConfig` reads the effort from modelOptions, not from the merged
+ * parameters, so it has to be handed the summarizer's own effort. */
+ expect(await summarizeWith({ reasoning_effort: 'medium' }, 'gpt-5.6')).toMatchObject({
+ firstPartyEndpoint: true,
+ useResponsesApi: true,
+ reasoning: { effort: 'medium' },
+ });
+ });
+
+ it('withholds the declaration when a reverse proxy serves the built-in endpoint', async () => {
+ process.env.OPENAI_REVERSE_PROXY = 'https://gateway.internal/v1';
+ try {
+ expect(await summarizeWith()).toBeUndefined();
+ } finally {
+ delete process.env.OPENAI_REVERSE_PROXY;
+ }
+ });
+
+ it('withholds the declaration when the base URL is user-provided', async () => {
+ process.env.OPENAI_REVERSE_PROXY = 'user_provided';
+ try {
+ expect(await summarizeWith()).toBeUndefined();
+ } finally {
+ delete process.env.OPENAI_REVERSE_PROXY;
+ }
+ });
+
+ it('declares nothing for an agent whose custom endpoint normalized to openAI', async () => {
+ /**
+ * `initializeAgent` rewrites a custom-endpoint agent's provider to `openAI`
+ * while its endpoint keeps the custom name. With summarization omitted, the
+ * summarizer reuses that agent's client — which points at the gateway, not
+ * at OpenAI.
+ */
+ const agents = await callAndCapture({
+ agents: [
+ makeAgent({
+ provider: 'openAI',
+ endpoint: 'MyGateway',
+ model: 'gpt-6-astra',
+ model_parameters: { model: 'gpt-6-astra' },
+ }),
+ ],
+ appConfig: makeAppConfig([
+ { name: 'MyGateway', baseURL: 'https://gateway.internal/v1', apiKey: 'gw-key' },
+ ]),
+ summarizationConfig: { model: 'gpt-6-astra' },
+ });
+ const config = agents[0].summarizationConfig as Record<string, unknown>;
+ expect(config.parameters).toBeUndefined();
+ });
+});
+
// ---------------------------------------------------------------------------
// Suite 8: subagentConfigs
// ---------------------------------------------------------------------------
diff --git a/packages/api/src/agents/run.ts b/packages/api/src/agents/run.ts
index 95a5278983..77cff7a4e7 100644
--- a/packages/api/src/agents/run.ts
+++ b/packages/api/src/agents/run.ts
@@ -5,6 +5,7 @@ import { Run, Providers, Constants, HookRegistry } from '@librechat/agents';
import {
KnownEndpoints,
EModelEndpoint,
+ ReasoningEffort,
MAX_SUBAGENT_DEPTH,
MAX_SUBAGENT_RUN_CONFIGS,
extractEnvVariable,
@@ -98,6 +99,7 @@ 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 { getBuiltInBaseURL } from '~/endpoints/openai/initialize';
import { getProviderConfig } from '~/endpoints/config/providers';
import { buildToolApprovalHooks } from '~/agents/hitl/hooks';
import { getAgentCheckpointer } from '~/agents/checkpointer';
@@ -588,6 +590,104 @@ interface SummarizationClientOverrides {
[key: string]: unknown;
}
+/**
+ * A user-supplied base URL in `summarization.parameters` points the summarizer
+ * at a gateway whose contract is not the built-in provider's, so no built-in
+ * request shaping may be claimed for it.
+ */
+function hasBaseURLOverride(parameters: SummarizationConfig['parameters']): boolean {
+ if (!isPlainObject(parameters)) {
+ return false;
+ }
+ const params = parameters as Record<string, unknown>;
+ if (isNonEmptyString(params.baseURL)) {
+ return true;
+ }
+ return isPlainObject(params.configuration) && 'baseURL' in params.configuration;
+}
+
+/**
+ * The scalar `reasoning_effort` the yaml schema accepts, when it names a known
+ * effort. `getOpenAIConfig` reads the effort from `modelOptions` — the merged
+ * `parameters` reach it too late — so a summarizer that configures one has to
+ * hand it over for the same API routing the agent flow performs.
+ */
+function summarizationReasoningEffort(
+ parameters: SummarizationConfig['parameters'],
+): ReasoningEffort | undefined {
+ if (!isPlainObject(parameters)) {
+ return undefined;
+ }
+ const effort = (parameters as Record<string, unknown>).reasoning_effort;
+ const known = Object.values(ReasoningEffort) as string[];
+ return typeof effort === 'string' && known.includes(effort)
+ ? (effort as ReasoningEffort)
+ : undefined;
+}
+
+/**
+ * Builds the model-specific request shaping a built-in provider's client needs,
+ * for the cross-provider case where the SDK builds that client from these
+ * parameters alone.
+ *
+ * The custom-endpoint path below already runs `getOpenAIConfig`; built-in
+ * providers skipped it entirely, so a summarizer never learned which API its
+ * model takes or whether its endpoint is first-party — and the agents SDK
+ * defaults its model-specific constraints off without that declaration
+ * (LibreChat#15598).
+ *
+ * Credentials and transport are deliberately not returned. A built-in provider
+ * has no configured key here, so the client resolves one the way it does today;
+ * emitting an empty `apiKey` would break that. The admin-configured base URL is
+ * still passed *in*, because whether the endpoint is first-party is exactly what
+ * `OPENAI_REVERSE_PROXY` decides.
+ */
+function resolveBuiltInClientOverrides(
+ provider: string,
+ target: {
+ model?: string;
+ parameters?: SummarizationConfig['parameters'];
+ agentProvider?: string;
+ },
+): SummarizationClientOverrides | undefined {
+ const { model, parameters } = target;
+ if (!isNonEmptyString(model) || hasBaseURLOverride(parameters)) {
+ return undefined;
+ }
+ /**
+ * Mirrors the SDK's own condition: when the summarization provider matches the
+ * agent's, `buildSummarizationClientConfig` spreads the agent's resolved client
+ * options and these parameters layer on top. A custom-endpoint agent is
+ * normalized to the `openAI` provider while keeping its own endpoint name, so
+ * declaring built-in constraints here would claim OpenAI's contract for that
+ * gateway.
+ */
+ if (provider === target.agentProvider) {
+ return undefined;
+ }
+ const baseURL = getBuiltInBaseURL(provider);
+ /** Resolving a user-provided base URL needs a database read this path avoids. */
+ if (isUserProvided(baseURL)) {
+ return undefined;
+ }
+ const { llmConfig } = getOpenAIConfig(
+ '',
+ {
+ modelOptions: { model, reasoning_effort: summarizationReasoningEffort(parameters) },
+ reverseProxyUrl: baseURL,
+ },
+ provider,
+ );
+ const {
+ apiKey: _apiKey,
+ model: _model,
+ modelName: _modelName,
+ streaming: _streaming,
+ ...shaping
+ } = llmConfig;
+ return Object.keys(shaping).length > 0 ? shaping : undefined;
+}
+
/**
* Resolves a summarization provider string (which may be a custom-endpoint name
* like "Ollama") into the SDK-recognized provider and any client-option
@@ -601,6 +701,11 @@ function resolveSummarizationProvider(
rawProvider: string,
appConfig: AppConfig | undefined,
headerContext: { user?: IUser; tenantId?: string; requestBody?: t.RequestBody },
+ target: {
+ model?: string;
+ parameters?: SummarizationConfig['parameters'];
+ agentProvider?: string;
+ } = {},
): {
provider: string;
clientOverrides?: SummarizationClientOverrides;
@@ -614,7 +719,10 @@ function resolveSummarizationProvider(
appConfig,
});
if (!customEndpointConfig) {
- return { provider: overrideProvider };
+ return {
+ provider: overrideProvider,
+ clientOverrides: resolveBuiltInClientOverrides(overrideProvider, target),
+ };
}
const rawApiKey = customEndpointConfig.apiKey ?? '';
const rawBaseURL = customEndpointConfig.baseURL ?? '';
@@ -775,11 +883,15 @@ function shapeSummarizationConfig(
isNonEmptyString(rawProvider) &&
normalizeEndpointName(rawProvider) === normalizeEndpointName(agentEndpoint);
+ const model = config?.model ?? fallbackModel;
+
const { provider, clientOverrides } = isSameEndpointAsAgent
? { provider: fallbackProvider, clientOverrides: undefined }
- : resolveSummarizationProvider(rawProvider, appConfig, headerContext);
-
- const model = config?.model ?? fallbackModel;
+ : resolveSummarizationProvider(rawProvider, appConfig, headerContext, {
+ model,
+ parameters: config?.parameters,
+ agentProvider: fallbackProvider,
+ });
const trigger =
config?.trigger?.type && typeof config?.trigger?.value === 'number'
? { type: config.trigger.type, value: config.trigger.value }
diff --git a/packages/api/src/endpoints/openai/initialize.ts b/packages/api/src/endpoints/openai/initialize.ts
index e662b20810..b86cf43f35 100644
--- a/packages/api/src/endpoints/openai/initialize.ts
+++ b/packages/api/src/endpoints/openai/initialize.ts
@@ -16,6 +16,25 @@ import { resolveEndpointRuntime } from '~/types';
import { validateEndpointURL } from '~/auth';
import { getOpenAIConfig } from './config';
+/**
+ * Admin-configured base URL for a built-in OpenAI-family endpoint, or `undefined`
+ * when the endpoint is served by OpenAI/Azure directly.
+ *
+ * Read at call time rather than module load so environment changes apply, and
+ * shared with callers that must know the endpoint a built-in provider actually
+ * talks to before claiming its contract. May be the `user_provided` sentinel,
+ * which resolves to a per-user value only after a database read.
+ */
+export function getBuiltInBaseURL(endpoint?: string | null): string | undefined {
+ if (endpoint === EModelEndpoint.openAI) {
+ return process.env.OPENAI_REVERSE_PROXY;
+ }
+ if (endpoint === EModelEndpoint.azureOpenAI) {
+ return process.env.AZURE_OPENAI_BASEURL;
+ }
+ return undefined;
+}
+
/**
* Initializes OpenAI options for agent usage. This function always returns configuration
* options and never creates a client instance (equivalent to optionsOnly=true behavior).
@@ -31,8 +50,7 @@ export async function initializeOpenAI(
const { appConfig, user, requestBody } = resolveEndpointRuntime(params);
const openAIConfig = appConfig?.endpoints?.[EModelEndpoint.openAI];
const allConfig = appConfig?.endpoints?.all;
- const { PROXY, OPENAI_API_KEY, AZURE_API_KEY, OPENAI_REVERSE_PROXY, AZURE_OPENAI_BASEURL } =
- process.env;
+ const { PROXY, OPENAI_API_KEY, AZURE_API_KEY } = process.env;
const { key: expiresAt } = requestBody;
const modelName = model_parameters?.model as string | undefined;
@@ -42,13 +60,10 @@ export async function initializeOpenAI(
[EModelEndpoint.azureOpenAI]: AZURE_API_KEY,
};
- const baseURLOptions = {
- [EModelEndpoint.openAI]: OPENAI_REVERSE_PROXY,
- [EModelEndpoint.azureOpenAI]: AZURE_OPENAI_BASEURL,
- };
+ const configuredBaseURL = getBuiltInBaseURL(endpoint);
const userProvidesKey = isUserProvided(credentials[endpoint as keyof typeof credentials]);
- const userProvidesURL = isUserProvided(baseURLOptions[endpoint as keyof typeof baseURLOptions]);
+ const userProvidesURL = isUserProvided(configuredBaseURL);
let userValues: UserKeyValues | null = null;
if (expiresAt && (userProvidesKey || userProvidesURL)) {
@@ -59,9 +74,7 @@ export async function initializeOpenAI(
let apiKey = userProvidesKey
? userValues?.apiKey
: credentials[endpoint as keyof typeof credentials];
- const baseURL = userProvidesURL
- ? userValues?.baseURL
- : baseURLOptions[endpoint as keyof typeof baseURLOptions];
+ const baseURL = userProvidesURL ? userValues?.baseURL : configuredBaseURL;
const clientOptions: OpenAIConfigOptions = {
proxy: PROXY ?? undefined,