@librechat/agents 3.1.84 → 3.1.86

package/src/agents/__tests__/AgentContext.test.ts

@@ -368,7 +368,7 @@ describe('AgentContext', () => {
       expect(result[4].content).toBe('Latest');
     });
 
-    it('does not place Anthropic dynamic instructions between tool calls and results', async () => {
+    it('keeps Anthropic dynamic instructions attached to the latest user turn during tool follow-up', async () => {
       const ctx = createBasicContext({
         agentConfig: {
           provider: Providers.ANTHROPIC,
@@ -401,10 +401,115 @@ describe('AgentContext', () => {
         }),
       ]);
 
-      expect(result[1].content).toBe('Use the tool');
-      expect((result[2] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
-      expect(result[3].getType()).toBe('tool');
-      expect(result[4].content).toBe('Dynamic instructions');
+      expect(result[1].content).toBe('Dynamic instructions');
+      expect(result[2].content).toBe('Use the tool');
+      expect((result[3] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[4].getType()).toBe('tool');
+    });
+
+    it('keeps Anthropic stable history cacheable before dynamic tool-follow-up context', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.ANTHROPIC,
+          clientOptions: {
+            model: 'claude-3-5-sonnet',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('Earlier'),
+        new AIMessage('Earlier assistant response'),
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+      ]);
+      const stableAssistant = result[2].content as TestSystemContentBlock[];
+
+      expect(result[1].content).toBe('Earlier');
+      expect(stableAssistant[0]).toMatchObject({
+        type: 'text',
+        text: 'Earlier assistant response',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[3].content).toBe('Dynamic instructions');
+      expect(result[4].content).toBe('Use the tool');
+      expect((result[5] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[6].getType()).toBe('tool');
+    });
+
+    it('keeps Anthropic dynamic context on latest no-tool turn after mixed prior turns', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.ANTHROPIC,
+          clientOptions: {
+            model: 'claude-3-5-sonnet',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('First turn, no tools'),
+        new AIMessage('First assistant response'),
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+        new AIMessage('4'),
+        new HumanMessage('Now answer without tools'),
+      ]);
+      const firstAssistant = result[2].content as TestSystemContentBlock[];
+      const toolAnswer = result[6].content as TestSystemContentBlock[];
+
+      expect(result[1].content).toBe('First turn, no tools');
+      expect(firstAssistant[0]).toMatchObject({
+        type: 'text',
+        text: 'First assistant response',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[3].content).toBe('Use the tool');
+      expect((result[4] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[5].getType()).toBe('tool');
+      expect(toolAnswer[0]).toMatchObject({
+        type: 'text',
+        text: '4',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[7].content).toBe('Dynamic instructions');
+      expect(result[8].content).toBe('Now answer without tools');
     });
 
     it('caches stable OpenRouter history before dynamic instructions', async () => {
@@ -437,6 +542,150 @@ describe('AgentContext', () => {
       expect(result[4].content).toBe('Latest');
     });
 
+    it('keeps OpenRouter opening user message before dynamic tool-follow-up context', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.OPENROUTER,
+          clientOptions: {
+            model: 'anthropic/claude-haiku-4.5',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+      ]);
+
+      expect(result[1].content).toBe('Use the tool');
+      expect(result[2].content).toBe('Dynamic instructions');
+      expect((result[3] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[4].getType()).toBe('tool');
+    });
+
+    it('keeps OpenRouter stable history cacheable before dynamic tool-follow-up context', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.OPENROUTER,
+          clientOptions: {
+            model: 'anthropic/claude-haiku-4.5',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('Earlier'),
+        new AIMessage('Earlier assistant response'),
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+      ]);
+      const stableAssistant = result[2].content as TestSystemContentBlock[];
+
+      expect(result[1].content).toBe('Earlier');
+      expect(stableAssistant[0]).toMatchObject({
+        type: 'text',
+        text: 'Earlier assistant response',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[3].content).toBe('Dynamic instructions');
+      expect(result[4].content).toBe('Use the tool');
+      expect((result[5] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[6].getType()).toBe('tool');
+    });
+
+    it('keeps OpenRouter dynamic context on latest no-tool turn after mixed prior turns', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.OPENROUTER,
+          clientOptions: {
+            model: 'anthropic/claude-haiku-4.5',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('First turn, no tools'),
+        new AIMessage('First assistant response'),
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+        new AIMessage('4'),
+        new HumanMessage('Now answer without tools'),
+      ]);
+      const firstAssistant = result[2].content as TestSystemContentBlock[];
+      const toolAnswer = result[6].content as TestSystemContentBlock[];
+
+      expect(result[1].content).toBe('First turn, no tools');
+      expect(firstAssistant[0]).toMatchObject({
+        type: 'text',
+        text: 'First assistant response',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[3].content).toBe('Use the tool');
+      expect((result[4] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[5].getType()).toBe('tool');
+      expect(toolAnswer[0]).toMatchObject({
+        type: 'text',
+        text: '4',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[7].content).toBe('Dynamic instructions');
+      expect(result[8].content).toBe('Now answer without tools');
+    });
+
     it('adds OpenRouter body cache points when there is no dynamic tail', async () => {
       const ctx = createBasicContext({
         agentConfig: {

package/src/common/enum.ts

@@ -261,4 +261,5 @@ export enum TitleMethod {
 
 export enum EnvVar {
   CODE_BASEURL = 'LIBRECHAT_CODE_BASEURL',
+  CODE_API_RUN_TIMEOUT_MS = 'CODE_API_RUN_TIMEOUT_MS',
 }

package/src/graphs/MultiAgentGraph.ts

@@ -1074,10 +1074,11 @@ export class MultiAgentGraph extends StandardGraph {
              * to pass filtered messages + prompt to the destination agent
              */
             const filteredMessages = state.messages.slice(0, this.startIndex);
+            const promptMessage = new HumanMessage(promptText);
             return {
-              messages: [new HumanMessage(promptText)],
+              messages: [promptMessage],
               agentMessages: messagesStateReducer(filteredMessages, [
-                new HumanMessage(promptText),
+                promptMessage,
               ]),
             };
           }

package/src/graphs/__tests__/composition.smoke.test.ts

@@ -1,11 +1,17 @@
-import { HumanMessage } from '@langchain/core/messages';
-import type { ToolCall } from '@langchain/core/messages/tool';
+import { HumanMessage, getBufferString } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { ToolCall } from '@langchain/core/messages/tool';
+import type { BaseMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
 import { MultiAgentGraph } from '../MultiAgentGraph';
 import { Constants, Providers } from '@/common';
+import { FakeChatModel } from '@/llm/fake';
 import { StandardGraph } from '../Graph';
 
+const CHAIN_PROMPT_PREFIX = 'Previous context:\n';
+
 const makeAgent = (agentId: string): t.AgentInputs => ({
   agentId,
   provider: Providers.OPENAI,
@@ -29,6 +35,36 @@ const getAiContents = (messages: t.BaseGraphState['messages']): string[] =>
     .map((message) => message.content)
     .filter((content): content is string => typeof content === 'string');
 
+const getChainPromptContent = (messages: BaseMessage[]): string => {
+  const promptMessage = messages.find(
+    (message) =>
+      message.getType() === 'human' &&
+      typeof message.content === 'string' &&
+      message.content.startsWith(CHAIN_PROMPT_PREFIX)
+  );
+  if (promptMessage == null || typeof promptMessage.content !== 'string') {
+    throw new Error('Expected chain prompt message');
+  }
+  return promptMessage.content;
+};
+
+class CapturingChatModel extends FakeChatModel {
+  readonly invocations: BaseMessage[][] = [];
+
+  constructor(responses: string[]) {
+    super({ responses });
+  }
+
+  override async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    this.invocations.push(messages);
+    yield* super._streamResponseChunks(messages, options, runManager);
+  }
+}
+
 const expectCompiledWorkflow = (
   workflow: t.CompiledWorkflow | t.CompiledMultiAgentWorkflow
 ): void => {
@@ -119,6 +155,52 @@ describe('LangGraph composition smoke tests', () => {
     expect(getAiContents(result.messages)).toEqual(['from A', 'from B']);
   });
 
+  it('does not duplicate excludeResults chain prompt history for downstream agents', async () => {
+    const model = new CapturingChatModel(['from A', 'from B', 'from C']);
+    const prompt = (messages: BaseMessage[], startIndex: number): string =>
+      `${CHAIN_PROMPT_PREFIX}${getBufferString(messages.slice(startIndex))}`;
+    const graph = new MultiAgentGraph({
+      runId: 'exclude-results-chain-smoke',
+      agents: [makeAgent('A'), makeAgent('B'), makeAgent('C')],
+      edges: [
+        {
+          from: 'A',
+          to: 'B',
+          edgeType: 'direct',
+          prompt,
+          excludeResults: true,
+        },
+        {
+          from: 'B',
+          to: 'C',
+          edgeType: 'direct',
+          prompt,
+          excludeResults: true,
+        },
+      ],
+    });
+    graph.overrideModel = model;
+
+    const result = await graph
+      .createWorkflow()
+      .invoke(
+        { messages: [new HumanMessage('start')] },
+        makeConfig('exclude-results-chain-smoke')
+      );
+
+    expect(getAiContents(result.messages)).toEqual([
+      'from A',
+      'from B',
+      'from C',
+    ]);
+    expect(model.invocations).toHaveLength(3);
+
+    const downstreamPrompt = getChainPromptContent(model.invocations[2]);
+    const previousPromptCount =
+      downstreamPrompt.match(/Human: Previous context:/g)?.length ?? 0;
+    expect(previousPromptCount).toBe(1);
+  });
+
   it('compiles and invokes a handoff edge using graph-managed transfer tools', async () => {
     const transferToolCall: ToolCall = {
       id: 'call_transfer_to_B',

package/src/tools/BashProgrammaticToolCalling.ts

@@ -1,6 +1,7 @@
 import { config } from 'dotenv';
 import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import type { ToolCall } from '@langchain/core/messages/tool';
+import type { ProgrammaticToolCallingJsonSchema } from './ptcTimeout';
 import type * as t from '@/types';
 import {
   makeRequest,
@@ -8,6 +9,11 @@ import {
   formatCompletedResponse,
 } from './ProgrammaticToolCalling';
 import { getCodeBaseURL } from './CodeExecutor';
+import {
+  clampCodeApiRunTimeoutMs,
+  createCodeApiRunTimeoutSchema,
+  resolveCodeApiRunTimeoutMs,
+} from './ptcTimeout';
 import { Constants } from '@/common';
 
 config();
@@ -17,7 +23,7 @@ config();
 // ============================================================================
 
 const DEFAULT_MAX_ROUND_TRIPS = 20;
-const DEFAULT_TIMEOUT = 60000;
+const DEFAULT_RUN_TIMEOUT_MS = resolveCodeApiRunTimeoutMs();
 
 /** Bash reserved words that get `_tool` suffix when used as function names */
 const BASH_RESERVED = new Set([
@@ -60,7 +66,8 @@ const CORE_RULES = `Rules:
 - Tools are pre-defined as bash functions—DO NOT redefine them
 - Each tool function accepts a JSON string argument
 - Only echo/printf output returns to the model
-- Generated files are automatically available in /mnt/data/ for subsequent executions`;
+- Generated files are automatically available in /mnt/data/ for subsequent executions
+- timeout caps one sandbox run/replay iteration, not the total multi-round-trip workflow`;
 
 const ADDITIONAL_RULES =
   '- Tool names normalized: hyphens→underscores, reserved words get `_tool` suffix';
@@ -92,25 +99,25 @@ ${CORE_RULES}`;
 // Schema
 // ============================================================================
 
-export const BashProgrammaticToolCallingSchema = {
-  type: 'object',
-  properties: {
-    code: {
-      type: 'string',
-      minLength: 1,
-      description: CODE_PARAM_DESCRIPTION,
-    },
-    timeout: {
-      type: 'integer',
-      minimum: 1000,
-      maximum: 300000,
-      default: DEFAULT_TIMEOUT,
-      description:
-        'Maximum execution time in milliseconds. Default: 60 seconds. Max: 5 minutes.',
+export function createBashProgrammaticToolCallingSchema(
+  maxRunTimeoutMs = DEFAULT_RUN_TIMEOUT_MS
+): ProgrammaticToolCallingJsonSchema {
+  return {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        minLength: 1,
+        description: CODE_PARAM_DESCRIPTION,
+      },
+      timeout: createCodeApiRunTimeoutSchema(maxRunTimeoutMs),
     },
-  },
-  required: ['code'],
-} as const;
+    required: ['code'],
+  } as const;
+}
+
+export const BashProgrammaticToolCallingSchema =
+  createBashProgrammaticToolCallingSchema();
 
 export const BashProgrammaticToolCallingName =
   Constants.BASH_PROGRAMMATIC_TOOL_CALLING;
@@ -242,6 +249,7 @@ export function createBashProgrammaticToolCallingTool(
 ): DynamicStructuredTool {
   const baseUrl = initParams.baseUrl ?? getCodeBaseURL();
   const maxRoundTrips = initParams.maxRoundTrips ?? DEFAULT_MAX_ROUND_TRIPS;
+  const maxRunTimeoutMs = resolveCodeApiRunTimeoutMs(initParams.runTimeoutMs);
   const proxy = initParams.proxy ?? process.env.PROXY;
   const debug = initParams.debug ?? process.env.BASH_PTC_DEBUG === 'true';
   const EXEC_ENDPOINT = `${baseUrl}/exec/programmatic`;
@@ -249,7 +257,8 @@ export function createBashProgrammaticToolCallingTool(
   return tool(
     async (rawParams, config) => {
       const params = rawParams as { code: string; timeout?: number };
-      const { code, timeout = DEFAULT_TIMEOUT } = params;
+      const { code } = params;
+      const timeout = clampCodeApiRunTimeoutMs(params.timeout, maxRunTimeoutMs);
 
       const toolCall = (config.toolCall ?? {}) as ToolCall &
         Partial<t.ProgrammaticCache> & {
@@ -382,7 +391,7 @@ export function createBashProgrammaticToolCallingTool(
     {
       name: Constants.BASH_PROGRAMMATIC_TOOL_CALLING,
       description: BashProgrammaticToolCallingDescription,
-      schema: BashProgrammaticToolCallingSchema,
+      schema: createBashProgrammaticToolCallingSchema(maxRunTimeoutMs),
       responseFormat: Constants.CONTENT_AND_ARTIFACT,
     }
   );

package/src/tools/ProgrammaticToolCalling.ts

@@ -4,6 +4,7 @@ import fetch, { RequestInit } from 'node-fetch';
 import { HttpsProxyAgent } from 'https-proxy-agent';
 import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import type { ToolCall } from '@langchain/core/messages/tool';
+import type { ProgrammaticToolCallingJsonSchema } from './ptcTimeout';
 import type * as t from '@/types';
 import {
   buildCodeApiHttpErrorMessage,
@@ -11,6 +12,11 @@ import {
   getCodeBaseURL,
   resolveCodeApiAuthHeaders,
 } from './CodeExecutor';
+import {
+  clampCodeApiRunTimeoutMs,
+  createCodeApiRunTimeoutSchema,
+  resolveCodeApiRunTimeoutMs,
+} from './ptcTimeout';
 import { Constants } from '@/common';
 
 config();
@@ -18,8 +24,7 @@ config();
 /** Default max round-trips to prevent infinite loops */
 const DEFAULT_MAX_ROUND_TRIPS = 20;
 
-/** Default execution timeout in milliseconds */
-const DEFAULT_TIMEOUT = 60000;
+const DEFAULT_RUN_TIMEOUT_MS = resolveCodeApiRunTimeoutMs();
 
 // ============================================================================
 // Description Components (Single Source of Truth)
@@ -35,7 +40,8 @@ const CORE_RULES = `Rules:
 - Just write code with await—auto-wrapped in async context
 - DO NOT define async def main() or call asyncio.run()
 - Tools are pre-defined—DO NOT write function definitions
-- Only print() output returns to the model`;
+- Only print() output returns to the model
+- timeout caps one sandbox run/replay iteration, not the total multi-round-trip workflow`;
 
 const ADDITIONAL_RULES = `- Generated files are automatically available in /mnt/data/ for subsequent executions
 - Tool names normalized: hyphens→underscores, keywords get \`_tool\` suffix`;
@@ -68,25 +74,25 @@ ${EXAMPLES}
 
 ${CORE_RULES}`;
 
-export const ProgrammaticToolCallingSchema = {
-  type: 'object',
-  properties: {
-    code: {
-      type: 'string',
-      minLength: 1,
-      description: CODE_PARAM_DESCRIPTION,
-    },
-    timeout: {
-      type: 'integer',
-      minimum: 1000,
-      maximum: 300000,
-      default: DEFAULT_TIMEOUT,
-      description:
-        'Maximum execution time in milliseconds. Default: 60 seconds. Max: 5 minutes.',
+export function createProgrammaticToolCallingSchema(
+  maxRunTimeoutMs = DEFAULT_RUN_TIMEOUT_MS
+): ProgrammaticToolCallingJsonSchema {
+  return {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        minLength: 1,
+        description: CODE_PARAM_DESCRIPTION,
+      },
+      timeout: createCodeApiRunTimeoutSchema(maxRunTimeoutMs),
     },
-  },
-  required: ['code'],
-} as const;
+    required: ['code'],
+  } as const;
+}
+
+export const ProgrammaticToolCallingSchema =
+  createProgrammaticToolCallingSchema();
 
 export const ProgrammaticToolCallingName = Constants.PROGRAMMATIC_TOOL_CALLING;
 
@@ -731,6 +737,7 @@ export function createProgrammaticToolCallingTool(
 ): DynamicStructuredTool {
   const baseUrl = initParams.baseUrl ?? getCodeBaseURL();
   const maxRoundTrips = initParams.maxRoundTrips ?? DEFAULT_MAX_ROUND_TRIPS;
+  const maxRunTimeoutMs = resolveCodeApiRunTimeoutMs(initParams.runTimeoutMs);
   const proxy = initParams.proxy ?? process.env.PROXY;
   const debug = initParams.debug ?? process.env.PTC_DEBUG === 'true';
   const EXEC_ENDPOINT = `${baseUrl}/exec/programmatic`;
@@ -738,7 +745,8 @@ export function createProgrammaticToolCallingTool(
   return tool(
     async (rawParams, config) => {
       const params = rawParams as { code: string; timeout?: number };
-      const { code, timeout = DEFAULT_TIMEOUT } = params;
+      const { code } = params;
+      const timeout = clampCodeApiRunTimeoutMs(params.timeout, maxRunTimeoutMs);
 
       // Extra params injected by ToolNode (follows web_search pattern).
       const toolCall = (config.toolCall ?? {}) as ToolCall &
@@ -873,7 +881,7 @@ export function createProgrammaticToolCallingTool(
     {
       name: Constants.PROGRAMMATIC_TOOL_CALLING,
       description: ProgrammaticToolCallingDescription,
-      schema: ProgrammaticToolCallingSchema,
+      schema: createProgrammaticToolCallingSchema(maxRunTimeoutMs),
       responseFormat: Constants.CONTENT_AND_ARTIFACT,
     }
   );