@librechat/agents 3.1.71 → 3.1.73

package/src/messages/ensureThinkingBlock.test.ts

@@ -1209,4 +1209,171 @@ describe('ensureThinkingBlockInMessages', () => {
       expect(outputImageBlock).not.toBe(originalImageBlock);
     });
   });
+
+  describe('runStartIndex (current-run boundary)', () => {
+    /**
+     * Claude is allowed to skip a thinking block before a tool_use (cf.
+     * PR #116). When the agent's own first iteration produces an
+     * `AI(tool_use, no thinking)`, the function would otherwise convert
+     * it to a `[Previous agent context]` HumanMessage — polluting the
+     * next iteration's prompt with text the model treats as suspicious
+     * injected content. The model then ignores its own real prior tool
+     * result and re-runs the tool to verify, often failing because the
+     * subsequent sandbox doesn't have the file.
+     *
+     * The `runStartIndex` parameter tells the function which messages
+     * are the agent's own in-run work: those at or after it must NEVER
+     * be converted, even if no thinking block appears in the chain.
+     */
+
+    test('preserves the agent first-iteration AI(tool_use) when its index is at runStartIndex', () => {
+      const messages = [
+        new HumanMessage({ content: 'fetch the data' }),
+        // No thinking block — Claude validly skipped it before tool_use
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            { id: 'c1', name: 'fetch', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'data', tool_call_id: 'c1' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.BEDROCK,
+        undefined,
+        /* runStartIndex */ 1
+      );
+
+      // All 3 preserved — the AI at index 1 is the agent's own work
+      expect(result).toHaveLength(3);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect((result[1] as AIMessage).tool_calls).toHaveLength(1);
+      expect(result[2]).toBeInstanceOf(ToolMessage);
+      // No placeholder leaked in
+      expect(getTextContent(result[1])).not.toContain(
+        '[Previous agent context]'
+      );
+    });
+
+    test('preserves multiple in-run AI(tool_use) iterations without thinking blocks', () => {
+      const messages = [
+        new HumanMessage({ content: 'do work' }),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            { id: 'c1', name: 'step1', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r1', tool_call_id: 'c1' }),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            { id: 'c2', name: 'step2', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r2', tool_call_id: 'c2' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.BEDROCK,
+        undefined,
+        /* runStartIndex */ 1
+      );
+
+      expect(result).toHaveLength(5);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect(result[3]).toBeInstanceOf(AIMessage);
+      // Neither AI was converted
+      expect(getTextContent(result[1])).not.toContain(
+        '[Previous agent context]'
+      );
+      expect(getTextContent(result[3])).not.toContain(
+        '[Previous agent context]'
+      );
+    });
+
+    test('still converts pre-runStartIndex history that lacks thinking blocks', () => {
+      // Real handoff scenario: a prior non-thinking agent's tool calls
+      // appear before this run started. They genuinely need the
+      // placeholder (the legacy reason this function exists).
+      const messages = [
+        new HumanMessage({ content: 'first request' }),
+        new AIMessage({
+          content: 'using tool',
+          tool_calls: [
+            { id: 'old', name: 'legacy', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'old result', tool_call_id: 'old' }),
+        // Current run starts here — say after a handoff. Index >= 3 is
+        // the new agent's own work.
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.BEDROCK,
+        undefined,
+        /* runStartIndex */ 3
+      );
+
+      // The pre-run AI(tool_use)+Tool got converted to a placeholder
+      expect(result).toHaveLength(2);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(HumanMessage);
+      expect(getTextContent(result[1])).toContain('[Previous agent context]');
+    });
+
+    test('falls back to chainHasThinkingBlock heuristic when runStartIndex is undefined (backward compat)', () => {
+      const messages = [
+        new HumanMessage({ content: 'do work' }),
+        // No reasoning + no runStartIndex hint → still gets converted
+        // (preserves the prior behavior for callers that haven't been
+        // updated to pass the boundary).
+        new AIMessage({
+          content: 'using tool',
+          tool_calls: [
+            { id: 'c1', name: 'tool', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r', tool_call_id: 'c1' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(messages, Providers.BEDROCK);
+
+      expect(result).toHaveLength(2);
+      expect(result[1]).toBeInstanceOf(HumanMessage);
+      expect(getTextContent(result[1])).toContain('[Previous agent context]');
+    });
+
+    test('runStartIndex of 0 is honored (whole array is the current run)', () => {
+      // Edge: a fresh run with no prior history at all. Everything is
+      // in-run and must be preserved even without thinking blocks.
+      const messages = [
+        new HumanMessage({ content: 'do work' }),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            { id: 'c1', name: 'tool', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r', tool_call_id: 'c1' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.BEDROCK,
+        undefined,
+        /* runStartIndex */ 0
+      );
+
+      expect(result).toHaveLength(3);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect(getTextContent(result[1])).not.toContain(
+        '[Previous agent context]'
+      );
+    });
+  });
 });

package/src/messages/format.ts

@@ -1391,12 +1391,23 @@ function appendToolCalls(
  * @param messages - Array of messages to process
  * @param provider - The provider being used (unused but kept for future compatibility)
  * @param config - Optional RunnableConfig for structured agent logging
+ * @param runStartIndex - Index in `messages` where the CURRENT run's own
+ *   appended AI/Tool messages begin (i.e. anything at this index or later
+ *   was just produced by this run's own iterations, not historical
+ *   context). When provided, AI messages at or after this index are
+ *   never converted to `[Previous agent context]` placeholders — Claude
+ *   can validly skip a thinking block before a tool_use (cf. PR #116),
+ *   so the agent's own in-run iterations must not be misclassified as
+ *   foreign history. Without the signal the function falls back to its
+ *   prior heuristic (`chainHasThinkingBlock`), preserving backward
+ *   compatibility for callers that don't yet pass the boundary.
  * @returns The messages array with tool sequences converted to buffer strings if necessary
  */
 export function ensureThinkingBlockInMessages(
   messages: BaseMessage[],
   _provider: Providers,
-  config?: RunnableConfig
+  config?: RunnableConfig,
+  runStartIndex?: number
 ): BaseMessage[] {
   if (messages.length === 0) {
     return messages;
@@ -1483,6 +1494,23 @@ export function ensureThinkingBlockInMessages(
     // but follow-ups have content: "" with only tool_calls. These are the
     // same agent's turn and must NOT be converted to HumanMessages.
     if (hasToolUse && !hasThinkingBlock) {
+      // Current-run boundary check: anything at or after `runStartIndex`
+      // is the current run's own work — preserve it. Claude is allowed
+      // to skip a thinking block before a tool_use (cf. PR #116 in the
+      // agents repo), so the agent's own first-iteration AI message can
+      // legitimately have tool_calls without reasoning. Converting it to
+      // a `[Previous agent context]` placeholder pollutes the next
+      // iteration's prompt — the LLM sees the placeholder, treats it as
+      // suspicious injected content, ignores its own real prior tool
+      // result, and re-runs the tool to verify (which then often fails
+      // because subsequent calls land in fresh sandboxes without the
+      // file). Skip the conversion when we know this is in-run.
+      if (runStartIndex !== undefined && i >= runStartIndex) {
+        result.push(msg);
+        i++;
+        continue;
+      }
+
       // Walk backwards — if an earlier AI message in the same chain (before
       // the nearest HumanMessage) has a thinking/reasoning block, this is a
       // continuation of a thinking-enabled turn, not a non-thinking handoff.

package/src/tools/ToolNode.ts

@@ -89,7 +89,26 @@ function isSend(value: unknown): value is Send {
   return value instanceof Send;
 }
 
-/** Merges code execution session context into the sessions map. */
+/**
+ * Merges code execution session context into the sessions map.
+ *
+ * The codeapi worker reports two distinct ids on a code-execution result:
+ *  - `artifact.session_id` (the `sessionId` arg here) is the EXEC session
+ *    — the sandbox VM that ran the code. It's transient and torn down
+ *    post-execution; subsequent calls cannot reuse it as a sandbox.
+ *  - `file.session_id` on each `artifact.files[i]` is the STORAGE
+ *    session — the file-server bucket prefix where the artifact actually
+ *    lives and is served from.
+ *
+ * Per-file `session_id` is preserved (not overwritten with the exec id)
+ * because `_injected_files` are looked up against the file-server's
+ * storage path on subsequent tool calls. Stomping the storage id with
+ * the exec id silently 404s every follow-up tool call within the same
+ * run — `cat /mnt/data/foo.txt` reports "No such file or directory"
+ * because the worker can't mount a file at a path the storage doesn't
+ * know about. Fall back to `sessionId` only when the per-file id is
+ * absent (older worker payloads).
+ */
 function updateCodeSession(
   sessions: t.ToolSessionMap,
   sessionId: string,
@@ -104,7 +123,7 @@ function updateCodeSession(
   if (newFiles.length > 0) {
     const filesWithSession: t.FileRefs = newFiles.map((file) => ({
       ...file,
-      session_id: sessionId,
+      session_id: file.session_id ?? sessionId,
     }));
     const newFileNames = new Set(filesWithSession.map((f) => f.name));
     const filteredExisting = existingFiles.filter(
@@ -996,9 +1015,21 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
           turn,
         };
 
+        /**
+         * Emit `codeSessionContext` for any tool whose host handler may need
+         * to reach into the code-execution sandbox:
+         *   - `CODE_EXECUTION_TOOLS` — direct executors that POST to /exec.
+         *   - `SKILL_TOOL` — skill files live alongside code-env state.
+         *   - `READ_FILE` — when the requested path is a code-env artifact
+         *     (e.g. `/mnt/data/...`) the host falls back to reading via the
+         *     same sandbox session; without the seeded `session_id` /
+         *     `_injected_files` here, that fallback can't see prior-turn
+         *     artifacts on the very first call of a turn.
+         */
         if (
           CODE_EXECUTION_TOOLS.has(entry.call.name) ||
-          entry.call.name === Constants.SKILL_TOOL
+          entry.call.name === Constants.SKILL_TOOL ||
+          entry.call.name === Constants.READ_FILE
         ) {
           request.codeSessionContext = this.getCodeSessionContext();
         }

package/src/tools/__tests__/ToolNode.session.test.ts

@@ -1,11 +1,12 @@
 import { z } from 'zod';
 import { tool } from '@langchain/core/tools';
 import { AIMessage } from '@langchain/core/messages';
-import { describe, it, expect } from '@jest/globals';
+import { describe, it, expect, jest, afterEach } from '@jest/globals';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type * as t from '@/types';
 import { ToolNode } from '../ToolNode';
 import { Constants } from '@/common';
+import * as events from '@/utils/events';
 
 /**
  * Creates a mock execute_code tool that captures the toolCall config it receives.
@@ -233,7 +234,9 @@ describe('ToolNode code execution session management', () => {
             status: 'success',
           },
         ],
-        new Map([['tc1', { id: 'tc1', name: Constants.EXECUTE_CODE, args: {} }]])
+        new Map([
+          ['tc1', { id: 'tc1', name: Constants.EXECUTE_CODE, args: {} }],
+        ])
       );
 
       const stored = sessions.get(
@@ -279,7 +282,9 @@ describe('ToolNode code execution session management', () => {
             status: 'success',
           },
         ],
-        new Map([['tc2', { id: 'tc2', name: Constants.EXECUTE_CODE, args: {} }]])
+        new Map([
+          ['tc2', { id: 'tc2', name: Constants.EXECUTE_CODE, args: {} }],
+        ])
       );
 
       const stored = sessions.get(
@@ -329,7 +334,9 @@ describe('ToolNode code execution session management', () => {
             status: 'success',
           },
         ],
-        new Map([['tc3', { id: 'tc3', name: Constants.EXECUTE_CODE, args: {} }]])
+        new Map([
+          ['tc3', { id: 'tc3', name: Constants.EXECUTE_CODE, args: {} }],
+        ])
       );
 
       const stored = sessions.get(
@@ -379,7 +386,9 @@ describe('ToolNode code execution session management', () => {
             status: 'success',
           },
         ],
-        new Map([['tc4', { id: 'tc4', name: Constants.EXECUTE_CODE, args: {} }]])
+        new Map([
+          ['tc4', { id: 'tc4', name: Constants.EXECUTE_CODE, args: {} }],
+        ])
       );
 
       const stored = sessions.get(
@@ -456,10 +465,274 @@ describe('ToolNode code execution session management', () => {
             errorMessage: 'execution failed',
           },
         ],
-        new Map([['tc6', { id: 'tc6', name: Constants.EXECUTE_CODE, args: {} }]])
+        new Map([
+          ['tc6', { id: 'tc6', name: Constants.EXECUTE_CODE, args: {} }],
+        ])
       );
 
       expect(sessions.has(Constants.EXECUTE_CODE)).toBe(false);
     });
+
+    it('preserves per-file storage session_id (not overwritten with the exec session_id)', () => {
+      /**
+       * Regression: the codeapi worker reports `artifact.session_id` (EXEC
+       * session — torn down post-run) and per-file `session_id` (STORAGE
+       * session where the file lives). Stomping the storage id with the
+       * exec id silently 404s every follow-up tool call within the same
+       * run because `_injected_files` carry the wrong path on the next
+       * `/exec`. The worker tries to mount `<exec_session>/<id>` against
+       * file-server, gets 404, mounts nothing — `cat /mnt/data/foo.txt`
+       * → "No such file or directory".
+       */
+      const sessions: t.ToolSessionMap = new Map();
+      const mockTool = createMockCodeTool({ capturedConfigs: [] });
+      const toolNode = new ToolNode({
+        tools: [mockTool],
+        sessions,
+        eventDrivenMode: true,
+      });
+      const storeMethod = (
+        toolNode as unknown as {
+          storeCodeSessionFromResults: (
+            results: t.ToolExecuteResult[],
+            requestMap: Map<string, t.ToolCallRequest>
+          ) => void;
+        }
+      ).storeCodeSessionFromResults.bind(toolNode);
+
+      storeMethod(
+        [
+          {
+            toolCallId: 'tc-storage',
+            content: 'output',
+            artifact: {
+              /* EXEC session — transient, torn down after this run */
+              session_id: 'exec-session-123',
+              files: [
+                /* STORAGE session — persistent file-server bucket prefix */
+                {
+                  id: 'f1',
+                  name: 'sentinel.txt',
+                  session_id: 'storage-session-A',
+                },
+                { id: 'f2', name: 'data.csv', session_id: 'storage-session-B' },
+              ],
+            },
+            status: 'success',
+          },
+        ],
+        new Map([
+          [
+            'tc-storage',
+            { id: 'tc-storage', name: Constants.EXECUTE_CODE, args: {} },
+          ],
+        ])
+      );
+
+      const stored = sessions.get(
+        Constants.EXECUTE_CODE
+      ) as t.CodeSessionContext;
+      /* The session-level id is the (latest) exec id — fine for tracking
+         "what session ran last" — but per-file storage ids must survive. */
+      expect(stored.session_id).toBe('exec-session-123');
+      expect(stored.files).toHaveLength(2);
+      expect(stored.files![0]).toEqual({
+        id: 'f1',
+        name: 'sentinel.txt',
+        session_id: 'storage-session-A',
+      });
+      expect(stored.files![1]).toEqual({
+        id: 'f2',
+        name: 'data.csv',
+        session_id: 'storage-session-B',
+      });
+    });
+
+    it('falls back to exec session_id only when per-file session_id is absent (older worker payloads)', () => {
+      const sessions: t.ToolSessionMap = new Map();
+      const mockTool = createMockCodeTool({ capturedConfigs: [] });
+      const toolNode = new ToolNode({
+        tools: [mockTool],
+        sessions,
+        eventDrivenMode: true,
+      });
+      const storeMethod = (
+        toolNode as unknown as {
+          storeCodeSessionFromResults: (
+            results: t.ToolExecuteResult[],
+            requestMap: Map<string, t.ToolCallRequest>
+          ) => void;
+        }
+      ).storeCodeSessionFromResults.bind(toolNode);
+
+      storeMethod(
+        [
+          {
+            toolCallId: 'tc-mixed',
+            content: 'output',
+            artifact: {
+              session_id: 'exec-mixed',
+              files: [
+                /* Mix: one file with storage id, one without (older payload). */
+                { id: 'f1', name: 'fresh.csv', session_id: 'storage-fresh' },
+                { id: 'f2', name: 'legacy.csv' },
+              ],
+            },
+            status: 'success',
+          },
+        ],
+        new Map([
+          [
+            'tc-mixed',
+            { id: 'tc-mixed', name: Constants.EXECUTE_CODE, args: {} },
+          ],
+        ])
+      );
+
+      const stored = sessions.get(
+        Constants.EXECUTE_CODE
+      ) as t.CodeSessionContext;
+      expect(stored.files![0].session_id).toBe('storage-fresh');
+      /* Fallback only when the per-file id is missing. */
+      expect(stored.files![1].session_id).toBe('exec-mixed');
+    });
+  });
+
+  describe('codeSessionContext emission gate (event-driven request building)', () => {
+    /**
+     * Captures the `ToolExecuteBatchRequest` dispatched on ON_TOOL_EXECUTE so
+     * we can assert which `request.name`s receive `codeSessionContext`. Returns
+     * the captured requests; resolves the dispatched event with empty results
+     * to let `dispatchToolEvents` complete.
+     */
+    function captureBatchRequests(): {
+      capturedRequests: t.ToolCallRequest[];
+      } {
+      const capturedRequests: t.ToolCallRequest[] = [];
+      jest
+        .spyOn(events, 'safeDispatchCustomEvent')
+        .mockImplementation(async (_event, data) => {
+          const batch = data as t.ToolExecuteBatchRequest;
+          if (Array.isArray(batch.toolCalls)) {
+            capturedRequests.push(...batch.toolCalls);
+          }
+          if (typeof batch.resolve === 'function') {
+            batch.resolve(
+              batch.toolCalls.map((tc) => ({
+                toolCallId: tc.id,
+                content: '',
+                status: 'success' as const,
+              }))
+            );
+          }
+        });
+      return { capturedRequests };
+    }
+
+    const createDummyTool = (name: string): StructuredToolInterface =>
+      tool(async () => 'ok', {
+        name,
+        description: 'dummy',
+        schema: z.object({ x: z.string().optional() }),
+      }) as unknown as StructuredToolInterface;
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('attaches codeSessionContext to read_file requests so the host can fall back to the code-env sandbox', async () => {
+      const sessions: t.ToolSessionMap = new Map();
+      sessions.set(Constants.EXECUTE_CODE, {
+        session_id: 'rf-session',
+        files: [{ id: 'rf1', name: 'data.csv', session_id: 'rf-session' }],
+        lastUpdated: Date.now(),
+      } satisfies t.CodeSessionContext);
+
+      const { capturedRequests } = captureBatchRequests();
+
+      const toolNode = new ToolNode({
+        tools: [createDummyTool(Constants.READ_FILE)],
+        sessions,
+        eventDrivenMode: true,
+        toolCallStepIds: new Map([['call_rf', 'step_rf']]),
+      });
+
+      const aiMsg = new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_rf',
+            name: Constants.READ_FILE,
+            args: { file_path: '/mnt/data/data.csv' },
+          },
+        ],
+      });
+
+      await toolNode.invoke({ messages: [aiMsg] });
+
+      expect(capturedRequests).toHaveLength(1);
+      expect(capturedRequests[0].name).toBe(Constants.READ_FILE);
+      expect(capturedRequests[0].codeSessionContext).toEqual({
+        session_id: 'rf-session',
+        files: [{ session_id: 'rf-session', id: 'rf1', name: 'data.csv' }],
+      });
+    });
+
+    it('does not attach codeSessionContext to read_file when no session exists yet', async () => {
+      const { capturedRequests } = captureBatchRequests();
+
+      const toolNode = new ToolNode({
+        tools: [createDummyTool(Constants.READ_FILE)],
+        sessions: new Map(),
+        eventDrivenMode: true,
+        toolCallStepIds: new Map([['call_rf2', 'step_rf2']]),
+      });
+
+      const aiMsg = new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_rf2',
+            name: Constants.READ_FILE,
+            args: { file_path: 'some-skill/notes.md' },
+          },
+        ],
+      });
+
+      await toolNode.invoke({ messages: [aiMsg] });
+
+      expect(capturedRequests).toHaveLength(1);
+      expect(capturedRequests[0].name).toBe(Constants.READ_FILE);
+      expect(capturedRequests[0].codeSessionContext).toBeUndefined();
+    });
+
+    it('does not attach codeSessionContext to unrelated tools', async () => {
+      const sessions: t.ToolSessionMap = new Map();
+      sessions.set(Constants.EXECUTE_CODE, {
+        session_id: 'unrelated-session',
+        files: [],
+        lastUpdated: Date.now(),
+      } satisfies t.CodeSessionContext);
+
+      const { capturedRequests } = captureBatchRequests();
+
+      const toolNode = new ToolNode({
+        tools: [createDummyTool('web_search')],
+        sessions,
+        eventDrivenMode: true,
+        toolCallStepIds: new Map([['call_ws', 'step_ws']]),
+      });
+
+      const aiMsg = new AIMessage({
+        content: '',
+        tool_calls: [{ id: 'call_ws', name: 'web_search', args: { x: 'q' } }],
+      });
+
+      await toolNode.invoke({ messages: [aiMsg] });
+
+      expect(capturedRequests).toHaveLength(1);
+      expect(capturedRequests[0].name).toBe('web_search');
+      expect(capturedRequests[0].codeSessionContext).toBeUndefined();
+    });
   });
 });