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: Apply the Configured Reasoning Effort to Summarization (#15232)
Danny Avilacdd4c09076aa
diff --git a/packages/api/src/agents/__tests__/run-summarization.test.ts b/packages/api/src/agents/__tests__/run-summarization.test.tsindex 595688c55e..43d7c810ab 100644--- a/packages/api/src/agents/__tests__/run-summarization.test.ts+++ b/packages/api/src/agents/__tests__/run-summarization.test.ts@@ -86,7 +86,9 @@ jest.mock('~/agents/checkpointer', () => ({getAgentCheckpointer: jest.fn().mockResolvedValue({}),}));-import { Run, buildChildInputs, InMemorySubagentTaskStore } from '@librechat/agents';+import { ChatOpenAI } from '@librechat/agents/llm/openai';+import { ChatOpenRouter } from '@librechat/agents/llm/openrouter';+import { Run, Providers, buildChildInputs, InMemorySubagentTaskStore } from '@librechat/agents';/** Minimal RunAgent factory */function makeAgent(@@ -618,6 +620,223 @@ describe('summarizationConfig field passthrough', () => {});});+// ---------------------------------------------------------------------------+// Suite: reasoning effort translation+// ---------------------------------------------------------------------------+const OPENROUTER_MODEL = 'openai/gpt-5.6';+const ADAPTIVE_CLAUDE_MODEL = 'anthropic/claude-sonnet-4.6';++/** Agent whose resolved client options already carry a reasoning configuration. */+function makeReasoningAgent(overrides: {+ provider: string;+ endpoint: string;+ model: string;+ model_parameters: Record<string, unknown>;+}) {+ return makeAgent({+ provider: overrides.provider as never,+ endpoint: overrides.endpoint,+ model: overrides.model,+ model_parameters: overrides.model_parameters as never,+ });+}++describe('summarization reasoning effort', () => {+ it.each(['medium', 'low'])(+ 'overrides an inherited OpenRouter reasoning object with %s, leaving the agent untouched',+ async (reasoningEffort) => {+ const agents = await callAndCapture({+ agents: [+ makeReasoningAgent({+ provider: Providers.OPENROUTER,+ endpoint: 'OpenRouter',+ model: OPENROUTER_MODEL,+ model_parameters: {+ model: OPENROUTER_MODEL,+ modelKwargs: { reasoning: { effort: 'max' } },+ },+ }),+ ],+ summarizationConfig: {+ provider: 'OpenRouter',+ model: OPENROUTER_MODEL,+ parameters: { reasoning_effort: reasoningEffort },+ },+ });++ const mainClientOptions = agents[0].clientOptions as Record<string, unknown>;+ const summaryConfig = agents[0].summarizationConfig as Record<string, unknown>;++ expect(mainClientOptions.modelKwargs).toEqual({ reasoning: { effort: 'max' } });+ expect(summaryConfig.parameters).toEqual({ reasoning: { effort: reasoningEffort } });++ /** The SDK spreads `parameters` onto the agent's own client options. */+ const summaryModel = new ChatOpenRouter({+ ...mainClientOptions,+ ...(summaryConfig.parameters as Record<string, unknown>),+ apiKey: 'test-key',+ model: summaryConfig.model as string,+ });+ const request = summaryModel.invocationParams();++ expect(request.reasoning).toEqual({ effort: reasoningEffort });+ expect(request.reasoning_effort).toBeUndefined();+ },+ );++ it('overrides an inherited OpenAI reasoning object', async () => {+ const agents = await callAndCapture({+ agents: [+ makeReasoningAgent({+ provider: EModelEndpoint.openAI,+ endpoint: EModelEndpoint.openAI,+ model: 'gpt-5.6',+ model_parameters: { model: 'gpt-5.6', reasoning: { effort: 'high' } },+ }),+ ],+ summarizationConfig: {+ provider: EModelEndpoint.openAI,+ model: 'gpt-5.6',+ parameters: { reasoning_effort: 'low' },+ },+ });++ const mainClientOptions = agents[0].clientOptions as Record<string, unknown>;+ const summaryConfig = agents[0].summarizationConfig as Record<string, unknown>;++ expect(mainClientOptions.reasoning).toEqual({ effort: 'high' });+ expect(summaryConfig.parameters).toEqual({ reasoning: { effort: 'low' } });++ const summaryModel = new ChatOpenAI({+ ...mainClientOptions,+ ...(summaryConfig.parameters as Record<string, unknown>),+ apiKey: 'test-key',+ model: summaryConfig.model as string,+ } as never);+ const request = summaryModel.invocationParams() as Record<string, unknown>;++ /** Chat Completions re-emits the object as the scalar the API expects. */+ expect(request.reasoning_effort).toBe('low');+ });++ it('maps effort to verbosity for OpenRouter adaptive Anthropic models', async () => {+ const agents = await callAndCapture({+ agents: [+ makeReasoningAgent({+ provider: Providers.OPENROUTER,+ endpoint: 'OpenRouter',+ model: ADAPTIVE_CLAUDE_MODEL,+ model_parameters: {+ model: ADAPTIVE_CLAUDE_MODEL,+ verbosity: 'max',+ modelKwargs: { reasoning: { enabled: true } },+ },+ }),+ ],+ summarizationConfig: {+ provider: 'OpenRouter',+ model: ADAPTIVE_CLAUDE_MODEL,+ parameters: { reasoning_effort: 'low' },+ },+ });++ const summaryConfig = agents[0].summarizationConfig as Record<string, unknown>;+ expect(summaryConfig.parameters).toEqual({+ verbosity: 'low',+ reasoning: { enabled: true },+ });+ });++ it('turns adaptive thinking off for reasoning_effort "none"', async () => {+ const agents = await callAndCapture({+ agents: [+ makeReasoningAgent({+ provider: Providers.OPENROUTER,+ endpoint: 'OpenRouter',+ model: ADAPTIVE_CLAUDE_MODEL,+ model_parameters: {+ model: ADAPTIVE_CLAUDE_MODEL,+ modelKwargs: { reasoning: { enabled: true } },+ },+ }),+ ],+ summarizationConfig: {+ provider: 'OpenRouter',+ model: ADAPTIVE_CLAUDE_MODEL,+ parameters: { reasoning_effort: 'none' },+ },+ });++ const summaryConfig = agents[0].summarizationConfig as Record<string, unknown>;+ expect(summaryConfig.parameters).toEqual({ reasoning: { enabled: false } });++ const summaryModel = new ChatOpenRouter({+ ...(agents[0].clientOptions as Record<string, unknown>),+ ...(summaryConfig.parameters as Record<string, unknown>),+ apiKey: 'test-key',+ model: ADAPTIVE_CLAUDE_MODEL,+ });+ expect(summaryModel.invocationParams().reasoning).toEqual({ enabled: false });+ });++ it('translates for a custom endpoint that resolves to OpenRouter by baseURL', async () => {+ const appConfig = makeAppConfig([+ { name: 'Router', baseURL: 'https://openrouter.ai/api/v1', apiKey: 'router-key' },+ ]);+ const agents = await callAndCapture({+ summarizationConfig: {+ provider: 'Router',+ model: OPENROUTER_MODEL,+ parameters: { reasoning_effort: 'low' },+ },+ appConfig,+ });++ const summaryConfig = agents[0].summarizationConfig as Record<string, unknown>;+ expect(summaryConfig.provider).toBe(Providers.OPENROUTER);+ expect(summaryConfig.parameters).toMatchObject({ reasoning: { effort: 'low' } });+ expect(summaryConfig.parameters).not.toHaveProperty('reasoning_effort');+ });++ it('leaves parameters untouched for providers with no reasoning_effort concept', async () => {+ const agents = await callAndCapture({+ summarizationConfig: {+ provider: EModelEndpoint.anthropic,+ model: 'claude-3-haiku',+ parameters: { reasoning_effort: 'low' },+ },+ });++ const summaryConfig = agents[0].summarizationConfig as Record<string, unknown>;+ expect(summaryConfig.parameters).toEqual({ reasoning_effort: 'low' });+ });++ it('leaves unrelated parameters and an unset effort untouched', async () => {+ const agents = await callAndCapture({+ agents: [+ makeReasoningAgent({+ provider: Providers.OPENROUTER,+ endpoint: 'OpenRouter',+ model: OPENROUTER_MODEL,+ model_parameters: { model: OPENROUTER_MODEL },+ }),+ ],+ summarizationConfig: {+ provider: 'OpenRouter',+ model: OPENROUTER_MODEL,+ parameters: { temperature: 0.2, streaming: false, reasoning_effort: '' },+ },+ });++ const summaryConfig = agents[0].summarizationConfig as Record<string, unknown>;+ expect(summaryConfig.parameters).toEqual({+ temperature: 0.2,+ streaming: false,+ reasoning_effort: '',+ });+ });+});+// ---------------------------------------------------------------------------// Suite 5: Multi-agent + per-agent overrides// ---------------------------------------------------------------------------diff --git a/packages/api/src/agents/run.ts b/packages/api/src/agents/run.tsindex 029807ebba..e85100d28f 100644--- a/packages/api/src/agents/run.ts+++ b/packages/api/src/agents/run.ts@@ -72,12 +72,12 @@ import {import { applyCustomHandoffPromptKeyCompatibility } from '~/agents/handoffPromptKeyCompatibility';import { stripIntentFromToolRegistry, stripIntentFromToolDefinitions } from '~/agents/intent';import { isSteeringSupported, isSteerPreemptSupported } from '~/agents/steering/runtime';+import { extractDefaultParams, resolveReasoningParams } from '~/endpoints/openai/llm';import { getLLMConfig as getAnthropicLLMConfig } from '~/endpoints/anthropic/llm';import { resolveStreamLimits, resolveSubagentMaxTurns } from '~/agents/config';import { CREATE_FILE_TOOL_NAME, EDIT_FILE_TOOL_NAME } from '~/agents/tools';import { buildAgentInitialToolSessions } from '~/agents/codeFilesSession';import { getProviderConfig } from '~/endpoints/config/providers';-import { extractDefaultParams } from '~/endpoints/openai/llm';import { resolveHeaders, createSafeUser } from '~/utils/env';import { getAgentCheckpointer } from '~/agents/checkpointer';import { getPluginHookSource } from '~/agents/hooks/source';@@ -666,7 +666,11 @@ function resolveSummarizationProvider(* that the main agent relied on. `proxy` is forwarded so outbound proxy* dispatchers (`PROXY` env var) apply to cross-endpoint summarization.*/- const { llmConfig, configOptions } = getOpenAIConfig(+ const {+ llmConfig,+ configOptions,+ provider: detectedProvider,+ } = getOpenAIConfig(apiKey,{reverseProxyUrl: baseURL,@@ -694,8 +698,16 @@ function resolveSummarizationProvider(*/delete clientOverrides.model;delete clientOverrides.modelName;+ /**+ * `getOpenAIConfig` detects OpenRouter from the resolved `baseURL`, which+ * `getProviderConfig` cannot do for an endpoint whose config name isn't+ * `openrouter` — it reports `openAI` for those. Prefer the detected+ * provider so a cross-endpoint summarizer builds the same client the main+ * agent flow builds for that endpoint (`initializeAgent` applies the same+ * precedence).+ */return {- provider: overrideProvider,+ provider: detectedProvider ?? overrideProvider,clientOverrides,};} catch (error) {@@ -753,10 +765,17 @@ function shapeSummarizationConfig(* adding e.g. `configuration.defaultQuery` keeps the resolved `baseURL`* and `defaultHeaders` rather than replacing the whole object.*/- const parameters =+ const mergedParameters =clientOverrides != null? mergeParameters(clientOverrides, config?.parameters): config?.parameters;+ /**+ * 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 });return {enabled: config?.enabled !== false && isNonEmptyString(provider) && isNonEmptyString(model),diff --git a/packages/api/src/endpoints/openai/llm.ts b/packages/api/src/endpoints/openai/llm.tsindex 733ba91cc5..282aca2a17 100644--- a/packages/api/src/endpoints/openai/llm.ts+++ b/packages/api/src/endpoints/openai/llm.ts@@ -1,3 +1,4 @@+import { Providers, isOpenAILike } from '@librechat/agents';import {EModelEndpoint,ReasoningEffort,@@ -349,6 +350,76 @@ function applyOpenRouterReasoningConfig({return true;}+/**+ * Translates a scalar `reasoning_effort` parameter into the reasoning fields an+ * already-resolved OpenAI-compatible client honors, for callers that layer+ * their own parameters on top of a client configuration built elsewhere+ * (summarization reusing the agent's client options).+ *+ * The override has to land in *top-level* fields. A nested `modelKwargs`+ * fragment would replace the inherited `modelKwargs` wholesale, and a scalar+ * `reasoning_effort` is dropped outright: LangChain reads only `reasoning` from+ * constructor fields — `reasoning_effort` is a call-time option. `reasoning` is+ * the one shape every OpenAI-compatible client honors, since Chat Completions+ * re-emits it as `reasoning_effort`, the Responses API sends it as-is, and+ * `ChatOpenRouter` merges it over an inherited `modelKwargs.reasoning`.+ *+ * Mirrors {@link applyOpenRouterReasoningConfig} for OpenRouter's adaptive+ * Anthropic models, where effort is expressed as `verbosity` rather than+ * `reasoning.effort`. Non-OpenAI-compatible providers are left untouched:+ * they have no `reasoning_effort` concept to translate into.+ */+export function resolveReasoningParams({+ provider,+ model,+ parameters,+}: {+ provider?: string | null;+ model?: string | null;+ parameters?: Record<string, unknown>;+}): Record<string, unknown> | undefined {+ if (parameters == null || provider == null) {+ return parameters;+ }++ const reasoningEffort = parameters.reasoning_effort;+ if (typeof reasoningEffort !== 'string' || reasoningEffort === ReasoningEffort.unset) {+ return parameters;+ }++ const isOpenRouter = provider.toLowerCase() === Providers.OPENROUTER;+ if (!isOpenRouter && !isOpenAILike(provider as Providers)) {+ return parameters;+ }++ const resolved = { ...parameters };+ delete resolved.reasoning_effort;++ if (isOpenRouter && isOpenRouterAnthropicAdaptiveModel(model)) {+ /** Adaptive thinking is disabled through the object itself: the inherited+ * `modelKwargs.reasoning` would otherwise keep it enabled, which the main+ * flow's `include_reasoning: false` cannot undo. */+ if (reasoningEffort === ReasoningEffort.none) {+ resolved.reasoning = { enabled: false };+ return resolved;+ }+ const adaptiveVerbosity = getOpenRouterAnthropicVerbosity(reasoningEffort, model);+ if (adaptiveVerbosity != null && resolved.verbosity == null) {+ resolved.verbosity = adaptiveVerbosity;+ }+ resolved.reasoning = { enabled: true };+ return resolved;+ }++ const inherited = resolved.reasoning;+ const base =+ inherited != null && typeof inherited === 'object' && !Array.isArray(inherited)+ ? (inherited as Record<string, unknown>)+ : undefined;+ resolved.reasoning = { ...base, effort: reasoningEffort };+ return resolved;+}+function applyReasoningConfig({endpoint,llmConfig,