@librechat/agents 3.1.72 → 3.1.74

package/src/tools/CodeExecutor.ts

@@ -15,10 +15,41 @@ export const getCodeBaseURL = (): string =>
 
 const imageMessage = 'Image is already displayed to the user';
 const otherMessage = 'File is already downloaded by the user';
+const inheritedFileMessage =
+  'Available as an input — already known to the user';
 const accessMessage =
   'Note: Files from previous executions are automatically available and can be modified.';
 const emptyOutputMessage =
   'stdout: Empty. Ensure you\'re writing output explicitly.\n';
+const inheritedFilesHeader =
+  'Available files (inputs, not generated by this execution):';
+const generatedFilesHeader = 'Generated files:';
+const inheritedNote =
+  'Note: Files in "Available files" are inputs the user (or a skill) already provided to the sandbox. They were not produced by this execution and you should not present them as new outputs in your response.';
+
+/**
+ * Renders one section of the post-execution file listing. Used by the
+ * code/bash tool formatters to keep generated outputs and inherited
+ * inputs visually separated. See BashExecutor for full docs.
+ */
+export function renderFileSection(
+  header: string,
+  files: t.FileRefs,
+  defaultMessage: string
+): string {
+  if (files.length === 0) return '';
+  let out = `${header}\n`;
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const isImage = imageExtRegex.test(file.name);
+    out += `- /mnt/data/${file.name} | ${isImage ? imageMessage : defaultMessage}`;
+    if (i < files.length - 1) {
+      out += files.length <= 3 ? ', ' : ',\n';
+    }
+  }
+  out += '\n';
+  return out;
+}
 
 const SUPPORTED_LANGUAGES = [
   'py',
@@ -196,20 +227,33 @@ function createCodeExecutionTool(
         }
         if (result.stderr) formattedOutput += `stderr:\n${result.stderr}\n`;
         if (result.files && result.files.length > 0) {
-          formattedOutput += 'Generated files:\n';
+          /* See BashExecutor for the rationale: split inherited (read-only
+           * passthrough) inputs from real generated outputs so the LLM
+           * doesn't conflate skill files with newly-produced artifacts. */
+          const inheritedFiles = result.files.filter(
+            (f) => f.inherited === true
+          );
+          const generatedFiles = result.files.filter(
+            (f) => f.inherited !== true
+          );
 
-          const fileCount = result.files.length;
-          for (let i = 0; i < fileCount; i++) {
-            const file = result.files[i];
-            const isImage = imageExtRegex.test(file.name);
-            formattedOutput += `- /mnt/data/${file.name} | ${isImage ? imageMessage : otherMessage}`;
+          formattedOutput += renderFileSection(
+            generatedFilesHeader,
+            generatedFiles,
+            otherMessage
+          );
+          formattedOutput += renderFileSection(
+            inheritedFilesHeader,
+            inheritedFiles,
+            inheritedFileMessage
+          );
 
-            if (i < fileCount - 1) {
-              formattedOutput += fileCount <= 3 ? ', ' : ',\n';
-            }
+          if (generatedFiles.length > 0) {
+            formattedOutput += `\n\n${accessMessage}`;
+          }
+          if (inheritedFiles.length > 0) {
+            formattedOutput += `\n\n${inheritedNote}`;
           }
-
-          formattedOutput += `\n\n${accessMessage}`;
           return [
             formattedOutput.trim(),
             {

package/src/tools/ProgrammaticToolCalling.ts

@@ -5,7 +5,7 @@ import { HttpsProxyAgent } from 'https-proxy-agent';
 import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
-import { imageExtRegex, getCodeBaseURL } from './CodeExecutor';
+import { getCodeBaseURL, renderFileSection } from './CodeExecutor';
 import { Constants } from '@/common';
 
 config();
@@ -14,8 +14,14 @@ config();
 // Constants
 // ============================================================================
 
-const imageMessage = 'Image is already displayed to the user';
 const otherMessage = 'File is already downloaded by the user';
+const inheritedFileMessage =
+  'Available as an input — already known to the user';
+const inheritedFilesHeader =
+  'Available files (inputs, not generated by this execution):';
+const generatedFilesHeader = 'Generated files:';
+const inheritedNote =
+  'Note: Files in "Available files" are inputs the user (or a skill) already provided to the sandbox. They were not produced by this execution and you should not present them as new outputs in your response.';
 const accessMessage =
   'Note: Files from previous executions are automatically available and can be modified.';
 const emptyOutputMessage =
@@ -552,20 +558,29 @@ export function formatCompletedResponse(
   }
 
   if (response.files && response.files.length > 0) {
-    formatted += 'Generated files:\n';
-
-    const fileCount = response.files.length;
-    for (let i = 0; i < fileCount; i++) {
-      const file = response.files[i];
-      const isImage = imageExtRegex.test(file.name);
-      formatted += `- /mnt/data/${file.name} | ${isImage ? imageMessage : otherMessage}`;
+    /* See BashExecutor for the rationale: split inherited (read-only
+     * passthrough) inputs from real generated outputs so the LLM doesn't
+     * conflate skill files with newly-produced artifacts. */
+    const inheritedFiles = response.files.filter((f) => f.inherited === true);
+    const generatedFiles = response.files.filter((f) => f.inherited !== true);
+
+    formatted += renderFileSection(
+      generatedFilesHeader,
+      generatedFiles,
+      otherMessage
+    );
+    formatted += renderFileSection(
+      inheritedFilesHeader,
+      inheritedFiles,
+      inheritedFileMessage
+    );
 
-      if (i < fileCount - 1) {
-        formatted += fileCount <= 3 ? ', ' : ',\n';
-      }
+    if (generatedFiles.length > 0) {
+      formatted += `\n\n${accessMessage}`;
+    }
+    if (inheritedFiles.length > 0) {
+      formatted += `\n\n${inheritedNote}`;
     }
-
-    formatted += `\n\n${accessMessage}`;
   }
 
   return [

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(

package/src/tools/__tests__/ProgrammaticToolCalling.test.ts

@@ -664,6 +664,66 @@ for member in team:
       expect(output).toContain('chart.png');
       expect(output).toContain('Image is already displayed to the user');
     });
+
+    it('splits inherited inputs from generated outputs into distinct sections', () => {
+      const response: t.ProgrammaticExecutionResponse = {
+        status: 'completed',
+        stdout: 'analysis done\n',
+        stderr: '',
+        files: [
+          { id: 'g1', name: 'report.pdf' },
+          { id: 'i1', name: 'pptx/SKILL.md', inherited: true },
+          { id: 'i2', name: 'pptx/scripts/clean.py', inherited: true },
+          { id: 'g2', name: 'chart.png' },
+        ],
+        session_id: 'sess_abc123',
+      };
+
+      const [output, artifact] = formatCompletedResponse(response);
+
+      /* Generated section lists only outputs the run produced. */
+      const generatedIdx = output.indexOf('Generated files:');
+      const inheritedIdx = output.indexOf('Available files (inputs');
+      expect(generatedIdx).toBeGreaterThan(-1);
+      expect(inheritedIdx).toBeGreaterThan(generatedIdx);
+
+      /* Slice each section so we can assert membership without
+       * cross-talk between the two listings. */
+      const generatedSection = output.slice(generatedIdx, inheritedIdx);
+      const inheritedSection = output.slice(inheritedIdx);
+
+      expect(generatedSection).toContain('report.pdf');
+      expect(generatedSection).toContain('chart.png');
+      expect(generatedSection).not.toContain('SKILL.md');
+
+      expect(inheritedSection).toContain('pptx/SKILL.md');
+      expect(inheritedSection).toContain('pptx/scripts/clean.py');
+      expect(inheritedSection).toContain('Available as an input');
+
+      /* The artifact still carries every file so the host can still
+       * thread per-file ids through to subsequent calls. */
+      expect(artifact.files).toHaveLength(4);
+    });
+
+    it('omits the Generated files header when every entry is inherited', () => {
+      const response: t.ProgrammaticExecutionResponse = {
+        status: 'completed',
+        stdout: 'cat: ok\n',
+        stderr: '',
+        files: [
+          { id: 'i1', name: 'pptx/SKILL.md', inherited: true },
+          { id: 'i2', name: 'pptx/editing.md', inherited: true },
+        ],
+        session_id: 'sess_abc123',
+      };
+
+      const [output] = formatCompletedResponse(response);
+
+      expect(output).not.toContain('Generated files:');
+      expect(output).toContain('Available files (inputs');
+      expect(output).toContain('pptx/SKILL.md');
+      expect(output).toContain('pptx/editing.md');
+    });
   });
 
   describe('createProgrammaticToolCallingTool - Manual Invocation', () => {

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

@@ -472,6 +472,130 @@ describe('ToolNode code execution session management', () => {
 
       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)', () => {

package/src/types/tools.ts

@@ -113,6 +113,15 @@ export type FileRef = {
   path?: string;
   /** Session ID this file belongs to (for multi-session file tracking) */
   session_id?: string;
+  /**
+   * `true` when the codeapi sandbox echoed this entry as an unchanged
+   * passthrough of an input the caller already owns (skill files,
+   * downloaded inputs whose hash matched the baseline, inherited
+   * `.dirkeep` markers). The tool-result formatter renders these as
+   * "Available files" rather than "Generated files" so the LLM doesn't
+   * conflate infrastructure inputs with newly-produced outputs.
+   */
+  inherited?: true;
 };
 
 export type FileRefs = FileRef[];