@librechat/agents 3.2.2 → 3.2.31

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

@@ -2,18 +2,18 @@ import { z } from 'zod';
 import { tool } from '@langchain/core/tools';
 import { describe, it, expect } from '@jest/globals';
 import { AIMessage, HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
 import type { StructuredToolInterface } from '@langchain/core/tools';
+import type { BaseMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
-import * as events from '@/utils/events';
-import { ToolNode } from '../ToolNode';
-import { Constants } from '@/common';
 import {
   SkillToolDescription,
   SkillToolDefinition,
   SkillToolSchema,
   SkillToolName,
 } from '../SkillTool';
+import * as events from '@/utils/events';
+import { ToolNode } from '../ToolNode';
+import { Constants } from '@/common';
 
 describe('SkillTool', () => {
   describe('schema structure', () => {

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

@@ -1,10 +1,6 @@
 import { describe, it, expect, beforeEach } from '@jest/globals';
 import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
 import type { BaseMessage } from '@langchain/core/messages';
-import { HookRegistry } from '@/hooks/HookRegistry';
-import { Providers, GraphEvents, StepTypes } from '@/common';
-import { HandlerRegistry } from '@/events';
-import { AgentContext } from '@/agents/AgentContext';
 import type {
   AgentInputs,
   ResolvedSubagentConfig,
@@ -12,6 +8,7 @@ import type {
   ToolExecuteBatchRequest,
   ToolExecuteResult,
 } from '@/types';
+import type { StandardGraph } from '@/graphs/Graph';
 import {
   SubagentExecutor,
   filterSubagentResult,
@@ -20,7 +17,10 @@ import {
   summarizeEvent,
 } from '../subagent';
 import { sanitizeForwardedSubagentUpdateData } from '../subagent/SubagentExecutor';
-import type { StandardGraph } from '@/graphs/Graph';
+import { Providers, GraphEvents, StepTypes } from '@/common';
+import { AgentContext } from '@/agents/AgentContext';
+import { HookRegistry } from '@/hooks/HookRegistry';
+import { HandlerRegistry } from '@/events';
 
 jest.setTimeout(15000);
 
@@ -635,7 +635,10 @@ describe('SubagentExecutor', () => {
 
       const invokeConfig = getInvokeConfig();
       expect(invokeConfig).toBeDefined();
-      const configurable = invokeConfig!.configurable as Record<string, unknown>;
+      const configurable = invokeConfig!.configurable as Record<
+        string,
+        unknown
+      >;
       expect(configurable.requestBody).toEqual({
         messageId: 'msg-123',
         conversationId: 'conv-456',
@@ -1183,11 +1186,13 @@ describe('SubagentExecutor', () => {
         handle: (_event, rawData): void => {
           const request = rawData as ToolExecuteBatchRequest;
           toolRequests.push(request);
-          const results: ToolExecuteResult[] = request.toolCalls.map((call) => ({
-            toolCallId: call.id,
-            status: 'success',
-            content: `ran ${call.name}`,
-          }));
+          const results: ToolExecuteResult[] = request.toolCalls.map(
+            (call) => ({
+              toolCallId: call.id,
+              status: 'success',
+              content: `ran ${call.name}`,
+            })
+          );
           request.resolve(results);
         },
       });
@@ -1268,8 +1273,7 @@ describe('SubagentExecutor', () => {
 
       const toolUpdate = subagentUpdates.find(
         (update) =>
-          update.phase === 'run_step' &&
-          update.label === 'Calling calculator'
+          update.phase === 'run_step' && update.label === 'Calling calculator'
       );
       expect(toolUpdate?.data).toEqual({
         agentId: 'researcher',

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from '@jest/globals';
-import { Constants } from '@/common';
+import type { SubagentConfig } from '@/types';
 import {
   SubagentToolName,
   SubagentToolDescription,
@@ -8,7 +8,7 @@ import {
   createSubagentToolDefinition,
   buildSubagentToolParams,
 } from '../SubagentTool';
-import type { SubagentConfig } from '@/types';
+import { Constants } from '@/common';
 
 describe('SubagentTool', () => {
   describe('schema structure', () => {

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

@@ -5,9 +5,9 @@ import { describe, it, expect, jest, afterEach } from '@jest/globals';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type { PreToolUseHookInput, PreToolUseHookOutput } from '@/hooks';
 import type * as t from '@/types';
+import * as events from '@/utils/events';
 import { GraphEvents } from '@/common';
 import { HookRegistry } from '@/hooks';
-import * as events from '@/utils/events';
 import { ToolNode } from '../ToolNode';
 
 function createDummyTool(name: string): StructuredToolInterface {

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

@@ -3,15 +3,12 @@ import { tool } from '@langchain/core/tools';
 import { AIMessage, ToolMessage } from '@langchain/core/messages';
 import { describe, it, expect, jest, afterEach } from '@jest/globals';
 import type { StructuredToolInterface } from '@langchain/core/tools';
+import type { PostToolUseHookOutput, PreToolUseHookOutput } from '@/hooks';
 import type * as t from '@/types';
+import { ToolOutputReferenceRegistry } from '../toolOutputReferences';
 import * as events from '@/utils/events';
-import type {
-  PostToolUseHookOutput,
-  PreToolUseHookOutput,
-} from '@/hooks';
 import { HookRegistry } from '@/hooks';
 import { ToolNode } from '../ToolNode';
-import { ToolOutputReferenceRegistry } from '../toolOutputReferences';
 
 /**
  * Reads the lazy ref-metadata stamped onto a `ToolMessage` by ToolNode.

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

@@ -4,9 +4,9 @@ import { AIMessage } from '@langchain/core/messages';
 import { describe, it, expect, jest, afterEach } from '@jest/globals';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type * as t from '@/types';
+import * as events from '@/utils/events';
 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.

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

@@ -4,6 +4,7 @@
  * Tests helper functions and sanitization logic without hitting the API.
  */
 import { describe, it, expect } from '@jest/globals';
+import type { ToolMetadata, LCToolRegistry } from '@/types';
 import {
   sanitizeRegex,
   escapeRegexSpecialChars,
@@ -20,7 +21,6 @@ import {
   getBaseToolName,
   formatServerListing,
 } from '../ToolSearch';
-import type { ToolMetadata, LCToolRegistry } from '@/types';
 
 describe('ToolSearch', () => {
   describe('escapeRegexSpecialChars', () => {

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

@@ -1,5 +1,5 @@
-import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
 import { describe, it, expect } from '@jest/globals';
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
 import {
   annotateMessagesForLLM,
   ToolOutputReferenceRegistry,

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

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { tool } from '@langchain/core/tools';
+import { AIMessage, ToolMessage } from '@langchain/core/messages';
+import { describe, it, expect, jest, afterEach } from '@jest/globals';
 import {
   END,
   START,
@@ -9,11 +11,9 @@ import {
   MessagesAnnotation,
   Command,
 } from '@langchain/langgraph';
-import { AIMessage, ToolMessage } from '@langchain/core/messages';
-import { describe, it, expect, jest, afterEach } from '@jest/globals';
+import type { Runnable, RunnableConfig } from '@langchain/core/runnables';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type { BaseMessage } from '@langchain/core/messages';
-import type { Runnable, RunnableConfig } from '@langchain/core/runnables';
 import type { PreToolUseHookOutput } from '@/hooks';
 import type * as t from '@/types';
 import { HookRegistry } from '@/hooks';
@@ -60,7 +60,11 @@ function buildGraph(
     .addNode('agent', (): MessagesUpdate => {
       agentInvocations += 1;
       if (agentInvocations === 1) {
-        return { messages: [aiCall(toolCalls[0].id, toolCalls[0].name, toolCalls[0].args)] };
+        return {
+          messages: [
+            aiCall(toolCalls[0].id, toolCalls[0].name, toolCalls[0].args),
+          ],
+        };
       }
       return { messages: [] };
     })
@@ -80,14 +84,11 @@ describe('direct-path HITL: resume scope', () => {
 
   it('re-executes the direct tool body on resume when interrupt() fires from the direct path', async () => {
     const sideEffect = jest.fn(() => 'EXECUTED');
-    const directTool = tool(
-      async () => sideEffect(),
-      {
-        name: 'echo',
-        description: 'direct tool that records every body invocation',
-        schema: z.object({ command: z.string().optional() }).passthrough(),
-      }
-    ) as unknown as StructuredToolInterface;
+    const directTool = tool(async () => sideEffect(), {
+      name: 'echo',
+      description: 'direct tool that records every body invocation',
+      schema: z.object({ command: z.string().optional() }).passthrough(),
+    }) as unknown as StructuredToolInterface;
 
     const registry = new HookRegistry();
     let hookInvocations = 0;
@@ -149,7 +150,9 @@ describe('direct-path HITL: resume scope', () => {
 
     // Result should carry the executed output.
     const messages = (second as { messages: ToolMessage[] }).messages;
-    const toolMsg = messages.find((m) => m instanceof ToolMessage) as ToolMessage;
+    const toolMsg = messages.find(
+      (m) => m instanceof ToolMessage
+    ) as ToolMessage;
     expect(String(toolMsg.content)).toBe('EXECUTED');
   });
 
@@ -199,17 +202,20 @@ describe('direct-path HITL: resume scope', () => {
     });
 
     const builder = new StateGraph(MessagesAnnotation)
-      .addNode('agent', (): MessagesUpdate => ({
-        messages: [
-          new AIMessage({
-            content: '',
-            tool_calls: [
-              { id: 'a1', name: 'tool_a', args: {} },
-              { id: 'b1', name: 'tool_b', args: {} },
-            ],
-          }),
-        ],
-      }))
+      .addNode(
+        'agent',
+        (): MessagesUpdate => ({
+          messages: [
+            new AIMessage({
+              content: '',
+              tool_calls: [
+                { id: 'a1', name: 'tool_a', args: {} },
+                { id: 'b1', name: 'tool_b', args: {} },
+              ],
+            }),
+          ],
+        })
+      )
       .addNode('tools', node)
       .addEdge(START, 'agent')
       .addEdge('agent', 'tools')
@@ -311,14 +317,11 @@ describe('direct-path HITL: resume scope', () => {
     });
 
     it('fails closed when updatedInput is missing or wrong-shaped', async () => {
-      const directTool = tool(
-        async () => 'should-not-execute',
-        {
-          name: 'echo',
-          description: 'must not execute on malformed edit',
-          schema: z.object({ command: z.string().optional() }).passthrough(),
-        }
-      ) as unknown as StructuredToolInterface;
+      const directTool = tool(async () => 'should-not-execute', {
+        name: 'echo',
+        description: 'must not execute on malformed edit',
+        schema: z.object({ command: z.string().optional() }).passthrough(),
+      }) as unknown as StructuredToolInterface;
 
       const registry = new HookRegistry();
       registry.register('PreToolUse', {

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

@@ -147,6 +147,47 @@ describe('Direct-path lifecycle hooks (in-process tools)', () => {
     expect(String(message.content)).toBe('ran:ls');
   });
 
+  it('executingAgentId defaults to agentId for direct callers, and an explicit value wins', async () => {
+    const echo = createDirectTool('echo', (args) => `ran:${args.command}`);
+    const captured: Array<string | undefined> = [];
+    const registry = new HookRegistry();
+    registry.register('PreToolUse', {
+      hooks: [
+        async (input): Promise<PreToolUseHookOutput> => {
+          captured.push(input.executingAgentId);
+          return { decision: 'allow' };
+        },
+      ],
+    });
+
+    // Only the existing `agentId` option is passed → executingAgentId defaults to it.
+    const defaulted = new ToolNode({
+      tools: [echo],
+      eventDrivenMode: true,
+      hookRegistry: registry,
+      directToolNames: new Set(['echo']),
+      agentId: 'solo-agent',
+    });
+    await defaulted.invoke({
+      messages: [aiCall('call_def', 'echo', { command: 'a' })],
+    });
+
+    // An explicit executingAgentId overrides the agentId default.
+    const explicit = new ToolNode({
+      tools: [echo],
+      eventDrivenMode: true,
+      hookRegistry: registry,
+      directToolNames: new Set(['echo']),
+      agentId: 'solo-agent',
+      executingAgentId: 'owner-agent',
+    });
+    await explicit.invoke({
+      messages: [aiCall('call_exp', 'echo', { command: 'b' })],
+    });
+
+    expect(captured).toEqual(['solo-agent', 'owner-agent']);
+  });
+
   it('PreToolUse updatedInput rewrites the args before runTool sees them', async () => {
     const seen: Record<string, unknown>[] = [];
     const echo = createDirectTool('echo', (args) => {

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

@@ -1,14 +1,14 @@
 import { describe, it, expect, beforeEach, jest } from '@jest/globals';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
-import type { StandardGraph } from '@/graphs';
 import type { AgentContext } from '@/agents/AgentContext';
+import type { StandardGraph } from '@/graphs';
 import type * as t from '@/types';
-import { StepTypes, ToolCallTypes, Providers, GraphEvents } from '@/common';
 import {
   handleToolCallChunks,
   handleToolCalls,
   handleServerToolResult,
 } from '../handlers';
+import { StepTypes, ToolCallTypes, Providers, GraphEvents } from '@/common';
 
 type MockGraph = {
   getStepKey: jest.Mock;

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

@@ -1,14 +1,5 @@
 import { z } from 'zod';
 import { tool } from '@langchain/core/tools';
-import {
-  END,
-  START,
-  Command,
-  StateGraph,
-  MemorySaver,
-  isInterrupted,
-  MessagesAnnotation,
-} from '@langchain/langgraph';
 import { AIMessage, ToolMessage } from '@langchain/core/messages';
 import {
   describe,
@@ -18,9 +9,18 @@ import {
   afterEach,
   beforeEach,
 } from '@jest/globals';
+import {
+  END,
+  START,
+  Command,
+  StateGraph,
+  MemorySaver,
+  isInterrupted,
+  MessagesAnnotation,
+} from '@langchain/langgraph';
+import type { Runnable, RunnableConfig } from '@langchain/core/runnables';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type { BaseMessage } from '@langchain/core/messages';
-import type { Runnable, RunnableConfig } from '@langchain/core/runnables';
 import type {
   PreToolUseHookOutput,
   PostToolUseHookOutput,
@@ -32,9 +32,9 @@ import type {
   UserPromptSubmitHookOutput,
 } from '@/hooks';
 import type * as t from '@/types';
+import { Providers as providers, GraphEvents } from '@/common';
 import * as events from '@/utils/events';
 import { HookRegistry } from '@/hooks';
-import { Providers as providers, GraphEvents } from '@/common';
 import { ToolNode } from '../ToolNode';
 
 async function flushAsyncWork(): Promise<void> {

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

@@ -1,9 +1,4 @@
 import { describe, it, expect } from '@jest/globals';
-import {
-  Constants,
-  LOCAL_CODING_BUNDLE_NAMES,
-  LOCAL_CODING_TOOL_NAMES,
-} from '@/common';
 import {
   createLocalCodingTools,
   createLocalCodingToolDefinitions,
@@ -13,6 +8,11 @@ import {
   LocalListDirectoryToolName,
   LocalWriteFileToolName,
 } from '../local/LocalCodingTools';
+import {
+  Constants,
+  LOCAL_CODING_BUNDLE_NAMES,
+  LOCAL_CODING_TOOL_NAMES,
+} from '@/common';
 import { CompileCheckToolName } from '../local/CompileCheckTool';
 
 /**
@@ -45,7 +45,9 @@ describe('local coding tool names', () => {
     expect(Constants.BASH_TOOL).toBe('bash_tool');
     expect(Constants.EXECUTE_CODE).toBe('execute_code');
     expect(Constants.PROGRAMMATIC_TOOL_CALLING).toBe('run_tools_with_code');
-    expect(Constants.BASH_PROGRAMMATIC_TOOL_CALLING).toBe('run_tools_with_bash');
+    expect(Constants.BASH_PROGRAMMATIC_TOOL_CALLING).toBe(
+      'run_tools_with_bash'
+    );
   });
 
   it('LOCAL_CODING_BUNDLE_NAMES matches every name the bundle ships', () => {

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from '@jest/globals';
-import { formatSkillCatalog } from '../skillCatalog';
 import type { SkillCatalogEntry } from '@/types';
+import { formatSkillCatalog } from '../skillCatalog';
 
 describe('formatSkillCatalog', () => {
   it('returns empty string for empty array', () => {

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

@@ -1,7 +1,6 @@
 import { HumanMessage } from '@langchain/core/messages';
 import { FakeListChatModel } from '@langchain/core/utils/testing';
 import type { ToolCall } from '@langchain/core/messages/tool';
-import type * as t from '@/types';
 import type {
   HookCallback,
   PermissionDeniedHookOutput,
@@ -12,9 +11,7 @@ import type {
   SubagentStopHookInput,
   SubagentStopHookOutput,
 } from '@/hooks/types';
-import { HookRegistry } from '@/hooks/HookRegistry';
-import { Run } from '@/run';
-import { FakeChatModel } from '@/llm/fake';
+import type * as t from '@/types';
 import {
   Constants,
   GraphEvents,
@@ -22,7 +19,10 @@ import {
   ToolEndHandler,
   ModelEndHandler,
 } from '@/index';
+import { HookRegistry } from '@/hooks/HookRegistry';
 import * as providers from '@/llm/providers';
+import { FakeChatModel } from '@/llm/fake';
+import { Run } from '@/run';
 
 const CHILD_RESPONSE = 'Hook test child response.';
 
@@ -275,9 +275,7 @@ describe('Subagent hook integration (end-to-end via Run)', () => {
               toolCalls: [createCalculatorToolCall()],
             });
           }
-          bindTools(
-            tools: unknown
-          ): ReturnType<FakeChatModel['withConfig']> {
+          bindTools(tools: unknown): ReturnType<FakeChatModel['withConfig']> {
             const config = {
               tools,
             } as Parameters<FakeChatModel['withConfig']>[0];
@@ -292,11 +290,16 @@ describe('Subagent hook integration (end-to-end via Run)', () => {
     const registry = new HookRegistry();
     const preToolEvents: string[] = [];
     const postToolEvents: string[] = [];
+    // `executingAgentId` is always the owning agent (incl. top-level), unlike
+    // `agentId` which stays undefined outside a subagent scope.
+    const preExecEvents: string[] = [];
+    const postExecEvents: string[] = [];
 
     const preHook: HookCallback<'PreToolUse'> = async (
       input
     ): Promise<PreToolUseHookOutput> => {
       preToolEvents.push(`${input.agentId ?? '-'}:${input.toolName}`);
+      preExecEvents.push(`${input.executingAgentId ?? '-'}:${input.toolName}`);
       return { decision: 'allow' };
     };
     registry.register('PreToolUse', { hooks: [preHook] });
@@ -305,6 +308,7 @@ describe('Subagent hook integration (end-to-end via Run)', () => {
       input
     ): Promise<PostToolUseHookOutput> => {
       postToolEvents.push(`${input.agentId ?? '-'}:${input.toolName}`);
+      postExecEvents.push(`${input.executingAgentId ?? '-'}:${input.toolName}`);
       return {};
     };
     registry.register('PostToolUse', { hooks: [postHook] });
@@ -351,6 +355,14 @@ describe('Subagent hook integration (end-to-end via Run)', () => {
     expect(preToolEvents).toContain('researcher-child:calculator');
     expect(postToolEvents).toContain('-:subagent');
     expect(postToolEvents).toContain('researcher-child:calculator');
+
+    // `agentId` stays the subagent-scope marker (undefined at the top level),
+    // but `executingAgentId` attributes every batch to its owning agent — incl.
+    // the top-level parent, which a multi-agent host needs and `agentId` can't give.
+    expect(preExecEvents).toContain('hook-parent:subagent');
+    expect(preExecEvents).toContain('researcher-child:calculator');
+    expect(postExecEvents).toContain('hook-parent:subagent');
+    expect(postExecEvents).toContain('researcher-child:calculator');
   });
 
   it('child subagent tool ask hooks fail closed instead of starting unsupported nested HITL', async () => {
@@ -365,9 +377,7 @@ describe('Subagent hook integration (end-to-end via Run)', () => {
               toolCalls: [createCalculatorToolCall()],
             });
           }
-          bindTools(
-            tools: unknown
-          ): ReturnType<FakeChatModel['withConfig']> {
+          bindTools(tools: unknown): ReturnType<FakeChatModel['withConfig']> {
             const config = {
               tools,
             } as Parameters<FakeChatModel['withConfig']>[0];

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

@@ -1,15 +1,22 @@
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { mkdtemp, rm, writeFile } from 'fs/promises';
-import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
-import { Constants } from '@/common';
-import { createLocalCodingToolBundle } from '../local/LocalCodingTools';
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  jest,
+} from '@jest/globals';
+import type { WorkspaceFS } from '../local/workspaceFS';
 import {
   resolveWorkspacePathSafe,
   getWorkspaceFS,
 } from '../local/LocalExecutionEngine';
+import { createLocalCodingToolBundle } from '../local/LocalCodingTools';
 import { nodeWorkspaceFS } from '../local/workspaceFS';
-import type { WorkspaceFS } from '../local/workspaceFS';
+import { Constants } from '@/common';
 
 describe('workspace seam', () => {
   let workspace: string;
@@ -97,10 +104,14 @@ describe('workspace seam', () => {
       // the real Node impl so the tool actually completes; the spy just
       // proves the seam.
       const tracked: WorkspaceFS = {
-        readFile: jest.fn(nodeWorkspaceFS.readFile) as unknown as WorkspaceFS['readFile'],
+        readFile: jest.fn(
+          nodeWorkspaceFS.readFile
+        ) as unknown as WorkspaceFS['readFile'],
         writeFile: jest.fn(nodeWorkspaceFS.writeFile),
         stat: jest.fn(nodeWorkspaceFS.stat),
-        readdir: jest.fn(nodeWorkspaceFS.readdir) as unknown as WorkspaceFS['readdir'],
+        readdir: jest.fn(
+          nodeWorkspaceFS.readdir
+        ) as unknown as WorkspaceFS['readdir'],
         mkdir: jest.fn(nodeWorkspaceFS.mkdir),
         realpath: jest.fn(nodeWorkspaceFS.realpath),
         unlink: jest.fn(nodeWorkspaceFS.unlink),
@@ -120,7 +131,9 @@ describe('workspace seam', () => {
       expect(tracked.writeFile).toHaveBeenCalled();
       expect(tracked.mkdir).toHaveBeenCalled();
 
-      const readTool = bundle.tools.find((t) => t.name === Constants.READ_FILE)!;
+      const readTool = bundle.tools.find(
+        (t) => t.name === Constants.READ_FILE
+      )!;
       await readTool.invoke({
         id: 'c2',
         name: Constants.READ_FILE,

package/src/tools/cloudflare/CloudflareSandboxExecutionEngine.ts

@@ -1,15 +1,15 @@
-import { EventEmitter } from 'events';
 import { PassThrough } from 'stream';
 import { posix as path } from 'path';
-import type { ChildProcessWithoutNullStreams } from 'child_process';
+import { EventEmitter } from 'events';
 import type { WriteFileOptions, MakeDirectoryOptions, Stats } from 'fs';
+import type { ChildProcessWithoutNullStreams } from 'child_process';
 import type { FileHandle } from 'fs/promises';
+import type { WorkspaceFS, ReaddirEntry } from '@/tools/local/workspaceFS';
 import type * as t from '@/types';
 import {
   LOCAL_SPAWN_TIMEOUT_MS,
   validateBashCommand,
 } from '@/tools/local/LocalExecutionEngine';
-import type { WorkspaceFS, ReaddirEntry } from '@/tools/local/workspaceFS';
 
 const DEFAULT_WORKSPACE_ROOT = '/workspace';
 const DEFAULT_TIMEOUT_MS = 60000;
@@ -403,6 +403,9 @@ function createCloudflareSpawn(
     const child = new EventEmitter() as ChildProcessWithoutNullStreams;
     const abortController = new AbortController();
     const state = { closed: false };
+    /** Read through a function so concurrent `closeOnce` mutation (via
+     * `kill()`/abort during an `await`) isn't statically narrowed away. */
+    const isClosed = (): boolean => state.closed;
     const closeOnce = (
       exitCode: number | null,
       signal: NodeJS.Signals | null
@@ -451,7 +454,7 @@ function createCloudflareSpawn(
       const timedCommand = withInSandboxTimeout(rendered, timeoutMs);
       const cwd =
         options.cwd == null ? ctx.workspaceRoot : options.cwd.toString();
-      if (state.closed) {
+      if (isClosed()) {
         return;
       }
       const execOptions: t.CloudflareSandboxExecOptions = {
@@ -464,14 +467,14 @@ function createCloudflareSpawn(
       }
       try {
         const result = await ctx.sandbox.exec(timedCommand, execOptions);
-        if (state.closed) {
+        if (isClosed()) {
           return;
         }
         if (result.stdout) stdout.write(result.stdout);
         if (result.stderr) stderr.write(result.stderr);
         closeOnce(result.exitCode, null);
       } catch (error) {
-        if (state.closed) {
+        if (isClosed()) {
           return;
         }
         stderr.write((error as Error).message);