@librechat/agents 3.1.92 → 3.1.94

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

@@ -107,26 +107,105 @@ describe('Cloudflare sandbox execution backend', () => {
     expect(listPaths).toEqual(['/workspace']);
   });
 
-  it('aborts remote exec when the local timeout kills the spawn wrapper', async () => {
-    let signal: AbortSignal | undefined;
+  it('does not pass AbortSignal to Cloudflare spawn exec options', async () => {
+    let resolveExecCalled!: () => void;
+    const execCalled = new Promise<void>((resolve) => {
+      resolveExecCalled = resolve;
+    });
+    let receivedOptions: t.CloudflareSandboxExecOptions | undefined;
+    const sandbox = createRuntime({
+      exec: (_command, options) => {
+        receivedOptions = options;
+        resolveExecCalled();
+        return new Promise<t.CloudflareSandboxExecResult>(() => undefined);
+      },
+    });
+    const config = createCloudflareLocalExecutionConfig({
+      sandbox,
+      timeoutMs: 50,
+      workspaceRoot: '/workspace',
+    });
+
+    const resultPromise = spawnLocalProcess(
+      'bash',
+      ['-lc', 'sleep 10'],
+      config
+    );
+    await execCalled;
+    const result = await resultPromise;
+
+    expect(receivedOptions).not.toHaveProperty('signal');
+    expect(result.timedOut).toBe(true);
+    expect(result.exitCode).toBe(143);
+  });
+
+  it('passes AbortSignal to signal-aware runtimes and aborts it on kill', async () => {
+    let resolveExecCalled!: () => void;
+    const execCalled = new Promise<void>((resolve) => {
+      resolveExecCalled = resolve;
+    });
+    let receivedSignal: AbortSignal | undefined;
+    let abortEvents = 0;
     const sandbox = createRuntime({
-      exec: (_command, options) =>
-        new Promise<t.CloudflareSandboxExecResult>((_resolve, reject) => {
-          signal = options?.signal;
-          signal?.addEventListener('abort', () => reject(new Error('aborted')));
-        }),
+      supportsExecSignal: true,
+      exec: (_command, options) => {
+        receivedSignal = options?.signal;
+        receivedSignal?.addEventListener('abort', () => {
+          abortEvents += 1;
+        });
+        resolveExecCalled();
+        return new Promise<t.CloudflareSandboxExecResult>(() => undefined);
+      },
     });
     const config = createCloudflareLocalExecutionConfig({
       sandbox,
+      timeoutMs: 50,
+      workspaceRoot: '/workspace',
+    });
+
+    const resultPromise = spawnLocalProcess(
+      'bash',
+      ['-lc', 'sleep 10'],
+      config
+    );
+    await execCalled;
+    const result = await resultPromise;
+
+    expect(receivedSignal).toBeDefined();
+    expect(receivedSignal?.aborted).toBe(true);
+    expect(abortEvents).toBe(1);
+    expect(result.timedOut).toBe(true);
+    expect(result.exitCode).toBe(143);
+  });
+
+  it('does not start remote exec when killed before async sandbox resolution finishes', async () => {
+    let execCalls = 0;
+    let resolveSandbox!: (runtime: t.CloudflareSandboxRuntime) => void;
+    const sandboxPromise = new Promise<t.CloudflareSandboxRuntime>(
+      (resolve) => {
+        resolveSandbox = resolve;
+      }
+    );
+    const config = createCloudflareLocalExecutionConfig({
+      sandbox: () => sandboxPromise,
       timeoutMs: 10,
       workspaceRoot: '/workspace',
     });
 
     const result = await spawnLocalProcess('bash', ['-lc', 'sleep 10'], config);
+    resolveSandbox(
+      createRuntime({
+        exec: async () => {
+          execCalls += 1;
+          return { exitCode: 0, stdout: '', stderr: '' };
+        },
+      })
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
 
-    expect(signal?.aborted).toBe(true);
     expect(result.timedOut).toBe(true);
     expect(result.exitCode).toBe(143);
+    expect(execCalls).toBe(0);
   });
 
   it('memoizes sandbox factory results per config object', async () => {

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

@@ -86,6 +86,135 @@ describe('ProgrammaticToolCalling', () => {
       });
     });
 
+    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('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('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 }>

package/src/tools/cloudflare/CloudflareBridgeRuntime.ts

@@ -469,6 +469,7 @@ export function createCloudflareBridgeRuntime(
   }
 
   return {
+    supportsExecSignal: true,
     getSandboxId,
     exec,
     readFile,

package/src/tools/cloudflare/CloudflareSandboxExecutionEngine.ts

@@ -400,8 +400,8 @@ function createCloudflareSpawn(
   return (command, args, options) => {
     const stdout = new PassThrough();
     const stderr = new PassThrough();
-    const abortController = new AbortController();
     const child = new EventEmitter() as ChildProcessWithoutNullStreams;
+    const abortController = new AbortController();
     const state = { closed: false };
     const closeOnce = (
       exitCode: number | null,
@@ -451,13 +451,19 @@ function createCloudflareSpawn(
       const timedCommand = withInSandboxTimeout(rendered, timeoutMs);
       const cwd =
         options.cwd == null ? ctx.workspaceRoot : options.cwd.toString();
+      if (state.closed) {
+        return;
+      }
+      const execOptions: t.CloudflareSandboxExecOptions = {
+        cwd,
+        env: ctx.env,
+        timeout: outerTimeoutMs(timeoutMs),
+      };
+      if (ctx.sandbox.supportsExecSignal === true) {
+        execOptions.signal = abortController.signal;
+      }
       try {
-        const result = await ctx.sandbox.exec(timedCommand, {
-          cwd,
-          env: ctx.env,
-          timeout: outerTimeoutMs(timeoutMs),
-          signal: abortController.signal,
-        });
+        const result = await ctx.sandbox.exec(timedCommand, execOptions);
         if (state.closed) {
           return;
         }

package/src/types/tools.ts

@@ -853,6 +853,12 @@ export type CloudflareSandboxListFilesResult =
     };
 
 export interface CloudflareSandboxRuntime {
+  /**
+   * True when this runtime can consume AbortSignal values in exec options.
+   * Native Cloudflare Sandbox Durable Object RPC cannot clone AbortSignal,
+   * but HTTP bridge runtimes can use it to abort the underlying fetch.
+   */
+  supportsExecSignal?: boolean;
   exec(
     command: string,
     options?: CloudflareSandboxExecOptions
@@ -1019,9 +1025,9 @@ export type PTCToolCall = {
   id: string;
   /** Tool name */
   name: string;
-  /** Input parameters */
+  /** Input parameters. Some bridges may serialize object input as JSON text. */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  input: Record<string, any>;
+  input: Record<string, any> | string;
 };
 
 /**