@librechat/agents 3.1.89 → 3.1.90

package/src/tools/ToolNode.ts

@@ -46,6 +46,7 @@ import {
   buildReferenceKey,
   ToolOutputReferenceRegistry,
 } from '@/tools/toolOutputReferences';
+import { stripCodeSessionFileSummary } from '@/tools/CodeSessionFileSummary';
 import {
   resolveLocalToolRegistry,
   resolveLocalExecutionTools,
@@ -911,8 +912,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
        * Both session_id and _injected_files are injected directly to invokeParams
        * (not inside args) so they bypass Zod schema validation and reach config.toolCall.
        *
-       * session_id is always injected when available (even without tracked files)
-       * so the CodeExecutor can fall back to the /files endpoint for session continuity.
+       * session_id is always injected when available, but concrete file refs
+       * still need to travel through `_injected_files`; the legacy
+       * `/files/<session_id>` fallback was removed from the executors.
        */
       if (CODE_EXECUTION_TOOLS.has(call.name)) {
         const codeSession = this.sessions?.get(Constants.EXECUTE_CODE) as
@@ -959,6 +961,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         if (this.toolOutputRegistry != null || unresolvedRefs.length > 0) {
           if (typeof toolMsg.content === 'string') {
             const rawContent = toolMsg.content;
+            const registryContent = stripCodeSessionFileSummary(rawContent);
             const llmContent = truncateToolResultContent(
               rawContent,
               this.maxToolResultChars
@@ -966,7 +969,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
             toolMsg.content = llmContent;
             const refMeta = this.recordOutputReference(
               runId,
-              rawContent,
+              registryContent,
               refKey,
               unresolvedRefs
             );
@@ -1015,7 +1018,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       );
       const refMeta = this.recordOutputReference(
         runId,
-        rawContent,
+        stripCodeSessionFileSummary(rawContent),
         refKey,
         unresolvedRefs
       );
@@ -2661,7 +2664,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
               : undefined;
           const successRefMeta = this.recordOutputReference(
             registryRunId,
-            registryRaw,
+            stripCodeSessionFileSummary(registryRaw),
             refKey,
             unresolved
           );

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

@@ -18,6 +18,15 @@ describe('buildBashExecutionToolDescription', () => {
     ).toBe(BashExecutionToolDescription);
   });
 
+  it('warns about compact bash shell pitfalls', () => {
+    expect(BashExecutionToolDescription).toContain('heredoc/printf');
+    expect(BashExecutionToolDescription).toContain('not bare Python');
+    expect(BashExecutionToolDescription).toContain(
+      'failed executions do not register new files'
+    );
+    expect(BashExecutionToolDescription).toContain('not later-call storage');
+  });
+
   it('appends the tool-output references guide when enabled', () => {
     const composed = buildBashExecutionToolDescription({
       enableToolOutputReferences: true,

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

@@ -165,6 +165,17 @@ describe('CodeAPI auth header injection', () => {
     ).not.toHaveProperty('authHeaders');
   });
 
+  it('tolerates null params for direct code execution', async () => {
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({ session_id: 'session_123', stdout: '1\n' })
+    );
+    const tool = createCodeExecutionTool(null);
+
+    await expect(
+      tool.invoke({ lang: 'py', code: 'print(1)' })
+    ).resolves.toBeDefined();
+  });
+
   it('forwards Authorization for bash execution', async () => {
     fetchMock.mockResolvedValueOnce(
       jsonResponse({ session_id: 'session_123', stdout: '1\n' })
@@ -333,6 +344,38 @@ describe('CodeAPI auth header injection', () => {
     );
   });
 
+  it('reminds that failed bash programmatic executions do not register new files', async () => {
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        status: 'error',
+        error: 'jq failed',
+        stderr: 'jq: Cannot index string with string "name"',
+      })
+    );
+    const tool = createBashProgrammaticToolCallingTool();
+
+    await expect(
+      tool.invoke(
+        {
+          code: [
+            'lookup_user "{}" > /mnt/data/user.json',
+            'jq -r \'.result.name\' /mnt/data/user.json',
+          ].join('\n'),
+        },
+        {
+          toolCall: {
+            name: 'bash_programmatic_code_execution',
+            args: {},
+            toolMap: toolMap(),
+            toolDefs,
+          },
+        }
+      )
+    ).rejects.toThrow(
+      'files written during this failed call were not registered for later calls'
+    );
+  });
+
   it('fetches session files with the CodeAPI resource scope and auth headers', async () => {
     fetchMock.mockResolvedValueOnce(
       jsonResponse([

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

@@ -8,6 +8,7 @@ import type * as t from '@/types';
 import { Constants } from '@/common';
 import {
   createProgrammaticToolCallingTool,
+  createProgrammaticToolCallingSchema,
   formatCompletedResponse,
   extractUsedToolNames,
   filterToolsByUsage,
@@ -15,6 +16,7 @@ import {
   normalizeToPythonIdentifier,
   unwrapToolResponse,
 } from '../ProgrammaticToolCalling';
+import { createBashProgrammaticToolCallingSchema } from '../BashProgrammaticToolCalling';
 import {
   createProgrammaticToolRegistry,
   createGetTeamMembersTool,
@@ -24,6 +26,33 @@ import {
 } from '@/test/mockTools';
 
 describe('ProgrammaticToolCalling', () => {
+  describe('tool descriptions', () => {
+    it('explains Python inner-tool call and result shape', () => {
+      const schema = createProgrammaticToolCallingSchema();
+      const description = schema.properties.code.description;
+
+      expect(description).toContain('keyword args only');
+      expect(description).toContain('never pass a dict');
+      expect(description).toContain('Tool results are decoded Python values');
+    });
+
+    it('explains bash inner-tool stdout shape', () => {
+      const schema = createBashProgrammaticToolCallingSchema();
+      const description = schema.properties.code.description;
+
+      expect(description).toContain('jq: use fromjson? // .');
+      expect(description).toContain('again on JSON-string fields');
+      expect(description).toContain('arrays may contain strings');
+      expect(description).toContain('raw=$(tool');
+      expect(description).toContain('direct tool > file may be empty');
+      expect(description).toContain('/mnt/data/sf.json');
+      expect(description).toContain(
+        'failed executions do not register new files'
+      );
+      expect(description).toContain('not later-call storage');
+    });
+  });
+
   describe('executeTools', () => {
     let toolMap: t.ToolMap;
 
@@ -656,13 +685,26 @@ for member in team:
       expect(output).toContain('stderr:\nWarning: deprecated function');
     });
 
-    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. */
+    it('adds a /tmp scratch reminder when source code used /tmp', () => {
+      const response: t.ProgrammaticExecutionResponse = {
+        status: 'completed',
+        stdout: 'done\n',
+        stderr: '',
+        files: [],
+        session_id: 'sess_abc123',
+      };
+
+      const [output] = formatCompletedResponse(
+        response,
+        'tool "{}" > /tmp/result.json'
+      );
+
+      expect(output).toContain('stdout:\ndone');
+      expect(output).toContain('/tmp files are same-call scratch only');
+      expect(output).toContain('use /mnt/data for files needed later');
+    });
+
+    it('preserves files on the artifact and summarizes them without listing paths', () => {
       const response: t.ProgrammaticExecutionResponse = {
         status: 'completed',
         stdout: 'Generated report\n',
@@ -677,9 +719,12 @@ for member in team:
 
       const [output, artifact] = formatCompletedResponse(response);
 
-      /* Tool result text is stdout/stderr only. */
       expect(output).toContain('stdout:\nGenerated report');
-      expect(output).not.toContain('Generated files:');
+      expect(output).toContain('Generated files:');
+      expect(output).toContain(
+        'Session files: 2 persisted file(s) are available in /mnt/data, including 0 image(s).'
+      );
+      expect(output).toContain('do not invent download links');
       expect(output).not.toContain('Available files');
       expect(output).not.toContain('report.pdf');
       expect(output).not.toContain('SKILL.md');
@@ -691,6 +736,25 @@ for member in team:
       expect(artifact.files).toHaveLength(3);
       expect(artifact.files).toEqual(response.files);
     });
+
+    it('omits the generated-file summary for inherited-only files', () => {
+      const response: t.ProgrammaticExecutionResponse = {
+        status: 'completed',
+        stdout: 'No new files\n',
+        stderr: '',
+        files: [
+          { id: 'i1', name: 'skills/SKILL.md', inherited: true },
+          { id: 'i2', name: 'inputs/source.csv', inherited: true },
+        ],
+        session_id: 'sess_abc123',
+      };
+
+      const [output, artifact] = formatCompletedResponse(response);
+
+      expect(output).toBe('stdout:\nNo new files');
+      expect(output).not.toContain('Generated files:');
+      expect(artifact.files).toEqual(response.files);
+    });
   });
 
   describe('createProgrammaticToolCallingTool - Manual Invocation', () => {
@@ -889,11 +953,7 @@ for member in team:
       });
     });
 
-    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`. */
+    it('summarizes files in output while keeping exact refs on the artifact', () => {
       const response: t.ProgrammaticExecutionResponse = {
         status: 'completed',
         stdout: 'Report generated\n',
@@ -909,14 +969,38 @@ for member in team:
 
       const [output, artifact] = formatCompletedResponse(response);
 
-      expect(output).toBe('stdout:\nReport generated');
+      expect(output).toContain('stdout:\nReport generated');
+      expect(output).toContain(
+        'Session files: 4 persisted file(s) are available in /mnt/data, including 1 image(s).'
+      );
       expect(output).not.toContain('report.csv');
       expect(output).not.toContain('chart.png');
-      expect(output).not.toContain('/mnt/data/');
 
       expect(artifact.files).toHaveLength(4);
       expect(artifact.files).toEqual(response.files);
     });
+
+    it('treats malformed file refs as non-image files', () => {
+      const malformedFile = { id: 'broken' } as t.FileRef;
+      const response: t.ProgrammaticExecutionResponse = {
+        status: 'completed',
+        stdout: 'Report generated\n',
+        stderr: '',
+        files: [
+          { id: '1', name: 'chart.png' },
+          malformedFile,
+          { id: '3', name: 'inherited.png', inherited: true },
+        ],
+        session_id: 'sess_xyz',
+      };
+
+      const [output, artifact] = formatCompletedResponse(response);
+
+      expect(output).toContain(
+        'Session files: 2 persisted file(s) are available in /mnt/data, including 1 image(s).'
+      );
+      expect(artifact.files).toEqual(response.files);
+    });
   });
 
   describe('Tool Data Extraction', () => {