@ai-sdk/harness-acp 1.0.38 → 1.0.39

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,