@librechat/agents 3.1.80-dev.1 → 3.1.80-dev.3

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

@@ -626,7 +626,13 @@ for member in team:
       expect(output).toContain('stderr:\nWarning: deprecated function');
     });
 
-    it('formats file information correctly', () => {
+    it('preserves files on the artifact but omits them from the LLM-facing output', () => {
+      /* The post-execution file summary was removed because it
+       * misled the model more than it helped — especially with
+       * bash, where models naturally `ls /mnt/data/` to discover
+       * available files. The artifact still carries every file
+       * so the host's session-tracking layer stays in sync;
+       * the LLM just doesn't see the prescriptive listing. */
       const response: t.ProgrammaticExecutionResponse = {
         status: 'completed',
         stdout: 'Generated report\n',
@@ -634,95 +640,26 @@ for member in team:
         files: [
           { id: '1', name: 'report.pdf' },
           { id: '2', name: 'data.csv' },
-        ],
-        session_id: 'sess_abc123',
-      };
-
-      const [output, artifact] = formatCompletedResponse(response);
-
-      expect(output).toContain('Generated files:');
-      expect(output).toContain('report.pdf');
-      expect(output).toContain('data.csv');
-      expect(artifact.files).toHaveLength(2);
-      expect(artifact.files).toEqual(response.files);
-    });
-
-    it('handles image files with special message', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: '',
-        stderr: '',
-        files: [
-          { id: '1', name: 'chart.png' },
-          { id: '2', name: 'photo.jpg' },
-        ],
-        session_id: 'sess_abc123',
-      };
-
-      const [output] = formatCompletedResponse(response);
-
-      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);
-
+      /* Tool result text is stdout/stderr only. */
+      expect(output).toContain('stdout:\nGenerated report');
       expect(output).not.toContain('Generated files:');
-      expect(output).toContain('Available files (inputs');
-      expect(output).toContain('pptx/SKILL.md');
-      expect(output).toContain('pptx/editing.md');
+      expect(output).not.toContain('Available files');
+      expect(output).not.toContain('report.pdf');
+      expect(output).not.toContain('SKILL.md');
+      expect(output).not.toContain('Image is already displayed');
+      expect(output).not.toContain('Available as an input');
+
+      /* Host-facing artifact still has every file with its
+       * `inherited` flag intact for session-context merging. */
+      expect(artifact.files).toHaveLength(3);
+      expect(artifact.files).toEqual(response.files);
     });
   });
 
@@ -922,7 +859,11 @@ for member in team:
       });
     });
 
-    it('formats response with files', () => {
+    it('passes files through on the artifact, never on the LLM-facing output', () => {
+      /* Output stays stdout/stderr-only regardless of file count or
+       * filename shape. The artifact is the sole sink for file refs;
+       * hosts thread them into `_injected_files` on subsequent
+       * tool calls via `storeCodeSessionFromResults`. */
       const response: t.ProgrammaticExecutionResponse = {
         status: 'completed',
         stdout: 'Report generated\n',
@@ -930,61 +871,21 @@ for member in team:
         files: [
           { id: '1', name: 'report.csv' },
           { id: '2', name: 'chart.png' },
-        ],
-        session_id: 'sess_xyz',
-      };
-
-      const [output, artifact] = formatCompletedResponse(response);
-
-      expect(output).toContain('Generated files:');
-      expect(output).toContain('report.csv');
-      expect(output).toContain('chart.png');
-      expect(output).toContain('File is already downloaded');
-      expect(output).toContain('Image is already displayed');
-      expect(artifact.files).toHaveLength(2);
-    });
-
-    it('handles multiple files with correct separators', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: 'Done\n',
-        stderr: '',
-        files: [
-          { id: '1', name: 'file1.txt' },
-          { id: '2', name: 'file2.txt' },
-        ],
-        session_id: 'sess_xyz',
-      };
-
-      const [output] = formatCompletedResponse(response);
-
-      // 2 files format: "- /mnt/data/file1.txt | ..., - /mnt/data/file2.txt | ..."
-      expect(output).toContain('file1.txt');
-      expect(output).toContain('file2.txt');
-      expect(output).toContain('- /mnt/data/file1.txt');
-      expect(output).toContain('- /mnt/data/file2.txt');
-    });
-
-    it('handles many files with newline separators', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: 'Done\n',
-        stderr: '',
-        files: [
-          { id: '1', name: 'file1.txt' },
-          { id: '2', name: 'file2.txt' },
           { id: '3', name: 'file3.txt' },
           { id: '4', name: 'file4.txt' },
         ],
         session_id: 'sess_xyz',
       };
 
-      const [output] = formatCompletedResponse(response);
+      const [output, artifact] = formatCompletedResponse(response);
+
+      expect(output).toBe('stdout:\nReport generated');
+      expect(output).not.toContain('report.csv');
+      expect(output).not.toContain('chart.png');
+      expect(output).not.toContain('/mnt/data/');
 
-      // More than 3 files should use newline separators
-      expect(output).toContain('file1.txt');
-      expect(output).toContain('file4.txt');
-      expect(output.match(/,\n/g)?.length).toBeGreaterThanOrEqual(2);
+      expect(artifact.files).toHaveLength(4);
+      expect(artifact.files).toEqual(response.files);
     });
   });
 

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

@@ -512,6 +512,188 @@ describe('ToolNode code execution session management', () => {
       expect(chartFile!.storage_session_id).toBe('new-sess');
     });
 
