@ai-sdk/harness-acp 1.0.37 → 1.0.39

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @ai-sdk/harness-acp
 
+## 1.0.39
+
+### Patch Changes
+
+- 951c54d: feat(harness): support `askUserQuestions` tool including support for normalization across harness adapters
+- Updated dependencies [951c54d]
+  - @ai-sdk/harness@1.0.101
+
+## 1.0.38
+
+### Patch Changes
+
+- 74d252a: fix(harness-acp): preserve terminal events replayed during ACP continuation startup
+- 0c37bf0: fix(harness): avoid warning about lack of credential brokering support when `credentialForwarding` callback is used to replace all credentials with ephemeral fake secrets
+- Updated dependencies [0c37bf0]
+  - @ai-sdk/harness@1.0.100
+
 ## 1.0.37
 
 ### Patch Changes

package/dist/bridge/host-tool-mcp.mjs

@@ -12,7 +12,7 @@ import {
   ListToolsRequestSchema,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-var VERSION = true ? "1.0.37" : "0.0.0-test";
+var VERSION = true ? "1.0.39" : "0.0.0-test";
 function createHostToolMCPServer({
   tools: tools2,
   revision = 1,

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;
       }
@@ -684,7 +714,8 @@ 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()
 });
 async function readACPBridgeEnvironment({
   env
@@ -1154,6 +1185,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 +1200,6 @@ function createACPStreamTranslator({
           programmaticName,
           toolCallId: state.toolCallId
         });
-        emitToolCallCandidate?.({ toolCall: createACPToolCall({ state }) });
       }
       emit({
         type: "tool-call",
@@ -1277,6 +1308,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;
@@ -1731,6 +1766,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 +1843,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 +1933,8 @@ function createHostToolCorrelation({
       suppressToolCallUpdate({ toolCallId: toolCall.toolCallId });
       return true;
     },
+    suppressToolCall: suppressToolCallUpdate,
+    getToolCall: ({ toolCallId }) => observedToolCalls.get(toolCallId),
     flush,
     removeInvocation: ({ token }) => {
       deleteInvocation({ invocations, token });
@@ -1905,9 +1950,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 +2280,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 })
   };
 }
 
@@ -3150,6 +3214,7 @@ var sessionConfigurationFailure;
 var historicalUpdatesSuppressed = false;
 var coldRestorationMethod;
 var activePermissionController;
+var activeQuestionRequest;
 await runBridge({
   bridgeType,
   bridgeStateDir,
@@ -3293,15 +3358,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 +3472,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 +3567,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 +3580,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,
@@ -3629,6 +3758,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