test(mcp): preserve optional arguments through promotion

Author: TheGreatAxios

tests/integration/harness.ts

@@ -27,11 +27,15 @@ import type {
   ContextTransform,
   ContextStore,
   InferenceSource,
+  ToolDefinition,
 } from "@intx/types/runtime";
 import { type } from "arktype";
 
 import { createAgentWithLiveToolDispatch } from "../../src/agent/live-tool-dispatch.js";
-import { createChatDirector } from "../../src/agent/director.js";
+import {
+  createChatDirector,
+  type ChatDirector,
+} from "../../src/agent/director.js";
 import { OPERATOR_ORIGINATED_FLAG } from "../../src/agent/message-provenance.js";
 import {
   readSourceCredentialMaterial,
@@ -82,6 +86,7 @@ export interface IntegrationSession {
   workdir: string;
   agent: Agent;
   toolset: Awaited<ReturnType<typeof createAgentToolset>>;
+  updateToolDefinitions: (definitions: ToolDefinition[]) => void;
 }
 
 export interface OpenIntegrationSessionOpts {
@@ -114,6 +119,9 @@ export async function openIntegrationSession(
   const storageHolder: { current: ContextStore | undefined } = {
     current: undefined,
   };
+  const directorHolder: { current: ChatDirector | undefined } = {
+    current: undefined,
+  };
 
   const toolset = await createAgentToolset({
     cwd,
@@ -140,6 +148,7 @@ export async function openIntegrationSession(
         },
       );
       d.setClearDenials(() => opts.permissionGate.clearDenials());
+      directorHolder.current = d;
       return d;
     },
   });
@@ -262,7 +271,22 @@ export async function openIntegrationSession(
       ? innerAgent
       : createPrimaryDeliveryAdmission(innerAgent, primaryArchive);
 
-  return { harness, cwd, workdir, agent, toolset, storage: storageForAgent };
+  const updateToolDefinitions = (definitions: ToolDefinition[]): void => {
+    const director = directorHolder.current;
+    if (director === undefined)
+      throw new Error("chat director is not available");
+    director.updateToolDefinitions(definitions);
+  };
+
+  return {
+    harness,
+    cwd,
+    workdir,
+    agent,
+    toolset,
+    storage: storageForAgent,
+    updateToolDefinitions,
+  };
 }
 
 export async function closeIntegrationSession(

tests/integration/mcp-late-dispatch.test.ts

@@ -3,6 +3,8 @@ import { createAgent } from "@intx/agent";
 import type { ReactorEmittedEvent } from "@intx/inference";
 
 import { createAgentWithLiveToolDispatch } from "../../src/agent/live-tool-dispatch.js";
+import type { MCPClient } from "../../src/mcp/client.js";
+import { mcpClientTools } from "../../src/mcp/plugin.js";
 import { createPermissionGate } from "../../src/permission/gate.js";
 import {
   closeIntegrationSession,
@@ -11,6 +13,20 @@ import {
 } from "./harness.js";
 
 const LATE_MCP = "mcp__linear__list_issues";
+const LATE_MCP_SCHEMA = {
+  type: "object" as const,
+  properties: {
+    limit: { type: "integer" },
+    team: { type: "string" },
+  },
+};
+
+interface AnthropicRequestBody {
+  tools?: {
+    name: string;
+    input_schema: Record<string, unknown>;
+  }[];
+}
 
 function permissionGate() {
   return createPermissionGate({
@@ -21,20 +37,27 @@ function permissionGate() {
   });
 }
 
-function lateMcpTool() {
-  return {
-    kind: "string" as const,
-    definition: {
-      name: LATE_MCP,
-      description: "list issues",
-      inputSchema: {
-        type: "object" as const,
-        properties: {},
-        required: [] as string[],
+function lateMcpTools(
+  onCall?: (toolName: string, args: Record<string, unknown>) => void,
+) {
+  const client: MCPClient = {
+    serverName: "linear",
+    tools: [
+      {
+        name: "list_issues",
+        description: "list issues",
+        inputSchema: LATE_MCP_SCHEMA,
       },
+    ],
+    async call(toolName, args) {
+      onCall?.(toolName, args);
+      return "ISSUE-1";
+    },
+    async close() {
+      return undefined;
     },
-    handler: async () => "ISSUE-1",
   };
+  return mcpClientTools(client);
 }
 
 function toolDoneContents(events: ReactorEmittedEvent[]): string[] {
@@ -62,7 +85,7 @@ describe("integration — late MCP dispatch", () => {
       });
 
       try {
-        session.toolset.dynamicRunner.addTools([lateMcpTool()]);
+        session.toolset.dynamicRunner.addTools(lateMcpTools());
         session.harness.scenario.replyOnce("anthropic", {
           toolCalls: [{ name: LATE_MCP, args: {} }],
         });
@@ -89,7 +112,7 @@ describe("integration — late MCP dispatch", () => {
       });
 
       try {
-        session.toolset.dynamicRunner.addTools([lateMcpTool()]);
+        session.toolset.dynamicRunner.addTools(lateMcpTools());
         session.harness.scenario.replyOnce("anthropic", {
           toolCalls: [{ name: LATE_MCP, args: {} }],
         });
@@ -106,4 +129,66 @@ describe("integration — late MCP dispatch", () => {
       }
     },
   );
+
+  test.serial(
+    "tool_search promotion preserves optional MCP arguments",
+    async () => {
+      const session = await openIntegrationSession({
+        permissionGate: permissionGate(),
+        createAgentFn: createAgentWithLiveToolDispatch,
+      });
+      let receivedArgs: Record<string, unknown> | undefined;
+
+      try {
+        const tools = lateMcpTools((toolName, args) => {
+          if (toolName === "list_issues") {
+            receivedArgs = args;
+          }
+        });
+        expect(tools).toHaveLength(1);
+        expect(tools[0]?.kind).toBe("full");
+        session.toolset.dynamicRunner.addTools(tools);
+        session.toolset.setToolPromoter(() => {
+          session.updateToolDefinitions(
+            session.toolset.dynamicRunner.currentDefinitions(),
+          );
+        });
+        session.harness.scenario.replyOnce("anthropic", {
+          toolCalls: [
+            { name: "tool_search", args: { query: "linear list issues" } },
+          ],
+        });
+        session.harness.scenario.replyOnce("anthropic", {
+          toolCalls: [{ name: LATE_MCP, args: { limit: 1 } }],
+        });
+        session.harness.scenario.replyOnce("anthropic", { text: "listed" });
+
+        const { events } = await runUntilDone(session, "list one linear issue");
+        const bodies = await Promise.all(
+          session.harness.scenario
+            .matchedRequests()
+            .map(
+              async (request) =>
+                JSON.parse(
+                  await (request.clone() as unknown as Request).text(),
+                ) as AnthropicRequestBody,
+            ),
+        );
+        const publishedTool = bodies
+          .flatMap((body) => body.tools ?? [])
+          .find((tool) => tool.name === LATE_MCP);
+
+        expect(publishedTool?.input_schema.properties).toEqual(
+          LATE_MCP_SCHEMA.properties,
+        );
+        expect(
+          Object.hasOwn(publishedTool?.input_schema ?? {}, "required"),
+        ).toBe(false);
+        expect(receivedArgs).toEqual({ limit: 1 });
+        expect(toolDoneContents(events)).toContain("ISSUE-1");
+      } finally {
+        await closeIntegrationSession(session);
+      }
+    },
+  );
 });