+    it('preserves prior kind/resource_id/version when worker echoes inherited file (skill 403 regression)', () => {
+      /**
+       * Regression for the codeapi `session_key_mismatch` 403 that
+       * fires on the second `/exec` after a successful skill prime.
+       *
+       * Worker `inherited: true` echoes carry only
+       * `(id, name, storage_session_id)` — the sandbox doesn't know
+       * the resource identity (`kind`, `resource_id`, `version`),
+       * which was signed at upload time. If `updateCodeSession`
+       * replaces the prior entry verbatim from the echo, the next
+       * `_injected_files` derivation reads `kind: undefined` and
+       * `toInjectedFileRef` falls back to `kind: 'user'` +
+       * `resource_id: file.id`. Codeapi then resolves
+       * `legacy:user:<authContext.userId>`, which doesn't match the
+       * cached `legacy:skill:<skillId>:v:<v>` set at upload, and
+       * authorization 403s.
+       *
+       * The merge must overlay the echo onto the prior entry by
+       * `(storage_session_id, id)` so identity survives.
+       */
+      const SKILL_ID = '69dcf561f37f717858d4d072';
+      const SKILL_VERSION = 59;
+      const STORAGE_SESSION = 'p28pbmz0ejTZ8MMEkObN8';
+      const FILE_ID = 'JqnzC4f6gpirzW0yq_obR';
+
+      const sessions: t.ToolSessionMap = new Map();
+      sessions.set(Constants.EXECUTE_CODE, {
+        session_id: STORAGE_SESSION,
+        files: [
+          {
+            id: FILE_ID,
+            resource_id: SKILL_ID,
+            name: 'pptx/editing.md',
+            storage_session_id: STORAGE_SESSION,
+            kind: 'skill',
+            version: SKILL_VERSION,
+          },
+        ],
+        lastUpdated: Date.now(),
+      } satisfies t.CodeSessionContext);
+
+      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);
+
+      /* Worker echo shape — exactly what codeapi sends on
+       * `inherited: true` files. No kind, no resource_id, no version. */
+      storeMethod(
+        [
+          {
+            toolCallId: 'tc-skill-rerun',
+            content: 'output',
+            artifact: {
+              session_id: 'exec-sess-2',
+              files: [
+                {
+                  id: FILE_ID,
+                  name: 'pptx/editing.md',
+                  storage_session_id: STORAGE_SESSION,
+                  inherited: true,
+                } as unknown as t.FileRefs[number],
+              ],
+            },
+            status: 'success',
+          },
+        ],
+        new Map([
+          [
+            'tc-skill-rerun',
+            { id: 'tc-skill-rerun', name: Constants.EXECUTE_CODE, args: {} },
+          ],
+        ])
+      );
+
+      const stored = sessions.get(
+        Constants.EXECUTE_CODE
+      ) as t.CodeSessionContext;
+      const merged = stored.files!.find((f) => f.id === FILE_ID);
+      expect(merged).toBeDefined();
+      /* Identity preserved from prior entry: */
+      expect(merged!.kind).toBe('skill');
+      expect(merged!.resource_id).toBe(SKILL_ID);
+      expect((merged as { version?: number }).version).toBe(SKILL_VERSION);
+      /* Echo-owned fields propagated: */
+      expect((merged as { inherited?: boolean }).inherited).toBe(true);
+    });
+
+    it('uses fresh kind defaults for genuinely new files (no prior entry to merge from)', () => {
+      /**
+       * The merge keys on `(storage_session_id, id)`, not `name`.
+       * A file the worker emits for the first time (typical
+       * code-output / generated artifact) has no prior to inherit
+       * identity from — it lands as `kind: 'user'` via the standard
+       * fallback in `toInjectedFileRef`. Locks the contract that
+       * the merge doesn't accidentally re-tag user output as skill.
+       */
+      const sessions: t.ToolSessionMap = new Map();
+      sessions.set(Constants.EXECUTE_CODE, {
+        session_id: 'old-sess',
+        files: [
+          {
+            id: 'skill-f1',
+            resource_id: 'skill-id-1',
+            name: 'pptx/editing.md',
+            storage_session_id: 'skill-storage',
+            kind: 'skill',
+            version: 7,
+          },
+        ],
+        lastUpdated: Date.now(),
+      } satisfies t.CodeSessionContext);
+
+      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-output',
+            content: 'output',
+            artifact: {
+              session_id: 'output-sess',
+              files: [
+                {
+                  id: 'fresh-output-id',
+                  name: 'generated-chart.png',
+                  storage_session_id: 'output-sess',
+                } as unknown as t.FileRefs[number],
+              ],
+            },
+            status: 'success',
+          },
+        ],
+        new Map([
+          [
+            'tc-output',
+            { id: 'tc-output', name: Constants.EXECUTE_CODE, args: {} },
+          ],
+        ])
+      );
+
+      const stored = sessions.get(
+        Constants.EXECUTE_CODE
+      ) as t.CodeSessionContext;
+      const fresh = stored.files!.find((f) => f.id === 'fresh-output-id');
+      expect(fresh).toBeDefined();
+      /* No prior to inherit from — kind/resource_id/version absent
+       * on the entry; toInjectedFileRef will default kind to 'user'
+       * downstream. */
+      expect(fresh!.kind).toBeUndefined();
+      expect(fresh!.resource_id).toBeUndefined();
+      expect((fresh as { version?: number }).version).toBeUndefined();
+      /* Skill file untouched. */
+      const skillFile = stored.files!.find((f) => f.id === 'skill-f1');
+      expect(skillFile!.kind).toBe('skill');
+    });
+
     it('preserves existing files when new execution has no files', () => {
       const sessions: t.ToolSessionMap = new Map();
       sessions.set(Constants.EXECUTE_CODE, {