@ai-sdk/harness-acp 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @ai-sdk/harness-acp
 
+## 1.0.2
+
+### Patch Changes
+
+- a03ff6c: feat(harness): add support for per-harness MCP servers
+- fc3baaf: feat(harness): add optional `mintBridgeToken(sandboxId)` to harness settings to control the bridge token value
+- Updated dependencies [401a4ba]
+- Updated dependencies [a03ff6c]
+  - @ai-sdk/provider-utils@5.0.26
+  - @ai-sdk/harness@1.0.65
+
+## 1.0.1
+
+### Patch Changes
+
+- 6f54e1d: feat(harness-acp): further simplify public `createACP()` API
+- 15d0475: fix(harness-acp): defer auth resolution until session start to correctly recognize available credentials
+- faaabb0: fix(harness-acp): improve bridge error handling to prevent infinite hang on certain errors
+- Updated dependencies [81cd026]
+  - @ai-sdk/provider-utils@5.0.25
+  - @ai-sdk/harness@1.0.64
+
 ## 1.0.0
 
 ### Major Changes

package/README.md

@@ -27,14 +27,13 @@ import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
 
 const codexACP = createACP({
   harnessId: 'acp-codex',
-  implementation: {
-    type: 'npm',
-    mode: 'simple',
+  source: {
+    type: 'npm-simple',
     packageName: '@agentclientprotocol/codex-acp',
-    version: '1.1.4',
-    executable: 'codex-acp',
-    forwardEnv: ['CODEX_API_KEY', 'OPENAI_API_KEY'],
+    packageVersion: '1.1.4',
   },
+  executable: 'codex-acp',
+  forwardEnv: ['CODEX_API_KEY', 'OPENAI_API_KEY'],
   permissionModeMapping: {
     'allow-reads': null,
     'allow-edits': null,

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

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

package/dist/bridge/index.mjs

@@ -820,10 +820,25 @@ function createACPBridgeError({
   stage,
   cause
 }) {
-  const error = new Error(`ACP ${stage} failed.`);
+  const causeMessage = getErrorMessage({ error: cause });
+  const error = new Error(
+    causeMessage == null ? `ACP ${stage} failed.` : `ACP ${stage} failed: ${causeMessage}`
+  );
   error.cause = cause;
   return error;
 }
+function getErrorMessage({ error }) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error != null && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return void 0;
+}
 function stripMetadata({ value }) {
   if (Array.isArray(value)) {
     return value.map((item) => stripMetadata({ value: item }));
@@ -836,9 +851,46 @@ function stripMetadata({ value }) {
   return result;
 }
 
+// src/v1/bridge/agent-stderr-monitor.ts
+import { stripVTControlCharacters } from "util";
+function monitorACPAgentStderr({
+  stderr,
+  onStderrLine
+}) {
+  let rejectFailure;
+  const failure = new Promise((_, reject) => {
+    rejectFailure = reject;
+  });
+  void failure.catch(() => {
+  });
+  void (async () => {
+    stderr.setEncoding("utf8");
+    let pending = "";
+    for await (const chunk of stderr) {
+      pending += chunk;
+      const lines = pending.split("\n");
+      pending = lines.pop() ?? "";
+      for (const line of lines) handleStderrLine({ line });
+    }
+    if (pending.length > 0) handleStderrLine({ line: pending });
+  })().catch((error) => rejectFailure(error));
+  return failure;
+  function handleStderrLine({ line }) {
+    if (line.length === 0) return;
+    onStderrLine(line);
+    const normalizedLine = stripVTControlCharacters(line);
+    if (normalizedLine.toLowerCase().includes("failed to deserialize responsestreamevent from stream")) {
+      rejectFailure(
+        new Error("ACP agent failed to deserialize a streamed response.")
+      );
+    }
+  }
+}
+
 // src/v1/bridge/stream-translator.ts
 function createACPStreamTranslator({
   emit,
+  emitToolCallCandidate,
   builtinTools = []
 }) {
   let openBlock;
@@ -949,13 +1001,12 @@ function createACPStreamTranslator({
       if (builtin != null) {
         state.toolName = builtin.toolName;
         state.nativeName = builtin.nativeName != null && builtin.toolName !== builtin.nativeName ? builtin.nativeName : void 0;
-        state.dynamic = false;
       } else {
         state.toolName = createDynamicToolName({
           programmaticName,
           toolCallId: state.toolCallId
         });
-        state.dynamic = true;
+        emitToolCallCandidate?.({ toolCall: createACPToolCall({ state }) });
       }
       emit({
         type: "tool-call",
@@ -963,7 +1014,6 @@ function createACPStreamTranslator({
         toolName: state.toolName,
         input: stringifyToolInput({ input: state.values.rawInput }),
         providerExecuted: true,
-        ...state.dynamic ? { dynamic: true } : {},
         ...state.nativeName == null ? {} : { nativeName: state.nativeName }
       });
       state.emittedCall = true;
@@ -978,8 +1028,7 @@ function createACPStreamTranslator({
         toolCallId: state.toolCallId,
         toolName: state.toolName,
         result: createToolResult({ state }),
-        ...state.values.status === "failed" ? { isError: true } : {},
-        ...state.dynamic ? { dynamic: true } : {}
+        ...state.values.status === "failed" ? { isError: true } : {}
       });
       state.emittedResult = true;
       pendingToolCallIds.delete(state.toolCallId);
@@ -1294,6 +1343,31 @@ function mergeToolUpdate({
   });
   if (programmaticName != null) state.values.name = programmaticName;
 }
+function createACPToolCall({ state }) {
+  const title = getStringProperty2({
+    value: state.values,
+    property: "title"
+  });
+  const kind = state.values.kind;
+  const status = state.values.status;
+  return {
+    toolCallId: state.toolCallId,
+    title: title ?? state.toolName ?? `Tool ${state.toolCallId}`,
+    ...isACPToolKind(kind) ? { kind } : {},
+    ...isACPToolCallStatus(status) ? { status } : {},
+    ...Array.isArray(state.values.content) ? { content: state.values.content } : {},
+    ...Array.isArray(state.values.locations) ? { locations: state.values.locations } : {},
+    ...Object.prototype.hasOwnProperty.call(state.values, "rawInput") ? { rawInput: state.values.rawInput } : {},
+    ...Object.prototype.hasOwnProperty.call(state.values, "rawOutput") ? { rawOutput: state.values.rawOutput } : {},
+    ...state.values._meta === null || isRecord3(state.values._meta) ? { _meta: state.values._meta } : {}
+  };
+}
+function isACPToolKind(value) {
+  return value === "read" || value === "edit" || value === "delete" || value === "move" || value === "search" || value === "execute" || value === "think" || value === "fetch" || value === "switch_mode" || value === "other";
+}
+function isACPToolCallStatus(value) {
+  return value === "pending" || value === "in_progress" || value === "completed" || value === "failed";
+}
 function emitFileChanges({
   state,
   emit
@@ -1895,11 +1969,16 @@ function isTerminalToolUpdate(message) {
 // src/v1/bridge/create-emit-stream-event.ts
 function createEmitStreamEvent({
   emit,
+  emitToolCallCandidate,
   builtinTools,
   hostToolServerName,
   hostTools
 }) {
-  const translator = createACPStreamTranslator({ emit, builtinTools });
+  const translator = createACPStreamTranslator({
+    emit,
+    emitToolCallCandidate,
+    builtinTools
+  });
   const correlation = createHostToolCorrelation({
     emitSemanticUpdate: ({ message, rawUpdate }) => {
       translator.update({
@@ -2713,6 +2792,7 @@ var implementation = await readImplementationDescriptor({
 });
 var bridgeConfiguration = await readACPBridgeEnvironment({ env: processEnv });
 var child;
+var agentResponseStreamFailure;
 var connection;
 var session;
 var recoveredSessionUpdates;
@@ -2767,6 +2847,12 @@ async function runTurn(start, turn) {
   if (activeSession == null) {
     throw new Error("ACP session initialization did not produce a session.");
   }
+  const activeAgentResponseStreamFailure = agentResponseStreamFailure;
+  if (activeAgentResponseStreamFailure == null) {
+    throw new Error(
+      "ACP session initialization did not start stderr monitoring."
+    );
+  }
   if (start.recoveryMode?.type === "lossy-rerun") {
     const marker = {
       type: "acp-recovery",
@@ -2848,6 +2934,12 @@ async function runTurn(start, turn) {
   turn.emit({ type: "stream-start" });
   const emitStreamEvent = createEmitStreamEvent({
     emit: (event) => turn.emit(event),
+    emitToolCallCandidate: ({ toolCall }) => {
+      turn.emit({
+        type: "acp-tool-call-candidate",
+        toolCall
+      });
+    },
     builtinTools: start.builtinTools,
     hostToolServerName: HOST_TOOL_MCP_SERVER_NAME,
     hostTools: start.tools ?? []
@@ -2883,7 +2975,8 @@ async function runTurn(start, turn) {
       try {
         message = await Promise.race([
           activeSession.nextUpdate(),
-          cancellationFailure
+          cancellationFailure,
+          activeAgentResponseStreamFailure
         ]);
       } catch (error) {
         for (const rawValue of streamCapture?.drainRawValues() ?? []) {
@@ -2932,7 +3025,8 @@ async function ensureSession({
     providerAuthentication: bridgeConfiguration.providerAuthentication,
     sessionMeta: bridgeConfiguration.sessionMeta,
     permissionMode: start.permissionMode,
-    permissionModeMapping: start.permissionModeMapping
+    permissionModeMapping: start.permissionModeMapping,
+    mcpServers: start.mcpServers
   });
   if (session != null) {
     if (catalogRefreshError != null) throw catalogRefreshError;
@@ -2977,7 +3071,16 @@ async function ensureSession({
       stdio: ["pipe", "pipe", "pipe"]
     }
   );
-  forwardAgentStderr({ child, turn });
+  agentResponseStreamFailure = monitorACPAgentStderr({
+    stderr: child.stderr,
+    onStderrLine: (line) => {
+      turn.bridgeLog({
+        level: "warn",
+        subsystem: "acp.agent.stderr",
+        message: line
+      });
+    }
+  });
   const input = Writable.toWeb(child.stdin);
   const output = Readable.toWeb(child.stdout);
   const capturedStream = captureACPStream({
@@ -3020,6 +3123,10 @@ async function ensureSession({
       authentication
     });
   }
+  const externalMcpServers = createExternalMcpServers({
+    mcpServers: start.mcpServers,
+    initialization
+  });
   const tools = start.tools ?? [];
   const catalogPath = `${bridgeStateDir}/host-tools.json`;
   await writeFile2(catalogPath, JSON.stringify(tools), { mode: 384 });
@@ -3028,6 +3135,7 @@ async function ensureSession({
     serverName: HOST_TOOL_MCP_SERVER_NAME
   });
   const mcpServers = [
+    ...externalMcpServers,
     {
       name: HOST_TOOL_MCP_SERVER_NAME,
       command: process.execPath,
@@ -3129,6 +3237,33 @@ async function ensureSession({
   });
   sessionConfigurationFingerprint = fingerprint;
 }
+function createExternalMcpServers({
+  mcpServers,
+  initialization
+}) {
+  if (mcpServers == null) return [];
+  return Object.entries(mcpServers).map(([name2, value]) => {
+    if (!isRecord6(value)) {
+      throw new Error(
+        `ACP MCP server ${JSON.stringify(name2)} must be configured with an object value.`
+      );
+    }
+    if (value.type === "acp") {
+      throw new HarnessBridgeCapabilityUnsupportedError({
+        harnessId: bridgeType,
+        message: "ACP-transport MCP servers require client-side mcp/connect handling, which this harness does not provide."
+      });
+    }
+    const mcpCapabilities = initialization.agentCapabilities?.mcpCapabilities;
+    if (value.type === "http" && mcpCapabilities?.http !== true || value.type === "sse" && mcpCapabilities?.sse !== true) {
+      throw new HarnessBridgeCapabilityUnsupportedError({
+        harnessId: bridgeType,
+        message: `The ACP agent does not advertise support for ${value.type.toUpperCase()} MCP servers.`
+      });
+    }
+    return { ...value, name: name2 };
+  });
+}
 function unknownUsage2() {
   return {
     inputTokens: {
@@ -3207,35 +3342,6 @@ function createChildEnvironment({
 function isRecord6(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
-function forwardAgentStderr({
-  child: child2,
-  turn
-}) {
-  void (async () => {
-    child2.stderr.setEncoding("utf8");
-    let pending = "";
-    for await (const chunk of child2.stderr) {
-      pending += chunk;
-      const lines = pending.split("\n");
-      pending = lines.pop() ?? "";
-      for (const line of lines) {
-        if (line.length === 0) continue;
-        turn.bridgeLog({
-          level: "warn",
-          subsystem: "acp.agent.stderr",
-          message: line
-        });
-      }
-    }
-    if (pending.length > 0) {
-      turn.bridgeLog({
-        level: "warn",
-        subsystem: "acp.agent.stderr",
-        message: pending
-      });
-    }
-  })();
-}
 async function readImplementationDescriptor({
   path
 }) {