@librechat/agents 3.4.7 → 3.5.1

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

@@ -1,1557 +0,0 @@
-// src/tools/__tests__/ProgrammaticToolCalling.test.ts
-/**
- * Unit tests for Programmatic Tool Calling.
- * Tests manual invocation with mock tools and Code API responses.
- */
-import { describe, it, expect, jest, beforeEach } from '@jest/globals';
-import type * as t from '@/types';
-import {
-  createProgrammaticToolCallingTool,
-  createProgrammaticToolCallingSchema,
-  formatCompletedResponse,
-  extractUsedToolNames,
-  filterToolsByUsage,
-  executeTools,
-  normalizeToPythonIdentifier,
-  unwrapToolResponse,
-} from '../ProgrammaticToolCalling';
-import {
-  createProgrammaticToolRegistry,
-  createGetTeamMembersTool,
-  createGetExpensesTool,
-  createGetWeatherTool,
-  createCalculatorTool,
-} from '@/test/mockTools';
-import {
-  createBashProgrammaticToolCallingSchema,
-  normalizeBashToolResultsForReplay,
-} from '../BashProgrammaticToolCalling';
-import { Constants } from '@/common';
-
-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(
-        'Tool stdout is normalized to one compact JSON value'
-      );
-      expect(description).toContain('use fromjson? // .');
-      expect(description).toContain('only for JSON-string fields');
-      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 register nothing');
-      expect(description).toContain('`/tmp` never survives the call');
-    });
-  });
-
-  describe('normalizeBashToolResultsForReplay', () => {
-    it('decodes JSON-looking string results before bash replay', () => {
-      const results = normalizeBashToolResultsForReplay([
-        {
-          call_id: 'call_001',
-          result: JSON.stringify({
-            result: {
-              data: [{ station_id: 'USW00094725', winter_days: 91 }],
-            },
-          }),
-          is_error: false,
-        },
-      ]);
-
-      expect(results[0].result).toEqual({
-        result: {
-          data: [{ station_id: 'USW00094725', winter_days: 91 }],
-        },
-      });
-    });
-
-    it('decodes JSON-looking array string results before bash replay', () => {
-      const results = normalizeBashToolResultsForReplay([
-        {
-          call_id: 'call_001',
-          result: '[{"name":"tempAvg"},{"name":"snowDepth"}]',
-          is_error: false,
-        },
-      ]);
-
-      expect(results[0].result).toEqual([
-        { name: 'tempAvg' },
-        { name: 'snowDepth' },
-      ]);
-    });
-
-    it('preserves plain strings, invalid JSON strings, and error results', () => {
-      const errorJson = '{"message":"tool failed"}';
-      const results = normalizeBashToolResultsForReplay([
-        {
-          call_id: 'call_001',
-          result: 'plain text',
-          is_error: false,
-        },
-        {
-          call_id: 'call_002',
-          result: '{not json}',
-          is_error: false,
-        },
-        {
-          call_id: 'call_003',
-          result: errorJson,
-          is_error: true,
-          error_message: 'tool failed',
-        },
-      ]);
-
-      expect(results[0].result).toBe('plain text');
-      expect(results[1].result).toBe('{not json}');
-      expect(results[2].result).toBe(errorJson);
-    });
-  });
-
-  describe('executeTools', () => {
-    let toolMap: t.ToolMap;
-
-    beforeEach(() => {
-      const tools = [
-        createGetTeamMembersTool(),
-        createGetExpensesTool(),
-        createGetWeatherTool(),
-        createCalculatorTool(),
-      ];
-      toolMap = new Map(tools.map((t) => [t.name, t]));
-    });
-
-    it('executes a single tool successfully', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'get_weather',
-          input: { city: 'San Francisco' },
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results).toHaveLength(1);
-      expect(results[0].call_id).toBe('call_001');
-      expect(results[0].is_error).toBe(false);
-      expect(results[0].result).toEqual({
-        temperature: 65,
-        condition: 'Foggy',
-      });
-    });
-
-    it('parses JSON-string inputs before invoking structured tools', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'get_weather',
-          input: '{"city":"San Francisco"}',
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results).toHaveLength(1);
-      expect(results[0].call_id).toBe('call_001');
-      expect(results[0].is_error).toBe(false);
-      expect(results[0].result).toEqual({
-        temperature: 65,
-        condition: 'Foggy',
-      });
-    });
-
-    it('parses ClickHouse-style JSON strings with SQL punctuation for object-schema tools', async () => {
-      const invoke = jest.fn<
-        (_input: unknown, _config: unknown) => Promise<unknown>
-          >(async (input) => input);
-      const customTool = {
-        name: 'run_select_query_mcp_ClickHouse',
-        schema: {
-          type: 'object',
-          properties: {
-            serviceId: { type: 'string' },
-            query: { type: 'string' },
-          },
-          required: ['serviceId', 'query'],
-        },
-        invoke,
-      } as unknown as t.GenericTool;
-      const customToolMap: t.ToolMap = new Map([
-        ['run_select_query_mcp_ClickHouse', customTool],
-      ]);
-      const input = {
-        serviceId: '45886e06-932b-4cff-bb49-3f7281d80717',
-        query:
-          'SELECT name, round(avg(tempAvg)/10.0, 2) AS avg_temp_c ' +
-          'FROM system.columns WHERE database=\'default\' ' +
-          'AND table=\'uk_prices_3\' AND tempAvg != -9999',
-      };
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'run_select_query_mcp_ClickHouse',
-          input: JSON.stringify(input),
-        },
-      ];
-
-      const results = await executeTools(toolCalls, customToolMap);
-
-      expect(results[0].is_error).toBe(false);
-      expect(results[0].result).toEqual(input);
-      expect(invoke).toHaveBeenCalledWith(input, {
-        metadata: { [Constants.PROGRAMMATIC_TOOL_CALLING]: true },
-      });
-    });
-
-    it('preserves JSON-looking strings for string-input tools', async () => {
-      const invoke = jest.fn<
-        (_input: unknown, _config: unknown) => Promise<unknown>
-          >(async (input) => input);
-      const customTool = {
-        name: 'string_tool',
-        schema: { type: 'string' },
-        invoke,
-      } as unknown as t.GenericTool;
-      const customToolMap: t.ToolMap = new Map([['string_tool', customTool]]);
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'string_tool',
-          input: '{"raw":true}',
-        },
-      ];
-
-      const results = await executeTools(toolCalls, customToolMap);
-
-      expect(results[0].is_error).toBe(false);
-      expect(results[0].result).toBe('{"raw":true}');
-      expect(invoke).toHaveBeenCalledWith('{"raw":true}', {
-        metadata: { [Constants.PROGRAMMATIC_TOOL_CALLING]: true },
-      });
-    });
-
-    it('preserves ClickHouse-style JSON strings for raw string-input tools', async () => {
-      const invoke = jest.fn<
-        (_input: unknown, _config: unknown) => Promise<unknown>
-          >(async (input) => input);
-      const customTool = {
-        name: 'string_tool',
-        schema: { type: 'string' },
-        invoke,
-      } as unknown as t.GenericTool;
-      const customToolMap: t.ToolMap = new Map([['string_tool', customTool]]);
-      const input = JSON.stringify({
-        serviceId: '45886e06-932b-4cff-bb49-3f7281d80717',
-        query:
-          'SELECT round(avg(tempAvg)/10.0, 2) AS avg_temp_c ' +
-          'FROM default.weather_noaa_mt WHERE database=\'default\'',
-      });
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'string_tool',
-          input,
-        },
-      ];
-
-      const results = await executeTools(toolCalls, customToolMap);
-
-      expect(results[0].is_error).toBe(false);
-      expect(results[0].result).toBe(input);
-      expect(invoke).toHaveBeenCalledWith(input, {
-        metadata: { [Constants.PROGRAMMATIC_TOOL_CALLING]: true },
-      });
-    });
-
-    it('stringifies object inputs before invoking string-input tools', async () => {
-      const invoke = jest.fn<
-        (_input: unknown, _config: unknown) => Promise<unknown>
-          >(async (input) => input);
-      const customTool = {
-        name: 'string_tool',
-        schema: { type: 'string' },
-        invoke,
-      } as unknown as t.GenericTool;
-      const customToolMap: t.ToolMap = new Map([['string_tool', customTool]]);
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'string_tool',
-          input: { raw: true },
-        },
-      ];
-
-      const results = await executeTools(toolCalls, customToolMap);
-
-      expect(results[0].is_error).toBe(false);
-      expect(results[0].result).toBe('{"raw":true}');
-      expect(invoke).toHaveBeenCalledWith('{"raw":true}', {
-        metadata: { [Constants.PROGRAMMATIC_TOOL_CALLING]: true },
-      });
-    });
-
-    it('preserves object inputs for mixed object-or-string schemas', async () => {
-      const invoke = jest.fn<
-        (_input: unknown, _config: unknown) => Promise<unknown>
-          >(async (input) => input);
-      const customTool = {
-        name: 'mixed_tool',
-        schema: { type: ['object', 'string'] },
-        invoke,
-      } as unknown as t.GenericTool;
-      const customToolMap: t.ToolMap = new Map([['mixed_tool', customTool]]);
-      const input = { raw: true };
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'mixed_tool',
-          input,
-        },
-      ];
-
-      const results = await executeTools(toolCalls, customToolMap);
-
-      expect(results[0].is_error).toBe(false);
-      expect(results[0].result).toBe(input);
-      expect(invoke).toHaveBeenCalledWith(input, {
-        metadata: { [Constants.PROGRAMMATIC_TOOL_CALLING]: true },
-      });
-    });
-
-    it('preserves JSON-looking strings for mixed object-or-string schemas', async () => {
-      const invoke = jest.fn<
-        (_input: unknown, _config: unknown) => Promise<unknown>
-          >(async (input) => input);
-      const customTool = {
-        name: 'mixed_tool',
-        schema: { type: ['object', 'string'] },
-        invoke,
-      } as unknown as t.GenericTool;
-      const customToolMap: t.ToolMap = new Map([['mixed_tool', customTool]]);
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'mixed_tool',
-          input: '{"raw":true}',
-        },
-      ];
-
-      const results = await executeTools(toolCalls, customToolMap);
-
-      expect(results[0].is_error).toBe(false);
-      expect(results[0].result).toBe('{"raw":true}');
-      expect(invoke).toHaveBeenCalledWith('{"raw":true}', {
-        metadata: { [Constants.PROGRAMMATIC_TOOL_CALLING]: true },
-      });
-    });
-
-    it('marks bash PTC inner tool invocations with bash metadata', async () => {
-      const invoke = jest.fn<
-        (_input: unknown, _config: unknown) => Promise<{ ok: boolean }>
-          >(async () => ({ ok: true }));
-      const customTool = {
-        name: 'custom_tool',
-        invoke,
-      } as unknown as t.GenericTool;
-      const customToolMap: t.ToolMap = new Map([['custom_tool', customTool]]);
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'custom_tool',
-          input: { value: 1 },
-        },
-      ];
-
-      await executeTools(
-        toolCalls,
-        customToolMap,
-        Constants.BASH_PROGRAMMATIC_TOOL_CALLING
-      );
-
-      expect(invoke).toHaveBeenCalledWith(
-        { value: 1 },
-        { metadata: { [Constants.BASH_PROGRAMMATIC_TOOL_CALLING]: true } }
-      );
-    });
-
-    it('executes multiple tools in parallel', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'get_weather',
-          input: { city: 'San Francisco' },
-        },
-        {
-          id: 'call_002',
-          name: 'get_weather',
-          input: { city: 'New York' },
-        },
-        {
-          id: 'call_003',
-          name: 'get_weather',
-          input: { city: 'London' },
-        },
-      ];
-
-      const startTime = Date.now();
-      const results = await executeTools(toolCalls, toolMap);
-      const duration = Date.now() - startTime;
-
-      // Should execute in parallel (< 150ms total, not 120ms sequential)
-      expect(duration).toBeLessThan(150);
-
-      expect(results).toHaveLength(3);
-      expect(results[0].is_error).toBe(false);
-      expect(results[1].is_error).toBe(false);
-      expect(results[2].is_error).toBe(false);
-
-      expect(results[0].result.temperature).toBe(65);
-      expect(results[1].result.temperature).toBe(75);
-      expect(results[2].result.temperature).toBe(55);
-    });
-
-    it('handles tool not found error', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'nonexistent_tool',
-          input: {},
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results).toHaveLength(1);
-      expect(results[0].call_id).toBe('call_001');
-      expect(results[0].is_error).toBe(true);
-      expect(results[0].error_message).toContain('nonexistent_tool');
-      expect(results[0].error_message).toContain('Available tools:');
-    });
-
-    it('handles tool execution error', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'get_weather',
-          input: { city: 'InvalidCity' },
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results).toHaveLength(1);
-      expect(results[0].call_id).toBe('call_001');
-      expect(results[0].is_error).toBe(true);
-      expect(results[0].error_message).toContain('Weather data not available');
-    });
-
-    it('handles mix of successful and failed tool calls', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'get_weather',
-          input: { city: 'San Francisco' },
-        },
-        {
-          id: 'call_002',
-          name: 'get_weather',
-          input: { city: 'InvalidCity' },
-        },
-        {
-          id: 'call_003',
-          name: 'get_weather',
-          input: { city: 'New York' },
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results).toHaveLength(3);
-      expect(results[0].is_error).toBe(false);
-      expect(results[1].is_error).toBe(true);
-      expect(results[2].is_error).toBe(false);
-    });
-
-    it('executes tools with different parameters', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'get_team_members',
-          input: {},
-        },
-        {
-          id: 'call_002',
-          name: 'get_expenses',
-          input: { user_id: 'u1' },
-        },
-        {
-          id: 'call_003',
-          name: 'calculator',
-          input: { expression: '2 + 2 * 3' },
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results).toHaveLength(3);
-      expect(results[0].is_error).toBe(false);
-      expect(results[1].is_error).toBe(false);
-      expect(results[2].is_error).toBe(false);
-
-      expect(Array.isArray(results[0].result)).toBe(true);
-      expect(results[0].result).toHaveLength(3);
-      expect(Array.isArray(results[1].result)).toBe(true);
-      expect(results[2].result.result).toBe(8);
-    });
-  });
-
-  describe('normalizeToPythonIdentifier', () => {
-    it('converts hyphens to underscores', () => {
-      expect(normalizeToPythonIdentifier('my-tool-name')).toBe('my_tool_name');
-    });
-
-    it('converts spaces to underscores', () => {
-      expect(normalizeToPythonIdentifier('my tool name')).toBe('my_tool_name');
-    });
-
-    it('leaves underscores unchanged', () => {
-      expect(normalizeToPythonIdentifier('my_tool_name')).toBe('my_tool_name');
-    });
-
-    it('handles mixed hyphens and underscores', () => {
-      expect(normalizeToPythonIdentifier('my-tool_name-v2')).toBe(
-        'my_tool_name_v2'
-      );
-    });
-
-    it('handles MCP-style names with hyphens', () => {
-      expect(
-        normalizeToPythonIdentifier('create_spreadsheet_mcp_Google-Workspace')
-      ).toBe('create_spreadsheet_mcp_Google_Workspace');
-    });
-
-    it('removes invalid characters', () => {
-      expect(normalizeToPythonIdentifier('tool@name!v2')).toBe('toolnamev2');
-      expect(normalizeToPythonIdentifier('get.data.v2')).toBe('getdatav2');
-    });
-
-    it('prefixes with underscore if starts with number', () => {
-      expect(normalizeToPythonIdentifier('123tool')).toBe('_123tool');
-      expect(normalizeToPythonIdentifier('1-tool')).toBe('_1_tool');
-    });
-
-    it('appends _tool suffix for Python keywords', () => {
-      expect(normalizeToPythonIdentifier('return')).toBe('return_tool');
-      expect(normalizeToPythonIdentifier('async')).toBe('async_tool');
-      expect(normalizeToPythonIdentifier('import')).toBe('import_tool');
-    });
-  });
-
-  describe('unwrapToolResponse', () => {
-    describe('non-MCP tools', () => {
-      it('returns result as-is for non-MCP tools', () => {
-        const result = { temperature: 65, condition: 'Foggy' };
-        expect(unwrapToolResponse(result, false)).toEqual(result);
-      });
-
-      it('returns string as-is for non-MCP tools', () => {
-        expect(unwrapToolResponse('plain string', false)).toBe('plain string');
-      });
-
-      it('returns array as-is for non-MCP tools', () => {
-        const result = [1, 2, 3];
-        expect(unwrapToolResponse(result, false)).toEqual(result);
-      });
-    });
-
-    describe('MCP tools - tuple format [content, artifacts]', () => {
-      it('extracts string content from tuple', () => {
-        const result = ['Hello world', { artifacts: [] }];
-        expect(unwrapToolResponse(result, true)).toBe('Hello world');
-      });
-
-      it('parses JSON string content from tuple', () => {
-        const result = ['{"temperature": 65}', { artifacts: [] }];
-        expect(unwrapToolResponse(result, true)).toEqual({ temperature: 65 });
-      });
-
-      it('parses JSON array string content from tuple', () => {
-        const result = ['[1, 2, 3]', { artifacts: [] }];
-        expect(unwrapToolResponse(result, true)).toEqual([1, 2, 3]);
-      });
-
-      it('extracts text from single content block in tuple', () => {
-        const result = [{ type: 'text', text: 'Spreadsheet info here' }, {}];
-        expect(unwrapToolResponse(result, true)).toBe('Spreadsheet info here');
-      });
-
-      it('extracts and parses JSON from single content block in tuple', () => {
-        const result = [
-          { type: 'text', text: '{"id": "123", "name": "Test"}' },
-          {},
-        ];
-        expect(unwrapToolResponse(result, true)).toEqual({
-          id: '123',
-          name: 'Test',
-        });
-      });
-
-      it('extracts text from array of content blocks in tuple', () => {
-        const result = [
-          [
-            { type: 'text', text: 'Line 1' },
-            { type: 'text', text: 'Line 2' },
-          ],
-          {},
-        ];
-        expect(unwrapToolResponse(result, true)).toBe('Line 1\nLine 2');
-      });
-
-      it('returns object content as-is when not a text block', () => {
-        const result = [{ temperature: 65, condition: 'Foggy' }, {}];
-        expect(unwrapToolResponse(result, true)).toEqual({
-          temperature: 65,
-          condition: 'Foggy',
-        });
-      });
-    });
-
-    describe('MCP tools - single content block (not in tuple)', () => {
-      it('extracts text from single content block object', () => {
-        const result = { type: 'text', text: 'No data found in range' };
-        expect(unwrapToolResponse(result, true)).toBe('No data found in range');
-      });
-
-      it('extracts and parses JSON from single content block object', () => {
-        const result = {
-          type: 'text',
-          text: '{"sheets": [{"name": "raw_data"}]}',
-        };
-        expect(unwrapToolResponse(result, true)).toEqual({
-          sheets: [{ name: 'raw_data' }],
-        });
-      });
-
-      it('handles real-world MCP spreadsheet response', () => {
-        const result = {
-          type: 'text',
-          text: 'Spreadsheet: "NYC Taxi - Top Pickup Neighborhoods" (ID: abc123)\nSheets (2):\n  - "raw_data" (ID: 123) | Size: 1000x26',
-        };
-        expect(unwrapToolResponse(result, true)).toBe(
-          'Spreadsheet: "NYC Taxi - Top Pickup Neighborhoods" (ID: abc123)\nSheets (2):\n  - "raw_data" (ID: 123) | Size: 1000x26'
-        );
-      });
-
-      it('handles real-world MCP no data response', () => {
-        const result = {
-          type: 'text',
-          text: 'No data found in range \'raw_data!A1:D25\' for user@example.com.',
-        };
-        expect(unwrapToolResponse(result, true)).toBe(
-          'No data found in range \'raw_data!A1:D25\' for user@example.com.'
-        );
-      });
-    });
-
-    describe('MCP tools - array of content blocks (not in tuple)', () => {
-      it('extracts text from array of content blocks', () => {
-        const result = [
-          { type: 'text', text: 'First block' },
-          { type: 'text', text: 'Second block' },
-        ];
-        expect(unwrapToolResponse(result, true)).toBe(
-          'First block\nSecond block'
-        );
-      });
-
-      it('filters out non-text blocks', () => {
-        const result = [
-          { type: 'text', text: 'Text content' },
-          { type: 'image', data: 'base64...' },
-          { type: 'text', text: 'More text' },
-        ];
-        expect(unwrapToolResponse(result, true)).toBe(
-          'Text content\nMore text'
-        );
-      });
-    });
-
-    describe('edge cases', () => {
-      it('returns non-text block object as-is', () => {
-        const result = { type: 'image', data: 'base64...' };
-        expect(unwrapToolResponse(result, true)).toEqual(result);
-      });
-
-      it('handles empty array', () => {
-        expect(unwrapToolResponse([], true)).toEqual([]);
-      });
-
-      it('handles malformed JSON in text block gracefully', () => {
-        const result = { type: 'text', text: '{ invalid json }' };
-        expect(unwrapToolResponse(result, true)).toBe('{ invalid json }');
-      });
-
-      it('handles null', () => {
-        expect(unwrapToolResponse(null, true)).toBe(null);
-      });
-
-      it('handles undefined', () => {
-        expect(unwrapToolResponse(undefined, true)).toBe(undefined);
-      });
-    });
-  });
-
-  describe('extractUsedToolNames', () => {
-    const createToolMap = (names: string[]): Map<string, string> => {
-      const map = new Map<string, string>();
-      for (const name of names) {
-        map.set(normalizeToPythonIdentifier(name), name);
-      }
-      return map;
-    };
-
-    const availableTools = createToolMap([
-      'get_weather',
-      'get_team_members',
-      'get_expenses',
-      'calculator',
-      'search_docs',
-    ]);
-
-    it('extracts single tool name from simple code', () => {
-      const code = `result = await get_weather(city="SF")
-print(result)`;
-      const used = extractUsedToolNames(code, availableTools);
-
-      expect(used.size).toBe(1);
-      expect(used.has('get_weather')).toBe(true);
-    });
-
-    it('extracts multiple tool names from code', () => {
-      const code = `team = await get_team_members()
-for member in team:
-    expenses = await get_expenses(user_id=member['id'])
-    print(f"{member['name']}: {sum(e['amount'] for e in expenses)}")`;
-
-      const used = extractUsedToolNames(code, availableTools);
-
-      expect(used.size).toBe(2);
-      expect(used.has('get_team_members')).toBe(true);
-      expect(used.has('get_expenses')).toBe(true);
-    });
-
-    it('extracts tools from asyncio.gather calls', () => {
-      const code = `results = await asyncio.gather(
-    get_weather(city="SF"),
-    get_weather(city="NYC"),
-    get_expenses(user_id="u1")
-)`;
-      const used = extractUsedToolNames(code, availableTools);
-
-      expect(used.size).toBe(2);
-      expect(used.has('get_weather')).toBe(true);
-      expect(used.has('get_expenses')).toBe(true);
-    });
-
-    it('does not match partial tool names', () => {
-      const code = `# Using get_weather_data instead
-result = await get_weather_data(city="SF")`;
-
-      const used = extractUsedToolNames(code, availableTools);
-      expect(used.has('get_weather')).toBe(false);
-    });
-
-    it('matches tool names in different contexts', () => {
-      const code = `# direct call
-x = await calculator(expression="1+1")
-# in list comprehension
-results = [await get_weather(city=c) for c in cities]
-# conditional
-if condition:
-    await get_team_members()`;
-
-      const used = extractUsedToolNames(code, availableTools);
-
-      expect(used.size).toBe(3);
-      expect(used.has('calculator')).toBe(true);
-      expect(used.has('get_weather')).toBe(true);
-      expect(used.has('get_team_members')).toBe(true);
-    });
-
-    it('returns empty set when no tools are used', () => {
-      const code = `print("Hello, World!")
-x = 1 + 2`;
-
-      const used = extractUsedToolNames(code, availableTools);
-      expect(used.size).toBe(0);
-    });
-
-    it('handles tool names with special characters via normalization', () => {
-      const specialTools = createToolMap(['get_data.v2', 'calc+plus']);
-      const code = `await get_datav2()
-await calcplus()`;
-
-      const used = extractUsedToolNames(code, specialTools);
-
-      expect(used.has('get_data.v2')).toBe(true);
-      expect(used.has('calc+plus')).toBe(true);
-    });
-
-    it('matches hyphenated tool names using underscore in code', () => {
-      const mcpTools = createToolMap([
-        'create_spreadsheet_mcp_Google-Workspace',
-        'search_gmail_mcp_Google-Workspace',
-      ]);
-      const code = `result = await create_spreadsheet_mcp_Google_Workspace(title="Test")
-print(result)`;
-
-      const used = extractUsedToolNames(code, mcpTools);
-
-      expect(used.size).toBe(1);
-      expect(used.has('create_spreadsheet_mcp_Google-Workspace')).toBe(true);
-    });
-  });
-
-  describe('filterToolsByUsage', () => {
-    const allToolDefs: t.LCTool[] = [
-      {
-        name: 'get_weather',
-        description: 'Get weather for a city',
-        parameters: {
-          type: 'object',
-          properties: { city: { type: 'string' } },
-        },
-      },
-      {
-        name: 'get_team_members',
-        description: 'Get team members',
-        parameters: { type: 'object', properties: {} },
-      },
-      {
-        name: 'get_expenses',
-        description: 'Get expenses for a user',
-        parameters: {
-          type: 'object',
-          properties: { user_id: { type: 'string' } },
-        },
-      },
-      {
-        name: 'calculator',
-        description: 'Evaluate an expression',
-        parameters: {
-          type: 'object',
-          properties: { expression: { type: 'string' } },
-        },
-      },
-    ];
-
-    it('filters to only used tools', () => {
-      const code = `result = await get_weather(city="SF")
-print(result)`;
-
-      const filtered = filterToolsByUsage(allToolDefs, code);
-
-      expect(filtered).toHaveLength(1);
-      expect(filtered[0].name).toBe('get_weather');
-    });
-
-    it('filters to multiple used tools', () => {
-      const code = `team = await get_team_members()
-for member in team:
-    expenses = await get_expenses(user_id=member['id'])`;
-
-      const filtered = filterToolsByUsage(allToolDefs, code);
-
-      expect(filtered).toHaveLength(2);
-      expect(filtered.map((t) => t.name).sort()).toEqual([
-        'get_expenses',
-        'get_team_members',
-      ]);
-    });
-
-    it('returns all tools when no tools are detected', () => {
-      const code = 'print("Hello, World!")';
-
-      const filtered = filterToolsByUsage(allToolDefs, code);
-
-      expect(filtered).toHaveLength(4);
-    });
-
-    it('preserves tool definition structure', () => {
-      const code = 'await calculator(expression="2+2")';
-
-      const filtered = filterToolsByUsage(allToolDefs, code);
-
-      expect(filtered).toHaveLength(1);
-      expect(filtered[0]).toEqual(allToolDefs[3]);
-      expect(filtered[0].parameters).toBeDefined();
-      expect(filtered[0].description).toBe('Evaluate an expression');
-    });
-
-    it('handles empty tool definitions', () => {
-      const code = 'await get_weather(city="SF")';
-      const filtered = filterToolsByUsage([], code);
-
-      expect(filtered).toHaveLength(0);
-    });
-  });
-
-  describe('formatCompletedResponse', () => {
-    it('formats response with stdout', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: 'Hello, World!\n',
-        stderr: '',
-        files: [],
-        session_id: 'sess_abc123',
-      };
-
-      const [output, artifact] = formatCompletedResponse(response);
-
-      expect(output).toContain('stdout:\nHello, World!');
-      expect(artifact.session_id).toBe('sess_abc123');
-      expect(artifact.files).toEqual([]);
-    });
-
-    it('shows empty output message when no stdout', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: '',
-        stderr: '',
-        files: [],
-        session_id: 'sess_abc123',
-      };
-
-      const [output] = formatCompletedResponse(response);
-
-      expect(output).toContain(
-        'stdout: Empty. Ensure you\'re writing output explicitly'
-      );
-    });
-
-    it('includes stderr when present', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: 'Output\n',
-        stderr: 'Warning: deprecated function\n',
-        files: [],
-        session_id: 'sess_abc123',
-      };
-
-      const [output] = formatCompletedResponse(response);
-
-      expect(output).toContain('stdout:\nOutput');
-      expect(output).toContain('stderr:\nWarning: deprecated function');
-    });
-
-    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',
-        stderr: '',
-        files: [
-          { id: '1', name: 'report.pdf' },
-          { id: '2', name: 'data.csv' },
-          { id: 'i1', name: 'pptx/SKILL.md', inherited: true },
-        ],
-        session_id: 'sess_abc123',
-      };
-
-      const [output, artifact] = formatCompletedResponse(response);
-
-      expect(output).toContain('stdout:\nGenerated report');
-      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');
-      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);
-    });
-
-    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', () => {
-    let ptcTool: ReturnType<typeof createProgrammaticToolCallingTool>;
-    let toolMap: t.ToolMap;
-    let toolDefinitions: t.LCTool[];
-
-    beforeEach(() => {
-      const tools = [
-        createGetTeamMembersTool(),
-        createGetExpensesTool(),
-        createGetWeatherTool(),
-      ];
-      toolMap = new Map(tools.map((t) => [t.name, t]));
-      toolDefinitions = Array.from(
-        createProgrammaticToolRegistry().values()
-      ).filter((t) =>
-        ['get_team_members', 'get_expenses', 'get_weather'].includes(t.name)
-      );
-
-      ptcTool = createProgrammaticToolCallingTool({
-        baseUrl: 'http://mock-api',
-      });
-    });
-
-    it('throws error when no toolMap provided', async () => {
-      await expect(
-        ptcTool.invoke({
-          code: 'result = await get_weather(city="SF")\nprint(result)',
-          tools: toolDefinitions,
-          toolMap,
-        })
-      ).rejects.toThrow('No toolMap provided');
-    });
-
-    it('throws error when toolMap is empty', async () => {
-      const args = {
-        code: 'result = await get_weather(city="SF")\nprint(result)',
-        tools: toolDefinitions,
-        toolMap: new Map(),
-      };
-      const toolCall = {
-        name: 'programmatic_tool_calling',
-        args,
-      };
-      await expect(
-        ptcTool.invoke(args, {
-          toolCall,
-        })
-      ).rejects.toThrow('No toolMap provided');
-    });
-
-    it('throws error when no tool definitions provided', async () => {
-      const args = {
-        code: 'result = await get_weather(city="SF")\nprint(result)',
-        // No tools
-      };
-      const toolCall = {
-        name: 'programmatic_code_execution',
-        args,
-        toolMap,
-        // No `toolDefs`
-      };
-
-      await expect(ptcTool.invoke(args, { toolCall })).rejects.toThrow(
-        'No tool definitions provided'
-      );
-    });
-
-    it('uses toolDefs from config when tools not provided', async () => {
-      // Skip this test - requires mocking fetch which has complex typing
-      // This functionality is tested in the live script tests instead
-    });
-  });
-
-  describe('Tool Classification', () => {
-    it('filters tools by allowed_callers', () => {
-      const registry = createProgrammaticToolRegistry();
-
-      const codeExecutionTools = Array.from(registry.values()).filter((t) =>
-        (t.allowed_callers ?? ['direct']).includes('code_execution')
-      );
-      // get_team_members, get_expenses, calculator: code_execution only
-      const codeOnlyTools = codeExecutionTools.filter(
-        (t) => !(t.allowed_callers?.includes('direct') === true)
-      );
-      expect(codeOnlyTools.length).toBeGreaterThanOrEqual(3);
-
-      // get_weather: both direct and code_execution
-      const bothTools = Array.from(registry.values()).filter(
-        (t) =>
-          t.allowed_callers?.includes('direct') === true &&
-          t.allowed_callers.includes('code_execution')
-      );
-      expect(bothTools.length).toBeGreaterThanOrEqual(1);
-      expect(bothTools.some((t) => t.name === 'get_weather')).toBe(true);
-    });
-  });
-
-  describe('Error Handling', () => {
-    let toolMap: t.ToolMap;
-
-    beforeEach(() => {
-      const tools = [createGetWeatherTool()];
-      toolMap = new Map(tools.map((t) => [t.name, t]));
-    });
-
-    it('returns error for invalid city without throwing', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'get_weather',
-          input: { city: 'InvalidCity' },
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results).toHaveLength(1);
-      expect(results[0].is_error).toBe(true);
-      expect(results[0].result).toBeNull();
-      expect(results[0].error_message).toContain('Weather data not available');
-    });
-
-    it('continues execution when one tool fails', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'get_weather',
-          input: { city: 'San Francisco' },
-        },
-        {
-          id: 'call_002',
-          name: 'get_weather',
-          input: { city: 'InvalidCity' },
-        },
-        {
-          id: 'call_003',
-          name: 'get_weather',
-          input: { city: 'London' },
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results).toHaveLength(3);
-      expect(results[0].is_error).toBe(false);
-      expect(results[1].is_error).toBe(true);
-      expect(results[2].is_error).toBe(false);
-    });
-  });
-
-  describe('Parallel Execution Performance', () => {
-    let toolMap: t.ToolMap;
-
-    beforeEach(() => {
-      const tools = [createGetExpensesTool()];
-      toolMap = new Map(tools.map((t) => [t.name, t]));
-    });
-
-    it('executes tools in parallel, not sequentially', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        { id: 'call_001', name: 'get_expenses', input: { user_id: 'u1' } },
-        { id: 'call_002', name: 'get_expenses', input: { user_id: 'u2' } },
-        { id: 'call_003', name: 'get_expenses', input: { user_id: 'u3' } },
-      ];
-
-      const startTime = Date.now();
-      const results = await executeTools(toolCalls, toolMap);
-      const duration = Date.now() - startTime;
-
-      // Each tool has 30ms delay
-      // Sequential would be ~90ms, parallel should be ~30-50ms
-      expect(duration).toBeLessThan(80);
-      expect(results).toHaveLength(3);
-      expect(results.every((r) => r.is_error === false)).toBe(true);
-    });
-  });
-
-  describe('Response Formatting', () => {
-    it('formats stdout-only response', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: 'Team size: 3\n- Alice\n- Bob\n- Charlie\n',
-        stderr: '',
-        files: [],
-        session_id: 'sess_xyz',
-      };
-
-      const [output, artifact] = formatCompletedResponse(response);
-
-      expect(output).toBe('stdout:\nTeam size: 3\n- Alice\n- Bob\n- Charlie');
-      expect(artifact).toEqual({
-        session_id: 'sess_xyz',
-        files: [],
-      });
-    });
-
-    it('summarizes files in output while keeping exact refs on the artifact', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: 'Report generated\n',
-        stderr: '',
-        files: [
-          { id: '1', name: 'report.csv' },
-          { id: '2', name: 'chart.png' },
-          { id: '3', name: 'file3.txt' },
-          { id: '4', name: 'file4.txt' },
-        ],
-        session_id: 'sess_xyz',
-      };
-
-      const [output, artifact] = formatCompletedResponse(response);
-
-      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(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', () => {
-    let toolMap: t.ToolMap;
-
-    beforeEach(() => {
-      const tools = [
-        createGetTeamMembersTool(),
-        createGetExpensesTool(),
-        createCalculatorTool(),
-      ];
-      toolMap = new Map(tools.map((t) => [t.name, t]));
-    });
-
-    it('extracts correct data from team members tool', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        { id: 'call_001', name: 'get_team_members', input: {} },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results[0].result).toEqual([
-        { id: 'u1', name: 'Alice', department: 'Engineering' },
-        { id: 'u2', name: 'Bob', department: 'Marketing' },
-        { id: 'u3', name: 'Charlie', department: 'Engineering' },
-      ]);
-    });
-
-    it('extracts correct data from expenses tool', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        { id: 'call_001', name: 'get_expenses', input: { user_id: 'u1' } },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results[0].result).toEqual([
-        { amount: 150.0, category: 'travel' },
-        { amount: 75.5, category: 'meals' },
-      ]);
-    });
-
-    it('handles empty expense data', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'get_expenses',
-          input: { user_id: 'nonexistent' },
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results[0].is_error).toBe(false);
-      expect(results[0].result).toEqual([]);
-    });
-
-    it('calculates correct result', async () => {
-      const toolCalls: t.PTCToolCall[] = [
-        {
-          id: 'call_001',
-          name: 'calculator',
-          input: { expression: '2 + 2 * 3' },
-        },
-        {
-          id: 'call_002',
-          name: 'calculator',
-          input: { expression: '(10 + 5) / 3' },
-        },
-      ];
-
-      const results = await executeTools(toolCalls, toolMap);
-
-      expect(results[0].result.result).toBe(8);
-      expect(results[1].result.result).toBe(5);
-    });
-  });
-
-  describe('bash bridge script does not require python3 (Codex P2 #19)', () => {
-    /* 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(
-        'echo hello',
-        [],
-        'http://127.0.0.1:9999/tool',
-        'test-token'
-      );
-      // Curl path must be present and gated by `command -v curl` so
-      // it's tried first on hosts that have it.
-      expect(script).toContain('command -v curl');
-      expect(script).toContain('curl -sS -X POST');
-      // Python3 must remain as a fallback (not removed).
-      expect(script).toContain('command -v python3');
-      expect(script).toContain('python3 - "$__LIBRECHAT_TOOL_BRIDGE"');
-      // Curl branch must come BEFORE python3 — bash `if/elif` order
-      // determines which helper is preferred. Pre-fix, python3 was
-      // unconditional and the bash bridge failed on python3-less
-      // hosts (minimal containers, some Windows setups).
-      expect(script.indexOf('command -v curl')).toBeLessThan(
-        script.indexOf('command -v python3')
-      );
-      // Curl uses the bridge's text-mode endpoint to skip JSON
-      // parsing on the bash side.
-      expect(script).toContain('?mode=text');
-      // Helpful error when neither helper is available.
-      expect(script).toContain('needs either curl or python3');
-    });
-  });
-
-  describe('bridge runs PreToolUse hooks for inner tool calls (manual finding A)', () => {
-    // The bridge spawned by `run_tools_with_code` / `run_tools_with_bash`
-    // used to call inner tools via `executeTools` directly, bypassing
-    // every PreToolUse hook the host registered. Manual review flagged
-    // this as a P1 bypass — `write_file` could be invoked from inside
-    // a programmatic block while the host's `write_file` deny policy
-    // never saw it. Now ToolNode threads a `hookContext` into the
-    // programmatic-tool factory; the bridge runs PreToolUse before
-    // each inner call, fail-closing on `deny`/`ask`.
-
-    it('honours `decision: deny` for inner tool calls invoked through the bridge', async () => {
-      const { tool } = await import('@langchain/core/tools');
-      const { z } = await import('zod');
-      const { HookRegistry } = await import('@/hooks');
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const ptcMod = require('../local/LocalProgrammaticToolCalling');
-
-      let callsMade = 0;
-      const writeFileTool = tool(
-        async () => {
-          callsMade += 1;
-          return 'wrote file';
-        },
-        {
-          name: 'write_file',
-          description: 'mock write tool',
-          schema: z.object({ path: z.string() }),
-        }
-      );
-      const toolMap = new Map([['write_file', writeFileTool]]);
-      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' };
-            }
-            return { decision: 'allow' };
-          },
-        ],
-      });
-
-      // Internal createToolBridge isn't exported, but exercising it via
-      // a synthetic HTTP request mirrors the real path. We use a tiny
-      // helper to access the (testing-internal) bridge factory.
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const http = require('http') as typeof import('http');
-
-      // Use the same internal factory the production path uses by
-      // invoking it through a direct-spawn substitute: capture the
-      // request handler by recreating the simplest possible call.
-      // Simpler: spin up a minimal duplicate and assert hook gating.
-      // (We can't easily test the production server without exposing
-      // it, but exporting `applyPreToolUseHooksForBridge` would also
-      // do the job — for this test we exercise the deny path through
-      // the public `executeTools` shortcut that the bridge uses.)
-      void ptcMod;
-      void toolMap;
-      void registry;
-      void callsMade;
-      void http;
-      // The minimum-viable assertion: registering a deny hook and
-      // sending a `write_file` request through the bridge results in
-      // the inner tool NOT being invoked. Implemented via the public
-      // `applyPreToolUseHooksForBridge` (added in this round) so we
-      // don't have to reach into the createServer closure.
-      const gate = await ptcMod.applyPreToolUseHooksForBridge(
-        { registry, runId: 'r1' },
-        'write_file',
-        'call_1',
-        { path: '/tmp/x' }
-      );
-      expect(gate.denyReason).toBeDefined();
-      expect(gate.denyReason).toContain('no writes from bridge');
-    });
-
-    it('threads executingAgentId from the hook context to bridge PreToolUse hooks', async () => {
-      const { HookRegistry } = await import('@/hooks');
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const ptcMod = require('../local/LocalProgrammaticToolCalling');
-      const registry = new HookRegistry();
-      let seen: string | undefined = 'UNSET';
-      registry.register('PreToolUse', {
-        hooks: [
-          // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-          async (input) => {
-            seen = input.executingAgentId;
-            return { decision: 'allow' };
-          },
-        ],
-      });
-      await ptcMod.applyPreToolUseHooksForBridge(
-        { registry, runId: 'r1', executingAgentId: 'repo_investigator' },
-        'write_file',
-        'call_1',
-        { path: '/tmp/x' }
-      );
-      expect(seen).toBe('repo_investigator');
-    });
-
-    it('passes through when no hook denies (allow path)', async () => {
-      const { HookRegistry } = await import('@/hooks');
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const ptcMod = require('../local/LocalProgrammaticToolCalling');
-
-      const registry = new HookRegistry();
-      registry.register('PreToolUse', {
-        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-        hooks: [async () => ({ decision: 'allow' })],
-      });
-
-      const gate = await ptcMod.applyPreToolUseHooksForBridge(
-        { registry, runId: 'r1' },
-        'read_file',
-        'call_1',
-        { path: '/tmp/x' }
-      );
-      expect(gate.denyReason).toBeUndefined();
-      expect(gate.input).toEqual({ path: '/tmp/x' });
-    });
-
-    it('applies updatedInput to the inner tool args', async () => {
-      const { HookRegistry } = await import('@/hooks');
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const ptcMod = require('../local/LocalProgrammaticToolCalling');
-
-      const registry = new HookRegistry();
-      registry.register('PreToolUse', {
-        hooks: [
-          // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-          async () => ({
-            decision: 'allow',
-            updatedInput: { path: '/tmp/rewritten' },
-          }),
-        ],
-      });
-
-      const gate = await ptcMod.applyPreToolUseHooksForBridge(
-        { registry, runId: 'r1' },
-        'read_file',
-        'call_1',
-        { path: '/tmp/original' }
-      );
-      expect(gate.denyReason).toBeUndefined();
-      expect(gate.input).toEqual({ path: '/tmp/rewritten' });
-    });
-
-    it('treats `ask` as fail-closed deny (HITL not reachable from bridge)', async () => {
-      const { HookRegistry } = await import('@/hooks');
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const ptcMod = require('../local/LocalProgrammaticToolCalling');
-
-      const registry = new HookRegistry();
-      registry.register('PreToolUse', {
-        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-        hooks: [async () => ({ decision: 'ask' })],
-      });
-
-      const gate = await ptcMod.applyPreToolUseHooksForBridge(
-        { registry, runId: 'r1' },
-        'edit_file',
-        'call_1',
-        {}
-      );
-      expect(gate.denyReason).toBeDefined();
-      expect(gate.denyReason).toMatch(/HITL|ask|approval|interrupt/i);
-    });
-  });
-});