@ai-sdk/harness-acp 1.0.38 → 1.0.40

package/dist/bridge/index.mjs

@@ -230,6 +230,7 @@ async function runBridge(options) {
     }
   }
   const pendingToolResults = /* @__PURE__ */ new Map();
+  const bufferedToolResults = [];
   const pendingToolApprovals = /* @__PURE__ */ new Map();
   const writeBridgeMeta = async (state) => {
     try {
@@ -409,9 +410,23 @@ async function runBridge(options) {
         const userMessages = createBridgeUserMessageQueue({ respond: emit });
         const turn = {
           emit,
-          requestToolResult: (toolCallId) => new Promise((resolve) => {
-            pendingToolResults.set(toolCallId, resolve);
-          }),
+          requestToolResult: (requestInput) => {
+            const request = typeof requestInput === "string" ? { toolCallId: requestInput } : requestInput;
+            const bufferedIndex = bufferedToolResults.findIndex(
+              (buffered) => buffered.toolCallId === request.toolCallId || request.matches?.(buffered.result) === true
+            );
+            if (bufferedIndex >= 0) {
+              return Promise.resolve(
+                bufferedToolResults.splice(bufferedIndex, 1)[0].result
+              );
+            }
+            return new Promise((resolve) => {
+              pendingToolResults.set(request.toolCallId, {
+                resolve,
+                matches: request.matches
+              });
+            });
+          },
           requestToolApproval: (approvalId) => new Promise((resolve) => {
             pendingToolApprovals.set(approvalId, resolve);
           }),
@@ -453,10 +468,25 @@ async function runBridge(options) {
         return;
       }
       case "tool-result": {
-        const resolver = pendingToolResults.get(msg.toolCallId);
-        if (resolver) {
-          pendingToolResults.delete(msg.toolCallId);
-          resolver({ output: msg.output, isError: msg.isError });
+        const result = {
+          output: msg.output,
+          isError: msg.isError,
+          toolResult: msg.toolResult
+        };
+        const exactPending = pendingToolResults.get(msg.toolCallId);
+        const matchingPending = exactPending == null ? Array.from(pendingToolResults.entries()).find(
+          ([, pending2]) => pending2.matches?.(result) === true
+        ) : void 0;
+        const pending = exactPending ?? matchingPending?.[1];
+        const pendingId = exactPending != null ? msg.toolCallId : matchingPending?.[0];
+        if (pending != null && pendingId != null) {
+          pendingToolResults.delete(pendingId);
+          pending.resolve(result);
+        } else {
+          bufferedToolResults.push({
+            toolCallId: msg.toolCallId,
+            result
+          });
         }
         return;
       }
@@ -634,7 +664,6 @@ function serialiseError(err) {
 import * as acp5 from "@agentclientprotocol/sdk";
 import { spawn } from "child_process";
 import { readFile, writeFile as writeFile2 } from "fs/promises";
-import { fileURLToPath } from "url";
 import { Readable, Writable } from "stream";
 import { argv, env as processEnv } from "process";
 
@@ -665,6 +694,10 @@ var profileValueSchema = z.lazy(
     z.record(z.string(), profileValueSchema)
   ])
 );
+var hostToolMcpTransportSchema = z.enum([
+  "stdio",
+  "http"
+]);
 var serializableRecordSchema = z.record(z.string(), serializableValueSchema);
 var profileRecordSchema = z.record(z.string(), profileValueSchema);
 var authenticationSchema = z.object({
@@ -684,7 +717,9 @@ var bridgeConfigurationSchema = z.object({
   providerAuthentication: providerAuthenticationSchema.optional(),
   providerEnvironment: z.record(z.string(), z.string()).optional(),
   sessionMeta: serializableRecordSchema.optional(),
-  clientCapabilities: serializableRecordSchema.optional()
+  clientCapabilities: serializableRecordSchema.optional(),
+  askUserQuestionsRequestMethod: z.string().optional(),
+  hostToolMcpTransport: hostToolMcpTransportSchema.optional()
 });
 async function readACPBridgeEnvironment({
   env
@@ -1154,6 +1189,7 @@ function createACPStreamTranslator({
         builtinTools,
         builtinToolsByName
       });
+      emitToolCallCandidate?.({ toolCall: createACPToolCall({ state }) });
       if (!forceEmit && builtin?.inputSchema != null && state.values.status !== "completed" && state.values.status !== "failed" && !hasRequiredBuiltinToolInput({
         rawInput: state.values.rawInput,
         inputSchema: builtin.inputSchema
@@ -1168,7 +1204,6 @@ function createACPStreamTranslator({
           programmaticName,
           toolCallId: state.toolCallId
         });
-        emitToolCallCandidate?.({ toolCall: createACPToolCall({ state }) });
       }
       emit({
         type: "tool-call",
@@ -1277,6 +1312,10 @@ function createACPStreamTranslator({
     close: closeBlock,
     hostToolCall,
     hostToolResult,
+    getToolCall: ({ toolCallId }) => {
+      const state = toolStates.get(toolCallId);
+      return state == null ? void 0 : createACPToolCall({ state });
+    },
     finish: (response) => {
       if (finished) return;
       finished = true;
@@ -1382,7 +1421,24 @@ function resolveBuiltinTool({
   const schemaMatches = builtinTools.filter(
     (tool) => matchesBuiltinToolInput({ rawInput, inputSchema: tool.inputSchema })
   );
-  return schemaMatches.length === 1 ? schemaMatches[0] : void 0;
+  if (schemaMatches.length <= 1) return schemaMatches[0];
+  return findMostSpecificSchemaMatch({ rawInput, schemaMatches });
+}
+function findMostSpecificSchemaMatch({
+  rawInput,
+  schemaMatches
+}) {
+  if (!isRecord3(rawInput)) return void 0;
+  const rawInputKeys = Object.keys(rawInput);
+  const coverageOf = (tool) => {
+    const properties = isRecord3(tool.inputSchema) ? isRecord3(tool.inputSchema.properties) ? tool.inputSchema.properties : {} : {};
+    return rawInputKeys.filter((key) => key in properties).length;
+  };
+  const highestCoverage = Math.max(...schemaMatches.map(coverageOf));
+  const mostSpecificMatches = schemaMatches.filter(
+    (tool) => coverageOf(tool) === highestCoverage
+  );
+  return mostSpecificMatches.length === 1 ? mostSpecificMatches[0] : void 0;
 }
 function findBuiltinToolByTitle({
   title,
@@ -1731,6 +1787,7 @@ function createHostToolCorrelation({
   const candidates = /* @__PURE__ */ new Map();
   const suppressedToolCallIds = /* @__PURE__ */ new Set();
   const releasedToolCallIds = /* @__PURE__ */ new Set();
+  const observedToolCalls = /* @__PURE__ */ new Map();
   let nextCandidateOrder = 0;
   let buffered = [];
   let flushTimer;
@@ -1807,6 +1864,13 @@ function createHostToolCorrelation({
         return;
       }
       const toolCallId = message.update.toolCallId;
+      observedToolCalls.set(
+        toolCallId,
+        mergeObservedToolCall({
+          previous: observedToolCalls.get(toolCallId),
+          update: message.update
+        })
+      );
       if (suppressedToolCallIds.has(toolCallId)) {
         if (isTerminalToolUpdate(message)) {
           suppressedToolCallIds.delete(toolCallId);
@@ -1890,6 +1954,8 @@ function createHostToolCorrelation({
       suppressToolCallUpdate({ toolCallId: toolCall.toolCallId });
       return true;
     },
+    suppressToolCall: suppressToolCallUpdate,
+    getToolCall: ({ toolCallId }) => observedToolCalls.get(toolCallId),
     flush,
     removeInvocation: ({ token }) => {
       deleteInvocation({ invocations, token });
@@ -1905,9 +1971,26 @@ function createHostToolCorrelation({
       candidates.clear();
       suppressedToolCallIds.clear();
       releasedToolCallIds.clear();
+      observedToolCalls.clear();
     }
   };
 }
+function mergeObservedToolCall({
+  previous,
+  update
+}) {
+  return {
+    toolCallId: update.toolCallId,
+    title: update.title ?? previous?.title ?? `Tool ${update.toolCallId}`,
+    ...update.kind == null ? {} : { kind: update.kind },
+    ...update.status == null ? {} : { status: update.status },
+    ...update.content == null ? {} : { content: update.content },
+    ...update.locations == null ? {} : { locations: update.locations },
+    ...update.rawInput === void 0 ? {} : { rawInput: update.rawInput },
+    ...update.rawOutput === void 0 ? {} : { rawOutput: update.rawOutput },
+    ...update._meta === void 0 ? {} : { _meta: update._meta }
+  };
+}
 function hasPortableEvidence({
   candidate,
   invocation
@@ -2218,7 +2301,9 @@ function createEmitStreamEvent({
     hostToolCall: translator.hostToolCall,
     hostToolResult: translator.hostToolResult,
     registerHostToolCorrelationInvocation: correlation.registerInvocation,
-    removeHostToolCorrelationInvocation: correlation.removeInvocation
+    removeHostToolCorrelationInvocation: correlation.removeInvocation,
+    suppressToolCall: correlation.suppressToolCall,
+    getToolCall: ({ toolCallId }) => correlation.getToolCall({ toolCallId }) ?? translator.getToolCall({ toolCallId })
   };
 }
 
@@ -2236,6 +2321,14 @@ async function resolveACPInstructionConfiguration({
   if (instructionMapping == null || instructions == null || instructions.length === 0) {
     return { sessionMeta, environment: resolvedEnvironment };
   }
+  if (instructionMapping.type === "filesystem") {
+    if (typeof instructionMapping.path !== "string" || instructionMapping.path.trim().length === 0) {
+      throw new Error(
+        "ACP instruction mapping filesystem path must be a non-empty string."
+      );
+    }
+    return { sessionMeta, environment: resolvedEnvironment };
+  }
   assertSafePath({ path: instructionMapping.path });
   if (instructionMapping.type === "session-meta") {
     return {
@@ -2307,11 +2400,263 @@ function isRecord5(value) {
 }
 
 // src/v1/bridge/host-tool-relay.ts
-import { randomBytes, timingSafeEqual } from "crypto";
+import { randomBytes, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
 import { createServer } from "http";
+
+// src/v1/bridge/host-tool-mcp-http.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+
+// src/v1/bridge/host-tool-mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError
+} from "@modelcontextprotocol/sdk/types.js";
+var VERSION = true ? "1.0.40" : "0.0.0-test";
+function createHostToolMCPServer({
+  tools,
+  revision = 1,
+  invoke,
+  onListTools
+}) {
+  let catalog = createCatalog({ revision, tools });
+  let catalogAcknowledgmentError;
+  const server = new Server(
+    {
+      name: "@ai-sdk/harness-acp-host-tools",
+      version: VERSION
+    },
+    { capabilities: { tools: { listChanged: true } } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    if (catalogAcknowledgmentError != null) {
+      throw catalogAcknowledgmentError;
+    }
+    const current = catalog;
+    if (onListTools != null) {
+      setImmediate(() => {
+        void onListTools({ revision: current.revision }).catch((error) => {
+          catalogAcknowledgmentError = error;
+        });
+      });
+    }
+    return { tools: current.tools.map(toMCPTool) };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const current = catalog;
+    const tool = current.byName.get(request.params.name);
+    if (tool == null) {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        `Unknown host tool: ${request.params.name}`
+      );
+    }
+    const input = request.params.arguments ?? {};
+    const result = await invoke({
+      toolName: tool.name,
+      input,
+      catalogRevision: current.revision
+    });
+    return toCallToolResult({ result });
+  });
+  return {
+    server,
+    updateCatalog: async ({ revision: nextRevision, tools: nextTools }) => {
+      catalog = createCatalog({
+        revision: nextRevision,
+        tools: nextTools
+      });
+      await server.sendToolListChanged();
+    }
+  };
+}
+function createCatalog({
+  revision,
+  tools
+}) {
+  return {
+    revision,
+    tools: [...tools],
+    byName: new Map(tools.map((tool) => [tool.name, tool]))
+  };
+}
+function toMCPTool(tool) {
+  return {
+    name: tool.name,
+    ...tool.description == null ? {} : { description: tool.description },
+    inputSchema: requireObjectSchema({
+      toolName: tool.name,
+      schema: tool.inputSchema ?? { type: "object" }
+    })
+  };
+}
+function requireObjectSchema({
+  toolName,
+  schema
+}) {
+  if (schema == null || typeof schema !== "object" || Array.isArray(schema) || Reflect.get(schema, "type") !== void 0 && Reflect.get(schema, "type") !== "object") {
+    throw new Error(
+      `Host tool ${toolName} must use an object JSON Schema for MCP.`
+    );
+  }
+  return schema;
+}
+function toCallToolResult({
+  result
+}) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: stringifyOutput({ output: result.output })
+      }
+    ],
+    ...result.isError ? { isError: true } : {},
+    _meta: {
+      "ai-sdk-harness-acp-correlation": result.correlationToken
+    }
+  };
+}
+function stringifyOutput({ output }) {
+  if (output === void 0) return "null";
+  try {
+    return JSON.stringify(output);
+  } catch {
+    return JSON.stringify({
+      error: "Host tool output could not be serialized as JSON."
+    });
+  }
+}
+
+// src/v1/bridge/host-tool-mcp-http.ts
+var HOST_TOOL_MCP_ENDPOINT_PATH = "/mcp";
+function createHostToolMCPHttpEndpoint({
+  tools,
+  revision,
+  invoke,
+  onListTools
+}) {
+  let catalog = { revision, tools: [...tools] };
+  const sessions = /* @__PURE__ */ new Map();
+  let closed = false;
+  async function openSession({
+    request,
+    response,
+    body
+  }) {
+    const hostToolServer = createHostToolMCPServer({
+      tools: catalog.tools,
+      revision: catalog.revision,
+      invoke,
+      onListTools
+    });
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID2(),
+      onsessioninitialized: (sessionId) => {
+        sessions.set(sessionId, { transport, hostToolServer });
+      },
+      onsessionclosed: (sessionId) => {
+        sessions.delete(sessionId);
+      }
+    });
+    transport.onclose = () => {
+      const { sessionId } = transport;
+      if (sessionId != null) sessions.delete(sessionId);
+    };
+    await hostToolServer.server.connect(transport);
+    await transport.handleRequest(request, response, body);
+  }
+  return {
+    handleRequest: async ({ request, response, body }) => {
+      if (closed) {
+        respondWithJSONRPCError({
+          response,
+          status: 503,
+          code: -32e3,
+          message: "The host tool MCP endpoint is closed."
+        });
+        return;
+      }
+      const sessionId = readSessionId({ request });
+      if (sessionId != null) {
+        const session2 = sessions.get(sessionId);
+        if (session2 == null) {
+          respondWithJSONRPCError({
+            response,
+            status: 404,
+            code: -32001,
+            message: "Unknown host tool MCP session."
+          });
+          return;
+        }
+        await session2.transport.handleRequest(request, response, body);
+        return;
+      }
+      if (request.method !== "POST" || !isInitializeRequest(body)) {
+        respondWithJSONRPCError({
+          response,
+          status: 400,
+          code: -32e3,
+          message: "Host tool MCP requests without a session id must be an initialize request."
+        });
+        return;
+      }
+      await openSession({ request, response, body });
+    },
+    updateCatalog: async ({ revision: nextRevision, tools: nextTools }) => {
+      catalog = { revision: nextRevision, tools: [...nextTools] };
+      await Promise.all(
+        [...sessions.values()].map(
+          (session2) => session2.hostToolServer.updateCatalog({
+            revision: nextRevision,
+            tools: nextTools
+          })
+        )
+      );
+    },
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      const live = [...sessions.values()];
+      sessions.clear();
+      await Promise.all(
+        live.map((session2) => session2.hostToolServer.server.close())
+      );
+    }
+  };
+}
+function readSessionId({
+  request
+}) {
+  const value = request.headers["mcp-session-id"];
+  const sessionId = Array.isArray(value) ? value[0] : value;
+  return sessionId == null || sessionId.length === 0 ? void 0 : sessionId;
+}
+function respondWithJSONRPCError({
+  response,
+  status,
+  code,
+  message
+}) {
+  response.writeHead(status, { "content-type": "application/json" });
+  response.end(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      error: { code, message },
+      id: null
+    })
+  );
+}
+
+// src/v1/bridge/host-tool-relay.ts
 async function startHostToolRelay({
   tools,
-  serverName
+  serverName,
+  mcpTransport = "stdio"
 }) {
   const state = {
     tools: [...tools],
@@ -2326,8 +2671,44 @@ async function startHostToolRelay({
   let activeTurn;
   let invocationOrder = 0;
   let closePromise;
+  const mcpEndpoint = mcpTransport === "http" ? createHostToolMCPHttpEndpoint({
+    tools: state.tools,
+    revision: state.revision,
+    invoke: ({ toolName, input, catalogRevision }) => handleInvocation({
+      body: {
+        requestId: randomUUID3(),
+        toolName,
+        input,
+        catalogRevision
+      },
+      state,
+      serverName,
+      turn: activeTurn,
+      nextInvocationOrder: () => ++invocationOrder
+    }),
+    onListTools: async ({ revision }) => {
+      acknowledgeCatalog({ state, revision });
+    }
+  }) : void 0;
   const server = createServer(async (request, response) => {
     try {
+      if (mcpEndpoint != null && request.url === HOST_TOOL_MCP_ENDPOINT_PATH) {
+        if (!credentialsMatch({
+          expected: credential,
+          actual: request.headers.authorization
+        })) {
+          throw new RelayRequestError({
+            status: 401,
+            message: "Invalid host tool relay credential."
+          });
+        }
+        await mcpEndpoint.handleRequest({
+          request,
+          response,
+          ...request.method === "POST" ? { body: await readJSONBody({ request }) } : {}
+        });
+        return;
+      }
       const result = await handleRequest({
         request,
         credential,
@@ -2339,6 +2720,10 @@ async function startHostToolRelay({
       response.writeHead(200, { "content-type": "application/json" });
       response.end(JSON.stringify(result));
     } catch (error) {
+      if (response.headersSent) {
+        response.end();
+        return;
+      }
       const status = error instanceof RelayRequestError ? error.status : 500;
       response.writeHead(status, { "content-type": "application/json" });
       response.end(
@@ -2352,6 +2737,9 @@ async function startHostToolRelay({
   const address = server.address();
   return {
     url: `http://127.0.0.1:${address.port}/invoke`,
+    ...mcpEndpoint == null ? {} : {
+      mcpUrl: `http://127.0.0.1:${address.port}${HOST_TOOL_MCP_ENDPOINT_PATH}`
+    },
     credential,
     bindTurn: ({ turn }) => {
       if (activeTurn != null && activeTurn !== turn) {
@@ -2371,6 +2759,10 @@ async function startHostToolRelay({
       state.fingerprint = fingerprint;
       state.revision += 1;
       resolveCatalogChanges({ state });
+      void mcpEndpoint?.updateCatalog({
+        revision: state.revision,
+        tools: state.tools
+      });
       return { changed: true, revision: state.revision };
     },
     waitForCatalogRefresh: ({ revision, timeoutMs }) => waitForCatalogRefresh({ state, revision, timeoutMs }),
@@ -2379,7 +2771,10 @@ async function startHostToolRelay({
       state.closed = true;
       resolveCatalogChanges({ state });
       resolveRefreshWaiters({ state, closing: true });
-      closePromise = closeServer({ server });
+      closePromise = (async () => {
+        await mcpEndpoint?.close();
+        await closeServer({ server });
+      })();
       return closePromise;
     }
   };
@@ -2457,13 +2852,16 @@ function handleCatalogSeen({
       message: "Invalid host tool catalog acknowledgment."
     });
   }
-  state.servedRevision = Math.max(
-    state.servedRevision,
-    body.revision
-  );
-  resolveRefreshWaiters({ state, closing: false });
+  acknowledgeCatalog({ state, revision: body.revision });
   return { acknowledged: true };
 }
+function acknowledgeCatalog({
+  state,
+  revision
+}) {
+  state.servedRevision = Math.max(state.servedRevision, revision);
+  resolveRefreshWaiters({ state, closing: false });
+}
 async function handleInvocation({
   body,
   state,
@@ -2662,6 +3060,55 @@ var RelayRequestError = class extends Error {
   }
 };
 
+// src/v1/bridge/host-tool-mcp-definition.ts
+import { fileURLToPath } from "url";
+import { execPath } from "process";
+function createHostToolMcpServerDefinition({
+  mcpTransport,
+  relay,
+  serverName,
+  catalogPath,
+  initialization,
+  harnessId
+}) {
+  if (mcpTransport === "stdio") {
+    return {
+      name: serverName,
+      command: execPath,
+      args: [fileURLToPath(new URL("./host-tool-mcp.mjs", import.meta.url))],
+      env: [
+        {
+          name: "AI_SDK_ACP_HOST_TOOLS_FILE",
+          value: catalogPath
+        },
+        {
+          name: "AI_SDK_ACP_HOST_TOOL_RELAY_URL",
+          value: relay.url
+        },
+        {
+          name: "AI_SDK_ACP_HOST_TOOL_RELAY_CREDENTIAL",
+          value: relay.credential
+        }
+      ]
+    };
+  }
+  if (initialization.agentCapabilities?.mcpCapabilities?.http !== true) {
+    throw new HarnessBridgeCapabilityUnsupportedError({
+      harnessId,
+      message: "This harness exposes host tools through an HTTP MCP server, but the ACP agent does not advertise support for HTTP MCP servers."
+    });
+  }
+  if (relay.mcpUrl == null) {
+    throw new Error("The host tool MCP HTTP endpoint is unavailable.");
+  }
+  return {
+    type: "http",
+    name: serverName,
+    url: relay.mcpUrl,
+    headers: [{ name: "Authorization", value: `Bearer ${relay.credential}` }]
+  };
+}
+
 // src/v1/bridge/refresh-host-tool-catalog.ts
 async function promptAndRefreshInitialHostToolCatalog({
   startPrompt,
@@ -3150,6 +3597,7 @@ var sessionConfigurationFailure;
 var historicalUpdatesSuppressed = false;
 var coldRestorationMethod;
 var activePermissionController;
+var activeQuestionRequest;
 await runBridge({
   bridgeType,
   bridgeStateDir,
@@ -3293,15 +3741,31 @@ async function runTurn(start, turn) {
   const emitStreamEvent = createEmitStreamEvent({
     emit: (event) => turn.emit(event),
     emitToolCallCandidate: ({ toolCall }) => {
+      const requestId = crypto.randomUUID();
       turn.emit({
         type: "acp-tool-call-candidate",
+        requestId,
         toolCall
       });
+      void turn.requestToolResult(requestId).then((result) => {
+        if (result.output != null && typeof result.output === "object" && "suppress" in result.output && result.output.suppress === true) {
+          emitStreamEvent.suppressToolCall({
+            toolCallId: toolCall.toolCallId
+          });
+        }
+      });
     },
     builtinTools: start.builtinTools,
     hostToolServerName: HOST_TOOL_MCP_SERVER_NAME,
     hostTools: start.tools ?? []
   });
+  if (bridgeConfiguration.askUserQuestionsRequestMethod != null) {
+    activeQuestionRequest = {
+      method: bridgeConfiguration.askUserQuestionsRequestMethod,
+      turn,
+      emitStreamEvent
+    };
+  }
   const permissionController = createACPPermissionController({
     turn,
     sessionId: activeSession.sessionId,
@@ -3391,6 +3855,9 @@ async function runTurn(start, turn) {
       if (emitStreamEvent.message({ message })) return;
     }
   } finally {
+    if (activeQuestionRequest?.turn === turn) {
+      activeQuestionRequest = void 0;
+    }
     permissionController.cancelAll();
     activePermissionController = void 0;
     activeHostToolRelay.unbindTurn({ turn: relayTurn });
@@ -3483,7 +3950,7 @@ async function ensureSession({
     stream: acp5.ndJsonStream(input, output)
   });
   streamCapture = capturedStream.capture;
-  connection = acp5.client({ name: clientApp.name }).onRequest(
+  let client2 = acp5.client({ name: clientApp.name }).onRequest(
     acp5.methods.client.session.requestPermission,
     ({ params }) => activePermissionController?.requestPermission(params) ?? {
       outcome: { outcome: "cancelled" }
@@ -3496,7 +3963,52 @@ async function ensureSession({
       notification: params,
       update: params.update
     });
-  }).connect(capturedStream.stream);
+  });
+  if (bridgeConfiguration.askUserQuestionsRequestMethod != null) {
+    const method = bridgeConfiguration.askUserQuestionsRequestMethod;
+    client2 = client2.onRequest(
+      method,
+      (value) => value,
+      async ({ params }) => {
+        const active = activeQuestionRequest;
+        if (active == null || active.method !== method) {
+          throw acp5.RequestError.methodNotFound(method);
+        }
+        const requestId = crypto.randomUUID();
+        const nativeToolCallId = getNativeQuestionToolCallId({ params });
+        active.turn.emit({
+          type: "acp-question-request",
+          requestId,
+          nativeRequest: params,
+          ...nativeToolCallId == null ? {} : {
+            nativeToolCall: active.emitStreamEvent.getToolCall({
+              toolCallId: nativeToolCallId
+            }) ?? void 0
+          }
+        });
+        const result = await active.turn.requestToolResult(requestId);
+        const classification = result.output;
+        if (classification?.type !== "handled") {
+          throw acp5.RequestError.methodNotFound(method);
+        }
+        active.emitStreamEvent.suppressToolCall({
+          toolCallId: nativeToolCallId ?? classification.toolCallId
+        });
+        try {
+          const nativeResult = await active.turn.requestToolResult(
+            classification.toolCallId
+          );
+          return nativeResult.output;
+        } finally {
+          active.turn.emit({
+            type: "acp-question-resolved",
+            requestId
+          });
+        }
+      }
+    );
+  }
+  connection = client2.connect(capturedStream.stream);
   const initializeRequest = createACPInitializeRequest({
     protocolVersion: acp5.PROTOCOL_VERSION,
     clientApp,
@@ -3525,33 +4037,26 @@ async function ensureSession({
     initialization
   });
   const tools = start.tools ?? [];
+  const mcpTransport = bridgeConfiguration.hostToolMcpTransport ?? "stdio";
   const catalogPath = `${bridgeStateDir}/host-tools.json`;
-  await writeFile2(catalogPath, JSON.stringify(tools), { mode: 384 });
+  if (mcpTransport === "stdio") {
+    await writeFile2(catalogPath, JSON.stringify(tools), { mode: 384 });
+  }
   hostToolRelay = await startHostToolRelay({
     tools,
-    serverName: HOST_TOOL_MCP_SERVER_NAME
+    serverName: HOST_TOOL_MCP_SERVER_NAME,
+    mcpTransport
   });
   const mcpServers = [
     ...externalMcpServers,
-    {
-      name: HOST_TOOL_MCP_SERVER_NAME,
-      command: process.execPath,
-      args: [fileURLToPath(new URL("./host-tool-mcp.mjs", import.meta.url))],
-      env: [
-        {
-          name: "AI_SDK_ACP_HOST_TOOLS_FILE",
-          value: catalogPath
-        },
-        {
-          name: "AI_SDK_ACP_HOST_TOOL_RELAY_URL",
-          value: hostToolRelay.url
-        },
-        {
-          name: "AI_SDK_ACP_HOST_TOOL_RELAY_CREDENTIAL",
-          value: hostToolRelay.credential
-        }
-      ]
-    }
+    createHostToolMcpServerDefinition({
+      mcpTransport,
+      relay: hostToolRelay,
+      serverName: HOST_TOOL_MCP_SERVER_NAME,
+      catalogPath,
+      initialization,
+      harnessId: bridgeType
+    })
   ];
   let createdSession;
   if (start.recoveryMode?.type === "lossy-rerun") {
@@ -3629,6 +4134,14 @@ async function ensureSession({
   sessionConfigurationFingerprint = fingerprint;
   return { initialHostToolCatalogRefreshRequired: tools.length > 0 };
 }
+function getNativeQuestionToolCallId({
+  params
+}) {
+  if (!isRecord7(params)) return void 0;
+  if (typeof params.toolCallId === "string") return params.toolCallId;
+  const nestedParams = params.params;
+  return isRecord7(nestedParams) && typeof nestedParams.toolCallId === "string" ? nestedParams.toolCallId : void 0;
+}
 function createExternalMcpServers({
   mcpServers,
   initialization