@ai-sdk/harness-acp 1.0.37 → 1.0.39

package/src/v1/bridge/host-tool-correlation.ts

@@ -2,6 +2,7 @@ import type {
   ActiveSessionMessage,
   ToolCallUpdate,
 } from '@agentclientprotocol/sdk';
+import type { ACPToolCall } from '../../acp-tool-call';
 
 type SessionUpdateMessage = Extract<
   ActiveSessionMessage,
@@ -55,6 +56,8 @@ export function createHostToolCorrelation({
     order: number;
   }): void;
   claimHostToolPermission(options: { toolCall: ToolCallUpdate }): boolean;
+  suppressToolCall(options: { toolCallId: string }): void;
+  getToolCall(options: { toolCallId: string }): ACPToolCall | undefined;
   flush(): void;
   removeInvocation(options: { token: string }): void;
   close(): void;
@@ -63,6 +66,7 @@ export function createHostToolCorrelation({
   const candidates = new Map<string, CorrelationCandidate>();
   const suppressedToolCallIds = new Set<string>();
   const releasedToolCallIds = new Set<string>();
+  const observedToolCalls = new Map<string, ACPToolCall>();
   let nextCandidateOrder = 0;
   let buffered: BufferedUpdate[] = [];
   let flushTimer: ReturnType<typeof setTimeout> | undefined;
@@ -155,6 +159,13 @@ export function createHostToolCorrelation({
       }
 
       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);
@@ -242,6 +253,8 @@ export function createHostToolCorrelation({
       suppressToolCallUpdate({ toolCallId: toolCall.toolCallId });
       return true;
     },
+    suppressToolCall: suppressToolCallUpdate,
+    getToolCall: ({ toolCallId }) => observedToolCalls.get(toolCallId),
     flush,
     removeInvocation: ({ token }) => {
       deleteInvocation({ invocations, token });
@@ -257,10 +270,31 @@ export function createHostToolCorrelation({
       candidates.clear();
       suppressedToolCallIds.clear();
       releasedToolCallIds.clear();
+      observedToolCalls.clear();
     },
   };
 }
 
+function mergeObservedToolCall({
+  previous,
+  update,
+}: {
+  previous: ACPToolCall | undefined;
+  update: ToolCallUpdate;
+}): ACPToolCall {
+  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 === undefined ? {} : { rawInput: update.rawInput }),
+    ...(update.rawOutput === undefined ? {} : { rawOutput: update.rawOutput }),
+    ...(update._meta === undefined ? {} : { _meta: update._meta }),
+  };
+}
+
 function hasPortableEvidence({
   candidate,
   invocation,

package/src/v1/bridge/index.ts

@@ -104,6 +104,13 @@ let coldRestorationMethod: ACPSessionRestorationMethod | undefined;
 let activePermissionController:
   | ReturnType<typeof createACPPermissionController>
   | undefined;
+let activeQuestionRequest:
+  | {
+      method: string;
+      turn: BridgeTurn;
+      emitStreamEvent: ReturnType<typeof createEmitStreamEvent>;
+    }
+  | undefined;
 
 await runBridge<StartMessage>({
   bridgeType,
@@ -252,15 +259,36 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   const emitStreamEvent = createEmitStreamEvent({
     emit: event => turn.emit(event as BridgeEvent),
     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,
@@ -353,6 +381,9 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       if (emitStreamEvent.message({ message })) return;
     }
   } finally {
+    if (activeQuestionRequest?.turn === turn) {
+      activeQuestionRequest = undefined;
+    }
     permissionController.cancelAll();
     activePermissionController = undefined;
     activeHostToolRelay.unbindTurn({ turn: relayTurn });
@@ -458,7 +489,7 @@ async function ensureSession({
     stream: acp.ndJsonStream(input, output),
   });
   streamCapture = capturedStream.capture;
-  connection = acp
+  let client = acp
     .client({ name: clientApp.name })
     .onRequest(
       acp.methods.client.session.requestPermission,
@@ -475,8 +506,58 @@ async function ensureSession({
         notification: params,
         update: params.update,
       });
-    })
-    .connect(capturedStream.stream);
+    });
+  if (bridgeConfiguration.askUserQuestionsRequestMethod != null) {
+    const method = bridgeConfiguration.askUserQuestionsRequestMethod;
+    client = client.onRequest<unknown, unknown>(
+      method,
+      value => value,
+      async ({ params }) => {
+        const active = activeQuestionRequest;
+        if (active == null || active.method !== method) {
+          throw acp.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,
+                  }) ?? undefined,
+              }),
+        });
+        const result = await active.turn.requestToolResult(requestId);
+        const classification = result.output as
+          | { type: 'unhandled' }
+          | { type: 'handled'; toolCallId: string }
+          | undefined;
+        if (classification?.type !== 'handled') {
+          throw acp.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 = client.connect(capturedStream.stream);
 
   const initializeRequest = createACPInitializeRequest({
     protocolVersion: acp.PROTOCOL_VERSION,
@@ -627,6 +708,19 @@ async function ensureSession({
   return { initialHostToolCatalogRefreshRequired: tools.length > 0 };
 }
 
+function getNativeQuestionToolCallId({
+  params,
+}: {
+  params: unknown;
+}): string | undefined {
+  if (!isRecord(params)) return undefined;
+  if (typeof params.toolCallId === 'string') return params.toolCallId;
+  const nestedParams = params.params;
+  return isRecord(nestedParams) && typeof nestedParams.toolCallId === 'string'
+    ? nestedParams.toolCallId
+    : undefined;
+}
+
 function createExternalMcpServers({
   mcpServers,
   initialization,

package/src/v1/bridge/stream-translator.ts

@@ -68,6 +68,7 @@ export function createACPStreamTranslator({
     output: unknown;
     isError?: boolean;
   }) => void;
+  getToolCall: (options: { toolCallId: string }) => ACPToolCall | undefined;
 } {
   let openBlock:
     | {
@@ -215,6 +216,7 @@ export function createACPStreamTranslator({
         builtinTools,
         builtinToolsByName,
       });
+      emitToolCallCandidate?.({ toolCall: createACPToolCall({ state }) });
       if (
         !forceEmit &&
         builtin?.inputSchema != null &&
@@ -238,7 +240,6 @@ export function createACPStreamTranslator({
           programmaticName,
           toolCallId: state.toolCallId,
         });
-        emitToolCallCandidate?.({ toolCall: createACPToolCall({ state }) });
       }
       emit({
         type: 'tool-call',
@@ -381,6 +382,10 @@ export function createACPStreamTranslator({
     close: closeBlock,
     hostToolCall,
     hostToolResult,
+    getToolCall: ({ toolCallId }) => {
+      const state = toolStates.get(toolCallId);
+      return state == null ? undefined : createACPToolCall({ state });
+    },
     finish: response => {
       if (finished) return;
       finished = true;

package/src/v1/index.ts

@@ -1,5 +1,6 @@
 export { createACPV1 } from './acp-v1-harness';
 export type {
+  ACPAskUserQuestionsSettings,
   ACPCredentialBrokering,
   ACPAuthentication,
   ACPAuthenticationMode,