@librechat/agents 3.1.78 → 3.1.80-dev.0

package/src/tools/ToolNode.ts

@@ -249,22 +249,62 @@ function normalizeApprovalDecisions(
  *  - `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
+ *  - `file.storage_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).
+ * Per-file `storage_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 the exec id only when the
+ * per-file id is absent (e.g. inline `content` files have no persistent
+ * storage location).
  */
+/**
+ * Builds a `CodeEnvFile` ref from an arbitrary `FileRef`-like input,
+ * narrowing onto the discriminated union: `kind: 'skill'` requires
+ * `version`, other kinds forbid it.
+ *
+ * Defaults `kind` to `'user'` when unset — most ad-hoc files are
+ * user-private; shared resources (skills/agents) populate their kind
+ * upstream. A skill ref missing `version` falls back to `'user'` so
+ * the upstream contract bug surfaces as a degraded sessionKey rather
+ * than a runtime crash; primeSkillFiles is the only writer, and it
+ * always sets `version` — see LC packages/api/src/agents/skillFiles.ts.
+ */
+function toInjectedFileRef(
+  file: {
+    id: string;
+    name: string;
+    storage_session_id?: string;
+    kind?: t.CodeEnvKind;
+    version?: number;
+  },
+  execSessionId: string
+): t.CodeEnvFile {
+  const base = {
+    id: file.id,
+    name: file.name,
+    /* Inline `content` files have no persistent storage location;
+     * fall back to the execution session id for those entries. */
+    storage_session_id: file.storage_session_id ?? execSessionId,
+  };
+  const kind = file.kind ?? 'user';
+  if (kind === 'skill' && file.version != null) {
+    return { ...base, kind: 'skill', version: file.version };
+  }
+  if (kind === 'agent') {
+    return { ...base, kind: 'agent' };
+  }
+  return { ...base, kind: 'user' };
+}
+
 function updateCodeSession(
   sessions: t.ToolSessionMap,
-  sessionId: string,
+  execSessionId: string,
   files: t.FileRefs | undefined
 ): void {
   const newFiles = files ?? [];
@@ -276,20 +316,20 @@ function updateCodeSession(
   if (newFiles.length > 0) {
     const filesWithSession: t.FileRefs = newFiles.map((file) => ({
       ...file,
-      session_id: file.session_id ?? sessionId,
+      storage_session_id: file.storage_session_id ?? execSessionId,
     }));
     const newFileNames = new Set(filesWithSession.map((f) => f.name));
     const filteredExisting = existingFiles.filter(
       (f) => !newFileNames.has(f.name)
     );
     sessions.set(Constants.EXECUTE_CODE, {
-      session_id: sessionId,
+      session_id: execSessionId,
       files: [...filteredExisting, ...filesWithSession],
       lastUpdated: Date.now(),
     });
   } else {
     sessions.set(Constants.EXECUTE_CODE, {
-      session_id: sessionId,
+      session_id: execSessionId,
       files: existingFiles,
       lastUpdated: Date.now(),
     });
@@ -400,7 +440,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     this.loadRuntimeTools = loadRuntimeTools;
     this.errorHandler = errorHandler;
     this.toolUsageCount = new Map<string, number>();
-    this.toolRegistry = resolveLocalToolRegistry({ toolRegistry, toolExecution });
+    this.toolRegistry = resolveLocalToolRegistry({
+      toolRegistry,
+      toolExecution,
+    });
     this.sessions = sessions;
     this.eventDrivenMode = eventDrivenMode ?? false;
     this.agentId = agentId;
@@ -581,8 +624,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       resolveFn = <T>(_runId: string | undefined, args: T): ResolveResult<T> =>
         preBatchSnapshot.resolve(args);
     } else if (registry != null) {
-      resolveFn = <T>(runIdArg: string | undefined, args: T): ResolveResult<T> =>
-        registry.resolve(runIdArg, args);
+      resolveFn = <T>(
+        runIdArg: string | undefined,
+        args: T
+      ): ResolveResult<T> => registry.resolve(runIdArg, args);
     }
     /**
      * Precompute the reference key once per call — captured locally
@@ -717,20 +762,17 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         const codeSession = this.sessions?.get(Constants.EXECUTE_CODE) as
           | t.CodeSessionContext
           | undefined;
-        if (codeSession?.session_id != null && codeSession.session_id !== '') {
+        const execSessionId = codeSession?.session_id;
+        if (execSessionId != null && execSessionId !== '') {
           invokeParams = {
             ...invokeParams,
-            session_id: codeSession.session_id,
+            session_id: execSessionId,
           };
 
-          if (codeSession.files != null && codeSession.files.length > 0) {
-            const fileRefs: t.CodeEnvFile[] = codeSession.files.map((file) => ({
-              session_id: file.session_id ?? codeSession.session_id,
-              id: file.id,
-              name: file.name,
-              ...(file.entity_id != null ? { entity_id: file.entity_id } : {}),
-            }));
-            invokeParams._injected_files = fileRefs;
+          if (codeSession?.files != null && codeSession.files.length > 0) {
+            invokeParams._injected_files = codeSession.files.map((file) =>
+              toInjectedFileRef(file, execSessionId)
+            );
           }
         }
       }
@@ -950,10 +992,8 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   ): Promise<BaseMessage | Command> {
     const runId = (config.configurable?.run_id as string | undefined) ?? '';
     const hookRegistry = this.hookRegistry;
-    const hasPreHook =
-      hookRegistry?.hasHookFor('PreToolUse', runId) === true;
-    const hasPostHook =
-      hookRegistry?.hasHookFor('PostToolUse', runId) === true;
+    const hasPreHook = hookRegistry?.hasHookFor('PreToolUse', runId) === true;
+    const hasPostHook = hookRegistry?.hasHookFor('PostToolUse', runId) === true;
     const hasFailureHook =
       hookRegistry?.hasHookFor('PostToolUseFailure', runId) === true;
 
@@ -989,8 +1029,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     // assignment.)
     const cachedTurn =
       call.id != null && call.id !== ''
-        ? this.directPathTurns.get(call.id) ??
-          this.toolCallTurns.get(call.id)
+        ? (this.directPathTurns.get(call.id) ?? this.toolCallTurns.get(call.id))
         : undefined;
     if (cachedTurn != null) {
       usageCount = cachedTurn;
@@ -1156,10 +1195,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
             return this.blockDirectCall({
               call,
               resolvedArgs,
-              reason:
-                decision.reason ??
-                preResult.reason ??
-                'Rejected by user',
+              reason: decision.reason ?? preResult.reason ?? 'Rejected by user',
               hookRegistry,
               runId,
               threadId,
@@ -1173,7 +1209,8 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
               return this.blockDirectCall({
                 call,
                 resolvedArgs,
-                reason: 'Approval payload `respond` was missing a string `responseText`',
+                reason:
+                  'Approval payload `respond` was missing a string `responseText`',
                 hookRegistry,
                 runId,
                 threadId,
@@ -1464,17 +1501,15 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       return undefined;
     }
 
+    const execSessionId = codeSession.session_id;
     const context: NonNullable<t.ToolCallRequest['codeSessionContext']> = {
-      session_id: codeSession.session_id,
+      session_id: execSessionId,
     };
 
     if (codeSession.files && codeSession.files.length > 0) {
-      context.files = codeSession.files.map((file) => ({
-        session_id: file.session_id ?? codeSession.session_id,
-        id: file.id,
-        name: file.name,
-        ...(file.entity_id != null ? { entity_id: file.entity_id } : {}),
-      }));
+      context.files = codeSession.files.map((file) =>
+        toInjectedFileRef(file, execSessionId)
+      );
     }
 
     return context;
@@ -1509,11 +1544,12 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       }
 
       const artifact = result.artifact as t.CodeExecutionArtifact | undefined;
-      if (artifact?.session_id == null || artifact.session_id === '') {
+      const execSessionId = artifact?.session_id;
+      if (execSessionId == null || execSessionId === '') {
         continue;
       }
 
-      updateCodeSession(this.sessions, artifact.session_id!, artifact.files);
+      updateCodeSession(this.sessions, execSessionId, artifact?.files);
     }
   }
 
@@ -1558,8 +1594,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         const artifact = toolMessage.artifact as
           | t.CodeExecutionArtifact
           | undefined;
-        if (artifact?.session_id != null && artifact.session_id !== '') {
-          updateCodeSession(this.sessions, artifact.session_id, artifact.files);
+        const execSessionId = artifact?.session_id;
+        if (execSessionId != null && execSessionId !== '') {
+          updateCodeSession(this.sessions, execSessionId, artifact?.files);
         }
       }
 

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

@@ -0,0 +1,8 @@
+import { getReadRoots, getWriteRoots } from '../local/LocalExecutionEngine';
+
+describe('local execution workspace roots', () => {
+  it('uses the current working directory boundary when config is omitted', () => {
+    expect(getWriteRoots()).toEqual([process.cwd()]);
+    expect(getReadRoots()).toEqual([process.cwd()]);
+  });
+});

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

@@ -1064,8 +1064,11 @@ for member in team:
   });
 
   describe('bash bridge script does not require python3 (Codex P2 #19)', () => {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { _createBashProgramForTests } = require('../local/LocalProgrammaticToolCalling');
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const {
+      _createBashProgramForTests,
+    } = require('../local/LocalProgrammaticToolCalling');
+    /* eslint-enable @typescript-eslint/no-require-imports */
 
     it('uses curl as the primary HTTP helper with python3 only as fallback', () => {
       const script: string = _createBashProgramForTests(
@@ -1129,6 +1132,7 @@ for member in team:
       const registry = new HookRegistry();
       registry.register('PreToolUse', {
         hooks: [
+          // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
           async (input) => {
             if (input.toolName === 'write_file') {
               return { decision: 'deny', reason: 'no writes from bridge' };
@@ -1179,6 +1183,7 @@ for member in team:
 
       const registry = new HookRegistry();
       registry.register('PreToolUse', {
+        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
         hooks: [async () => ({ decision: 'allow' })],
       });
 
@@ -1200,6 +1205,7 @@ for member in team:
       const registry = new HookRegistry();
       registry.register('PreToolUse', {
         hooks: [
+          // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
           async () => ({
             decision: 'allow',
             updatedInput: { file_path: '/tmp/rewritten' },
@@ -1224,6 +1230,7 @@ for member in team:
 
       const registry = new HookRegistry();
       registry.register('PreToolUse', {
+        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
         hooks: [async () => ({ decision: 'ask' })],
       });
 

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

@@ -51,14 +51,22 @@ function createAIMessageWithCodeCall(callId: string): AIMessage {
 
 describe('ToolNode code execution session management', () => {
   describe('session injection via runTool (direct execution)', () => {
-    it('injects session_id and _injected_files when session has files', async () => {
+    it('injects session ids (both names) and _injected_files when session has files', async () => {
       const capturedConfigs: Record<string, unknown>[] = [];
       const sessions: t.ToolSessionMap = new Map();
       sessions.set(Constants.EXECUTE_CODE, {
         session_id: 'prev-session-abc',
         files: [
-          { id: 'file1', name: 'data.csv', session_id: 'prev-session-abc' },
-          { id: 'file2', name: 'chart.png', session_id: 'prev-session-abc' },
+          {
+            id: 'file1',
+            name: 'data.csv',
+            storage_session_id: 'prev-session-abc',
+          },
+          {
+            id: 'file2',
+            name: 'chart.png',
+            storage_session_id: 'prev-session-abc',
+          },
         ],
         lastUpdated: Date.now(),
       } satisfies t.CodeSessionContext);
@@ -70,14 +78,26 @@ describe('ToolNode code execution session management', () => {
       await toolNode.invoke({ messages: [aiMsg] });
 
       expect(capturedConfigs).toHaveLength(1);
+      /* Both names injected so pre- and post-rename consumers see the
+       * field they expect. */
       expect(capturedConfigs[0].session_id).toBe('prev-session-abc');
       expect(capturedConfigs[0]._injected_files).toEqual([
-        { session_id: 'prev-session-abc', id: 'file1', name: 'data.csv' },
-        { session_id: 'prev-session-abc', id: 'file2', name: 'chart.png' },
+        {
+          id: 'file1',
+          name: 'data.csv',
+          storage_session_id: 'prev-session-abc',
+          kind: 'user',
+        },
+        {
+          id: 'file2',
+          name: 'chart.png',
+          storage_session_id: 'prev-session-abc',
+          kind: 'user',
+        },
       ]);
     });
 
-    it('injects session_id even when session has no tracked files', async () => {
+    it('injects session ids even when session has no tracked files', async () => {
       const capturedConfigs: Record<string, unknown>[] = [];
       const sessions: t.ToolSessionMap = new Map();
       sessions.set(Constants.EXECUTE_CODE, {
@@ -112,14 +132,22 @@ describe('ToolNode code execution session management', () => {
       expect(capturedConfigs[0]._injected_files).toBeUndefined();
     });
 
-    it('preserves per-file session_id for multi-session files', async () => {
+    it('preserves per-file storage_session_id for multi-session files', async () => {
       const capturedConfigs: Record<string, unknown>[] = [];
       const sessions: t.ToolSessionMap = new Map();
       sessions.set(Constants.EXECUTE_CODE, {
         session_id: 'session-B',
         files: [
-          { id: 'f1', name: 'old.csv', session_id: 'session-A' },
-          { id: 'f2', name: 'new.png', session_id: 'session-B' },
+          {
+            id: 'f1',
+            name: 'old.csv',
+            storage_session_id: 'session-A',
+          },
+          {
+            id: 'f2',
+            name: 'new.png',
+            storage_session_id: 'session-B',
+          },
         ],
         lastUpdated: Date.now(),
       } satisfies t.CodeSessionContext);
@@ -131,26 +159,27 @@ describe('ToolNode code execution session management', () => {
       await toolNode.invoke({ messages: [aiMsg] });
 
       const files = capturedConfigs[0]._injected_files as t.CodeEnvFile[];
-      expect(files[0].session_id).toBe('session-A');
-      expect(files[1].session_id).toBe('session-B');
+      expect(files[0].storage_session_id).toBe('session-A');
+      expect(files[1].storage_session_id).toBe('session-B');
     });
 
-    it('forwards per-file entity_id for mixed-entity sessions', async () => {
+    it('forwards per-file kind and version for mixed-kind sessions', async () => {
       const capturedConfigs: Record<string, unknown>[] = [];
       const sessions: t.ToolSessionMap = new Map();
       sessions.set(Constants.EXECUTE_CODE, {
         session_id: 'session-A',
         files: [
           {
-            id: 'skill-file',
+            id: 'skill-123',
             name: 'demo/SKILL.md',
-            session_id: 'session-A',
-            entity_id: 'skill-123',
+            storage_session_id: 'session-A',
+            kind: 'skill',
+            version: 7,
           },
           {
             id: 'user-file',
             name: 'attachment.csv',
-            session_id: 'session-B',
+            storage_session_id: 'session-B',
           },
         ],
         lastUpdated: Date.now(),
@@ -165,15 +194,17 @@ describe('ToolNode code execution session management', () => {
       const files = capturedConfigs[0]._injected_files as t.CodeEnvFile[];
       expect(files).toEqual([
         {
-          session_id: 'session-A',
-          id: 'skill-file',
+          id: 'skill-123',
           name: 'demo/SKILL.md',
-          entity_id: 'skill-123',
+          storage_session_id: 'session-A',
+          kind: 'skill',
+          version: 7,
         },
         {
-          session_id: 'session-B',
           id: 'user-file',
           name: 'attachment.csv',
+          storage_session_id: 'session-B',
+          kind: 'user',
         },
       ]);
     });
@@ -184,7 +215,13 @@ describe('ToolNode code execution session management', () => {
       const sessions: t.ToolSessionMap = new Map();
       sessions.set(Constants.EXECUTE_CODE, {
         session_id: 'evt-session',
-        files: [{ id: 'ef1', name: 'out.parquet', session_id: 'evt-session' }],
+        files: [
+          {
+            id: 'ef1',
+            name: 'out.parquet',
+            storage_session_id: 'evt-session',
+          },
+        ],
         lastUpdated: Date.now(),
       } satisfies t.CodeSessionContext);
 
@@ -201,7 +238,14 @@ describe('ToolNode code execution session management', () => {
 
       expect(context).toEqual({
         session_id: 'evt-session',
-        files: [{ session_id: 'evt-session', id: 'ef1', name: 'out.parquet' }],
+        files: [
+          {
+            id: 'ef1',
+            name: 'out.parquet',
+            storage_session_id: 'evt-session',
+            kind: 'user',
+          },
+        ],
       });
     });
 
@@ -224,7 +268,9 @@ describe('ToolNode code execution session management', () => {
         toolNode as unknown as { getCodeSessionContext: () => unknown }
       ).getCodeSessionContext();
 
-      expect(context).toEqual({ session_id: 'evt-session-empty' });
+      expect(context).toEqual({
+        session_id: 'evt-session-empty',
+      });
     });
 
     it('returns undefined when no session exists', () => {
@@ -244,18 +290,23 @@ describe('ToolNode code execution session management', () => {
       expect(context).toBeUndefined();
     });
 
-    it('forwards per-file entity_id to event-driven request context', () => {
+    it('forwards per-file kind and version to event-driven request context', () => {
       const sessions: t.ToolSessionMap = new Map();
       sessions.set(Constants.EXECUTE_CODE, {
         session_id: 'evt-session',
         files: [
           {
-            id: 'sk1',
+            id: 'skill-abc',
             name: 'demo/SKILL.md',
-            session_id: 'evt-session',
-            entity_id: 'skill-abc',
+            storage_session_id: 'evt-session',
+            kind: 'skill',
+            version: 3,
+          },
+          {
+            id: 'usr1',
+            name: 'data.csv',
+            storage_session_id: 'evt-session',
           },
-          { id: 'usr1', name: 'data.csv', session_id: 'evt-session' },
         ],
         lastUpdated: Date.now(),
       } satisfies t.CodeSessionContext);
@@ -275,12 +326,18 @@ describe('ToolNode code execution session management', () => {
         session_id: 'evt-session',
         files: [
           {
-            session_id: 'evt-session',
-            id: 'sk1',
+            id: 'skill-abc',
             name: 'demo/SKILL.md',
-            entity_id: 'skill-abc',
+            storage_session_id: 'evt-session',
+            kind: 'skill',
+            version: 3,
+          },
+          {
+            id: 'usr1',
+            name: 'data.csv',
+            storage_session_id: 'evt-session',
+            kind: 'user',
           },
-          { session_id: 'evt-session', id: 'usr1', name: 'data.csv' },
         ],
       });
     });
@@ -333,7 +390,7 @@ describe('ToolNode code execution session management', () => {
         expect.objectContaining({
           id: 'f1',
           name: 'result.csv',
-          session_id: 'new-sess',
+          storage_session_id: 'new-sess',
         })
       );
     });
@@ -384,8 +441,8 @@ describe('ToolNode code execution session management', () => {
       sessions.set(Constants.EXECUTE_CODE, {
         session_id: 'old-sess',
         files: [
-          { id: 'f1', name: 'data.csv', session_id: 'old-sess' },
-          { id: 'f2', name: 'chart.png', session_id: 'old-sess' },
+          { id: 'f1', name: 'data.csv', storage_session_id: 'old-sess' },
+          { id: 'f2', name: 'chart.png', storage_session_id: 'old-sess' },
         ],
         lastUpdated: Date.now(),
       } satisfies t.CodeSessionContext);
@@ -430,18 +487,18 @@ describe('ToolNode code execution session management', () => {
       expect(stored.files).toHaveLength(2);
 
       const csvFile = stored.files!.find((f) => f.name === 'data.csv');
-      expect(csvFile!.session_id).toBe('old-sess');
+      expect(csvFile!.storage_session_id).toBe('old-sess');
 
       const chartFile = stored.files!.find((f) => f.name === 'chart.png');
       expect(chartFile!.id).toBe('f3');
-      expect(chartFile!.session_id).toBe('new-sess');
+      expect(chartFile!.storage_session_id).toBe('new-sess');
     });
 
     it('preserves existing files when new execution has no files', () => {
       const sessions: t.ToolSessionMap = new Map();
       sessions.set(Constants.EXECUTE_CODE, {
         session_id: 'old-sess',
-        files: [{ id: 'f1', name: 'data.csv', session_id: 'old-sess' }],
+        files: [{ id: 'f1', name: 'data.csv', storage_session_id: 'old-sess' }],
         lastUpdated: Date.now(),
       } satisfies t.CodeSessionContext);
 
@@ -507,7 +564,7 @@ describe('ToolNode code execution session management', () => {
           {
             toolCallId: 'tc5',
             content: 'search results',
-            artifact: { session_id: 'should-not-store' },
+            artifact: { storage_session_id: 'should-not-store' },
             status: 'success',
           },
         ],
@@ -597,9 +654,13 @@ describe('ToolNode code execution session management', () => {
                 {
                   id: 'f1',
                   name: 'sentinel.txt',
-                  session_id: 'storage-session-A',
+                  storage_session_id: 'storage-session-A',
+                },
+                {
+                  id: 'f2',
+                  name: 'data.csv',
+                  storage_session_id: 'storage-session-B',
                 },
-                { id: 'f2', name: 'data.csv', session_id: 'storage-session-B' },
               ],
             },
             status: 'success',
@@ -617,18 +678,20 @@ describe('ToolNode code execution session management', () => {
         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. */
+         "what session ran last" — but per-file storage ids must survive.
+         After the rename, both names appear at the top level (exec) and
+         on each file (storage). */
       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',
+        storage_session_id: 'storage-session-A',
       });
       expect(stored.files![1]).toEqual({
         id: 'f2',
         name: 'data.csv',
-        session_id: 'storage-session-B',
+        storage_session_id: 'storage-session-B',
       });
     });
 
@@ -658,7 +721,11 @@ describe('ToolNode code execution session management', () => {
               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: 'f1',
+                  name: 'fresh.csv',
+                  storage_session_id: 'storage-fresh',
+                },
                 { id: 'f2', name: 'legacy.csv' },
               ],
             },
@@ -676,9 +743,10 @@ describe('ToolNode code execution session management', () => {
       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');
+      expect(stored.files![0].storage_session_id).toBe('storage-fresh');
+      /* Fallback only when the per-file id is missing — the fallback
+       * value is the exec session id. */
+      expect(stored.files![1].storage_session_id).toBe('exec-mixed');
     });
   });
 
@@ -728,7 +796,13 @@ describe('ToolNode code execution session management', () => {
       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' }],
+        files: [
+          {
+            id: 'rf1',
+            name: 'data.csv',
+            storage_session_id: 'rf-session',
+          },
+        ],
         lastUpdated: Date.now(),
       } satisfies t.CodeSessionContext);
 
@@ -758,7 +832,14 @@ describe('ToolNode code execution session management', () => {
       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' }],
+        files: [
+          {
+            id: 'rf1',
+            name: 'data.csv',
+            storage_session_id: 'rf-session',
+            kind: 'user',
+          },
+        ],
       });
     });