Merge pull request #1542 from corbitsdev/cl-10856-gpt-shell-args-on-main

fix(agent): keep gpt shell arguments through dispatch

Author: TheGreatAxios

src/agent/tool-aliases.test.ts

@@ -191,6 +191,43 @@ describe("hidden alias dispatch", () => {
     expect(seen.timeout).toBe(5000);
   });
 
+  test("gpt shell keeps run_shell cwd, timeout, background, and stop", async () => {
+    let seen: Record<string, unknown> = {};
+    const runner = createDynamicToolRunner([
+      {
+        kind: "string",
+        definition: posixDef("run_shell"),
+        handler: async (args) => {
+          seen = args;
+          return "ok";
+        },
+      },
+    ]);
+    runner.setCallGate(() => true);
+    const result = await runner.run(
+      {
+        id: "1",
+        name: "shell",
+        arguments: {
+          command: "npm test",
+          cwd: "/tmp/proj",
+          timeout: 5000,
+          background: true,
+          stop: "sh_1",
+        },
+      },
+      new AbortController().signal,
+    );
+    expect(result.content).toBe("ok");
+    expect(seen).toEqual({
+      command: "npm test",
+      cwd: "/tmp/proj",
+      timeout: 5000,
+      background: true,
+      stop: "sh_1",
+    });
+  });
+
   test("update_plan hidden-dispatches onto manage_tasks; apply_patch does not", async () => {
     const runner = createDynamicToolRunner([
       {

src/agent/tool-aliases.ts

@@ -428,18 +428,16 @@ function incomingAlias(requested: string): string {
 }
 
 /** Coerce hidden Codex-shaped arguments onto the engine tool. Callers pass
- * the already-resolved engine. */
+ * the already-resolved engine. gpt advertises `shell` with run_shell's own
+ * arguments (`cwd`, `timeout`, `background`, `stop`); those pass through.
+ * Only Codex argv, `workdir`, and `timeout_ms` are rewritten. */
 export function prepareDispatchedToolCall(
   call: ToolCall,
   engine: string,
 ): ToolCall {
   const incoming = incomingAlias(call.name);
   let args = call.arguments;
-  if (
-    incoming === "shell" ||
-    incoming.toLowerCase() === "shell" ||
-    (engine === "run_shell" && looksLikeCodexShellArgs(args))
-  ) {
+  if (engine === "run_shell" && looksLikeCodexShellArgs(args)) {
     args = coerceShellArgs(args);
   }
   if (

src/permission/worker-grant-dispatch-identity.test.ts

@@ -1,8 +1,8 @@
-// gpt-family workers call run_shell as `shell`. Reactor authz sees that raw
-// wire call; the permission middleware sees DynamicToolRunner's
-// prepareDispatchedToolCall output, whose coerceShellArgs rebuilds the
-// arguments. The authorized retry must match the same envelope at both
-// stages.
+// gpt-family workers call run_shell as `shell` with run_shell's own
+// arguments. Reactor authz sees that raw wire call; the permission
+// middleware sees prepareDispatchedToolCall, which renames `shell` to
+// `run_shell` and leaves cwd, timeout, background, and stop in place.
+// The authorized retry must match the same envelope at both stages.
 import { describe, expect, test } from "bun:test";
 import type { ToolCall } from "@intx/types/runtime";
 
@@ -68,13 +68,21 @@ describe("gpt-family worker authorized retry identity", () => {
     expect(retryAuthz).toEqual({ effect: "allow" });
     expect(store.peek(requestId)?.status).toBe("authorized");
 
-    // 4. Retry, stage 2: DynamicToolRunner coerces the `shell` call onto
-    // run_shell, then the posix middleware runs gateToolCall.
+    // 4. Retry, stage 2: DynamicToolRunner renames `shell` onto run_shell
+    // and keeps the gpt-native arguments, then the posix middleware runs
+    // gateToolCall. The grant still matches the authorized envelope.
     const dispatched = prepareDispatchedToolCall(
       wireCall("call-2"),
       "run_shell",
     );
-    expect(dispatched.arguments).not.toEqual(wireCall("x").arguments);
+    expect(dispatched.name).toBe("run_shell");
+    expect(dispatched.arguments).toEqual(wireCall("x").arguments);
+    expect(dispatched.arguments).toMatchObject({
+      cwd: CWD,
+      timeout: 120000,
+      background: false,
+      stop: "",
+    });
 
     let executed = 0;
     const result = await gateToolCall(