@ai-sdk/harness-acp 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-acp",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -27,8 +27,8 @@
   },
   "dependencies": {
     "ws": "^8.21.0",
-    "@ai-sdk/harness": "1.0.64",
-    "@ai-sdk/provider-utils": "5.0.25"
+    "@ai-sdk/harness": "1.0.65",
+    "@ai-sdk/provider-utils": "5.0.26"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"

package/src/acp-harness.ts

@@ -2,6 +2,7 @@ import type { HarnessV1 } from '@ai-sdk/harness';
 import type { ToolSet } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import type { ACPClientApp } from './acp-auth';
+import type { ACPToolCall } from './acp-tool-call';
 import { createACPV1, type ACPV1Settings } from './v1';
 import {
   acpColdSessionStateSchema,
@@ -16,6 +17,12 @@ const ACP_CLIENT_APP = {
 
 export type ACPHarnessSettings<TBuiltinTools extends ToolSet = {}> = {
   readonly builtinTools?: TBuiltinTools;
+  /**
+   * MCP server definitions keyed by server name. Each definition uses the
+   * underlying runtime's native MCP server configuration format.
+   */
+  readonly mcpServers?: Record<string, unknown>;
+  readonly isMcpToolCall?: (toolCall: ACPToolCall) => boolean;
   readonly port?: number;
   readonly startupTimeoutMs?: number;
   readonly clientApp?: ACPClientApp;
@@ -32,6 +39,7 @@ export type ACPHarnessSettings<TBuiltinTools extends ToolSet = {}> = {
   readonly modelId?: ACPV1Settings['modelId'];
   readonly permissionModeMapping?: ACPV1Settings['permissionModeMapping'];
   readonly session?: ACPV1Settings['session'];
+  readonly mintBridgeToken?: ACPV1Settings['mintBridgeToken'];
 };
 
 const ACP_BUILTIN_TOOLS = {} as const satisfies ToolSet;
@@ -85,6 +93,17 @@ const acpResumeStateSchema = z.object({
 export function createACP<TBuiltinTools extends ToolSet = {}>(
   settings: ACPHarnessSettings<TBuiltinTools>,
 ): HarnessV1<TBuiltinTools> {
+  if (
+    settings.mcpServers != null &&
+    Object.prototype.hasOwnProperty.call(
+      settings.mcpServers,
+      'ai-sdk-harness-tools',
+    )
+  ) {
+    throw new Error(
+      'ACP MCP server name "ai-sdk-harness-tools" is reserved for HarnessAgent tools.',
+    );
+  }
   const version = (settings as { readonly version?: string }).version ?? 'v1';
   switch (version) {
     case 'v1': {

package/src/acp-tool-call.ts

@@ -0,0 +1,124 @@
+export type ACPMetadata = Record<string, unknown>;
+
+export type ACPRole = 'assistant' | 'user';
+
+export type ACPAnnotations = {
+  audience?: Array<ACPRole> | null;
+  lastModified?: string | null;
+  priority?: number | null;
+  _meta?: ACPMetadata | null;
+};
+
+export type ACPTextContent = {
+  annotations?: ACPAnnotations | null;
+  text: string;
+  _meta?: ACPMetadata | null;
+};
+
+export type ACPImageContent = {
+  annotations?: ACPAnnotations | null;
+  data: string;
+  mimeType: string;
+  uri?: string | null;
+  _meta?: ACPMetadata | null;
+};
+
+export type ACPAudioContent = {
+  annotations?: ACPAnnotations | null;
+  data: string;
+  mimeType: string;
+  _meta?: ACPMetadata | null;
+};
+
+export type ACPResourceLink = {
+  annotations?: ACPAnnotations | null;
+  description?: string | null;
+  mimeType?: string | null;
+  name: string;
+  size?: number | null;
+  title?: string | null;
+  uri: string;
+  _meta?: ACPMetadata | null;
+};
+
+export type ACPTextResourceContents = {
+  mimeType?: string | null;
+  text: string;
+  uri: string;
+  _meta?: ACPMetadata | null;
+};
+
+export type ACPBlobResourceContents = {
+  blob: string;
+  mimeType?: string | null;
+  uri: string;
+  _meta?: ACPMetadata | null;
+};
+
+export type ACPEmbeddedResource = {
+  annotations?: ACPAnnotations | null;
+  resource: ACPTextResourceContents | ACPBlobResourceContents;
+  _meta?: ACPMetadata | null;
+};
+
+export type ACPContentBlock =
+  | (ACPTextContent & { type: 'text' })
+  | (ACPImageContent & { type: 'image' })
+  | (ACPAudioContent & { type: 'audio' })
+  | (ACPResourceLink & { type: 'resource_link' })
+  | (ACPEmbeddedResource & { type: 'resource' });
+
+export type ACPToolCallContent =
+  | {
+      type: 'content';
+      content: ACPContentBlock;
+      _meta?: ACPMetadata | null;
+    }
+  | {
+      type: 'diff';
+      path: string;
+      oldText?: string | null;
+      newText: string;
+      _meta?: ACPMetadata | null;
+    }
+  | {
+      type: 'terminal';
+      terminalId: string;
+      _meta?: ACPMetadata | null;
+    };
+
+export type ACPToolKind =
+  | 'read'
+  | 'edit'
+  | 'delete'
+  | 'move'
+  | 'search'
+  | 'execute'
+  | 'think'
+  | 'fetch'
+  | 'switch_mode'
+  | 'other';
+
+export type ACPToolCallStatus =
+  | 'pending'
+  | 'in_progress'
+  | 'completed'
+  | 'failed';
+
+export type ACPToolCallLocation = {
+  path: string;
+  line?: number | null;
+  _meta?: ACPMetadata | null;
+};
+
+export type ACPToolCall = {
+  toolCallId: string;
+  title: string;
+  kind?: ACPToolKind;
+  status?: ACPToolCallStatus;
+  content?: Array<ACPToolCallContent>;
+  locations?: Array<ACPToolCallLocation>;
+  rawInput?: unknown;
+  rawOutput?: unknown;
+  _meta?: ACPMetadata | null;
+};

package/src/index.ts

@@ -1,6 +1,24 @@
 export { createACP } from './acp-harness';
 export type { ACPAuthOptions, ACPClientApp } from './acp-auth';
 export type { ACPHarnessSettings } from './acp-harness';
+export type {
+  ACPAnnotations,
+  ACPAudioContent,
+  ACPBlobResourceContents,
+  ACPContentBlock,
+  ACPEmbeddedResource,
+  ACPImageContent,
+  ACPMetadata,
+  ACPResourceLink,
+  ACPRole,
+  ACPTextContent,
+  ACPTextResourceContents,
+  ACPToolCall,
+  ACPToolCallContent,
+  ACPToolCallLocation,
+  ACPToolCallStatus,
+  ACPToolKind,
+} from './acp-tool-call';
 export type {
   ACPAuthentication,
   ACPNpmLockedSource,

package/src/v1/acp-v1-bridge-protocol.ts

@@ -11,6 +11,7 @@ import {
   type HarnessV1ToolSpec,
 } from '@ai-sdk/harness';
 import { z } from 'zod/v4';
+import type { ACPToolCall } from '../acp-tool-call';
 import type { ACPPermissionModeMapping } from './acp-v1-settings';
 import { acpTextContentBlockSchema } from './acp-v1-prompt';
 
@@ -126,11 +127,26 @@ const coldRestoreSchema = z.object({
   acpSessionId: z.string(),
 });
 
-export const outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+const acpToolCallCandidateSchema = z.object({
+  type: z.literal('acp-tool-call-candidate'),
+  toolCall: z.custom<ACPToolCall>(
+    value =>
+      value != null &&
+      typeof value === 'object' &&
+      typeof (value as { toolCallId?: unknown }).toolCallId === 'string' &&
+      typeof (value as { title?: unknown }).title === 'string',
+  ),
+});
+
+export const outboundMessageSchema = z.union([
+  harnessV1BridgeOutboundMessageSchema,
+  acpToolCallCandidateSchema,
+]);
 export type OutboundMessage = z.infer<typeof outboundMessageSchema>;
 
 export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
   prompt: z.array(acpTextContentBlockSchema),
+  mcpServers: z.record(z.string(), z.unknown()).optional(),
   tools: z.array(acpSerializableToolSpecSchema).optional(),
   builtinTools: z.array(builtinToolSchema).readonly().default([]),
   permissionModeMapping: permissionModeMappingSchema.optional(),

package/src/v1/acp-v1-harness.ts

@@ -40,6 +40,7 @@ import {
   type ACPAuthenticationProfileIdentity,
   type ACPClientApp,
 } from '../acp-auth';
+import type { ACPToolCall } from '../acp-tool-call';
 import {
   createACPV1Implementation,
   createImplementationDescriptor,
@@ -126,6 +127,17 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
     HarnessV1<TBuiltinTools>['lifecycleStateSchema']
   >;
 }): HarnessV1<TBuiltinTools> {
+  if (
+    settings.mcpServers != null &&
+    Object.prototype.hasOwnProperty.call(
+      settings.mcpServers,
+      'ai-sdk-harness-tools',
+    )
+  ) {
+    throw new Error(
+      'ACP MCP server name "ai-sdk-harness-tools" is reserved for HarnessAgent tools.',
+    );
+  }
   if (!HARNESS_ID_REGEXP.test(settings.harnessId)) {
     throw new Error(
       `ACP harnessId must be a stable kebab-case identifier; received ${JSON.stringify(settings.harnessId)}.`,
@@ -370,6 +382,8 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
               builtinTools: builtinToolCatalog,
               permissionMode,
               permissionModeMapping,
+              mcpServers: settings.mcpServers,
+              isMcpToolCall: settings.isMcpToolCall,
               initialGuidanceApplied: resolveACPInitialGuidanceApplied({
                 isResume: true,
                 lifecycleState: lifecycleData,
@@ -421,6 +435,7 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
                   sessionMeta: settings.session?.meta,
                   builtinTools: builtinToolCatalog,
                   permissionModeMapping,
+                  mcpServers: settings.mcpServers,
                 });
                 respawnStrategy = {
                   mode: 'lossy-rerun',
@@ -450,6 +465,7 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
             sessionMeta: settings.session?.meta,
             builtinTools: builtinToolCatalog,
             permissionModeMapping,
+            mcpServers: settings.mcpServers,
             debug: startOptions.observability?.debug,
           });
           respawnStrategy = {
@@ -465,7 +481,10 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
         override: portOverride,
         harnessId: settings.harnessId,
       });
-      const token = randomBytes(32).toString('hex');
+      const token =
+        settings.mintBridgeToken == null
+          ? randomBytes(32).toString('hex')
+          : settings.mintBridgeToken(sandboxSession.id);
       await sandbox.run({
         command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)}`,
         abortSignal: startOptions.abortSignal,
@@ -570,6 +589,9 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
               builtinTools: builtinToolCatalog,
               permissionMode,
               permissionModeMapping,
+              ...(settings.mcpServers == null
+                ? {}
+                : { mcpServers: settings.mcpServers }),
               tools: respawnStrategy.turnStartConfig.tools,
               turnStartConfig: respawnStrategy.turnStartConfig,
               recoveryMode: {
@@ -606,6 +628,8 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
         builtinTools: builtinToolCatalog,
         permissionMode,
         permissionModeMapping,
+        mcpServers: settings.mcpServers,
+        isMcpToolCall: settings.isMcpToolCall,
         initialGuidanceApplied: resolveACPInitialGuidanceApplied({
           isResume,
           lifecycleState: lifecycleData,
@@ -807,6 +831,8 @@ function createSession({
   builtinTools,
   permissionMode,
   permissionModeMapping,
+  mcpServers,
+  isMcpToolCall,
   initialGuidanceApplied: initialGuidanceAppliedAtStart,
   skillCatalog,
   skillsFingerprint,
@@ -835,6 +861,8 @@ function createSession({
   builtinTools: ReadonlyArray<ACPBuiltinToolMapping>;
   permissionMode: NonNullable<StartMessage['permissionMode']>;
   permissionModeMapping: StartMessage['permissionModeMapping'];
+  mcpServers: Record<string, unknown> | undefined;
+  isMcpToolCall: ((toolCall: ACPToolCall) => boolean) | undefined;
   initialGuidanceApplied: boolean;
   skillCatalog: ReadonlyArray<ACPSkillCatalogEntry>;
   skillsFingerprint: string;
@@ -889,6 +917,8 @@ function createSession({
     let openBlock:
       | { readonly type: 'text' | 'reasoning'; readonly id: string }
       | undefined;
+    const dynamicToolCalls = new Map<string, boolean>();
+    const toolCallClassificationErrors = new Map<string, unknown>();
     const subscriptions: Array<() => void> = [];
     const forward = (event: HarnessV1StreamPart) => {
       if (event.type === 'text-start' || event.type === 'reasoning-start') {
@@ -923,9 +953,7 @@ function createSession({
       'reasoning-start',
       'reasoning-delta',
       'reasoning-end',
-      'tool-call',
       'tool-approval-request',
-      'tool-result',
       'file-change',
       'finish-step',
       'raw',
@@ -954,6 +982,45 @@ function createSession({
         settle({ error: abortError });
       }
     };
+    subscriptions.push(
+      channel.on('acp-tool-call-candidate', event => {
+        try {
+          dynamicToolCalls.set(
+            event.toolCall.toolCallId,
+            isMcpToolCall?.(event.toolCall) === true,
+          );
+        } catch (error) {
+          toolCallClassificationErrors.set(event.toolCall.toolCallId, error);
+        }
+      }),
+    );
+    subscriptions.push(
+      channel.on('tool-call', event => {
+        if (toolCallClassificationErrors.has(event.toolCallId)) {
+          const error = toolCallClassificationErrors.get(event.toolCallId);
+          closeForwardedBlock();
+          forward({ type: 'error', error });
+          try {
+            channel.send({ type: 'abort' });
+          } catch {}
+          settle({ error });
+          return;
+        }
+        forward(
+          dynamicToolCalls.get(event.toolCallId) === true
+            ? { ...event, dynamic: true }
+            : event,
+        );
+      }),
+    );
+    subscriptions.push(
+      channel.on('tool-result', event => {
+        const dynamic = dynamicToolCalls.get(event.toolCallId) === true;
+        dynamicToolCalls.delete(event.toolCallId);
+        toolCallClassificationErrors.delete(event.toolCallId);
+        forward(dynamic ? { ...event, dynamic: true } : event);
+      }),
+    );
     for (const type of eventTypes) {
       subscriptions.push(channel.on(type, event => forward(event)));
     }
@@ -1110,6 +1177,7 @@ function createSession({
         builtinTools,
         permissionMode,
         permissionModeMapping,
+        mcpServers,
         debug,
         authenticationProfile,
         sessionMeta,
@@ -1137,6 +1205,7 @@ function createSession({
             builtinTools,
             permissionMode,
             permissionModeMapping,
+            ...(mcpServers == null ? {} : { mcpServers }),
             tools: options.tools == null ? undefined : turnStartConfig.tools,
             turnStartConfig,
           });
@@ -1174,6 +1243,7 @@ function createSession({
             builtinTools: turnStartConfig.builtinTools,
             permissionMode: turnStartConfig.permissionMode,
             permissionModeMapping: turnStartConfig.permissionModeMapping,
+            ...(mcpServers == null ? {} : { mcpServers }),
             tools: turnStartConfig.tools,
             turnStartConfig,
             recoveryMode: {
@@ -1338,12 +1408,14 @@ function validateACPTurnStartConfig({
   sessionMeta,
   builtinTools,
   permissionModeMapping,
+  mcpServers,
 }: {
   turnStartConfig: ACPTurnStartConfig;
   authenticationProfile: ACPAuthenticationProfileIdentity;
   sessionMeta: Readonly<Record<string, ACPSerializableValue>> | undefined;
   builtinTools: ReadonlyArray<ACPBuiltinToolMapping>;
   permissionModeMapping: ACPPermissionModeMapping | undefined;
+  mcpServers: Record<string, unknown> | undefined;
 }): void {
   const current = createACPTurnStartConfig({
     prompt: turnStartConfig.prompt,
@@ -1351,6 +1423,7 @@ function validateACPTurnStartConfig({
     builtinTools,
     permissionMode: turnStartConfig.permissionMode,
     permissionModeMapping,
+    mcpServers,
     debug: turnStartConfig.debug,
     authenticationProfile,
     sessionMeta,
@@ -1373,6 +1446,7 @@ function validateACPColdSessionConfiguration({
   sessionMeta,
   builtinTools,
   permissionModeMapping,
+  mcpServers,
   debug,
 }: {
   coldSession: ACPColdSessionState;
@@ -1382,6 +1456,7 @@ function validateACPColdSessionConfiguration({
   sessionMeta: Readonly<Record<string, ACPSerializableValue>> | undefined;
   builtinTools: ReadonlyArray<ACPBuiltinToolMapping>;
   permissionModeMapping: ACPPermissionModeMapping | undefined;
+  mcpServers: Record<string, unknown> | undefined;
   debug: HarnessV1DebugConfig | undefined;
 }): ACPTurnStartConfig {
   const current = createACPTurnStartConfig({
@@ -1390,6 +1465,7 @@ function validateACPColdSessionConfiguration({
     builtinTools,
     permissionMode,
     permissionModeMapping,
+    mcpServers,
     debug,
     authenticationProfile,
     sessionMeta,

package/src/v1/acp-v1-settings.ts

@@ -1,4 +1,5 @@
 import type { HarnessV1PermissionMode } from '@ai-sdk/harness';
+import type { ACPToolCall } from '../acp-tool-call';
 
 export type ACPSerializablePrimitive = string | number | boolean | null;
 
@@ -77,6 +78,8 @@ export type ACPPermissionModeMapping = Readonly<
 export type ACPV1Settings = {
   readonly version?: 'v1';
   readonly harnessId: string;
+  readonly mcpServers?: Record<string, unknown>;
+  readonly isMcpToolCall?: (toolCall: ACPToolCall) => boolean;
   readonly auth?: ACPProviderAuthenticationMode;
   readonly source: ACPSource;
   readonly executable: string;
@@ -94,4 +97,9 @@ export type ACPV1Settings = {
   readonly session?: {
     readonly meta?: Readonly<Record<string, ACPSerializableValue>>;
   };
+  /**
+   * Creates the authentication token used by the sandbox bridge. Defaults to
+   * a random 32-byte hexadecimal token.
+   */
+  readonly mintBridgeToken?: (sandboxId: string) => string;
 };

package/src/v1/acp-v1-turn-start-config.ts

@@ -20,6 +20,7 @@ export function createACPTurnStartConfig({
   builtinTools,
   permissionMode,
   permissionModeMapping,
+  mcpServers,
   debug,
   authenticationProfile,
   sessionMeta,
@@ -29,6 +30,7 @@ export function createACPTurnStartConfig({
   builtinTools: ReadonlyArray<ACPBuiltinToolMapping>;
   permissionMode: NonNullable<StartMessage['permissionMode']>;
   permissionModeMapping: ACPPermissionModeMapping | undefined;
+  mcpServers: Record<string, unknown> | undefined;
   debug: HarnessV1DebugConfig | undefined;
   authenticationProfile: ACPAuthenticationProfileIdentity;
   sessionMeta: Readonly<Record<string, ACPSerializableValue>> | undefined;
@@ -42,6 +44,7 @@ export function createACPTurnStartConfig({
           sessionMeta: sessionMeta ?? null,
           builtinTools,
           permissionModeMapping: permissionModeMapping ?? null,
+          mcpServers: mcpServers ?? null,
         }),
       )
       .digest('hex'),

package/src/v1/bridge/create-emit-stream-event.ts

@@ -6,17 +6,20 @@ import type {
   HarnessV1BridgeToolWire,
   HarnessV1StreamPart,
 } from '@ai-sdk/harness';
+import type { ACPToolCall } from '../../acp-tool-call';
 import type { ACPBuiltinToolMapping } from '../acp-v1-bridge-protocol';
 import { createACPStreamTranslator } from './stream-translator';
 import { createHostToolCorrelation } from './host-tool-correlation';
 
 export function createEmitStreamEvent({
   emit,
+  emitToolCallCandidate,
   builtinTools,
   hostToolServerName,
   hostTools,
 }: {
   emit: (event: HarnessV1StreamPart) => void;
+  emitToolCallCandidate: (options: { toolCall: ACPToolCall }) => void;
   builtinTools: ReadonlyArray<ACPBuiltinToolMapping>;
   hostToolServerName: string;
   hostTools: ReadonlyArray<HarnessV1BridgeToolWire>;
@@ -49,7 +52,11 @@ export function createEmitStreamEvent({
   }) => void;
   removeHostToolCorrelationInvocation: (options: { token: string }) => void;
 } {
-  const translator = createACPStreamTranslator({ emit, builtinTools });
+  const translator = createACPStreamTranslator({
+    emit,
+    emitToolCallCandidate,
+    builtinTools,
+  });
   const correlation = createHostToolCorrelation({
     emitSemanticUpdate: ({ message, rawUpdate }) => {
       translator.update({

package/src/v1/bridge/index.ts

@@ -230,6 +230,12 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   turn.emit({ type: 'stream-start' });
   const emitStreamEvent = createEmitStreamEvent({
     emit: event => turn.emit(event as BridgeEvent),
+    emitToolCallCandidate: ({ toolCall }) => {
+      turn.emit({
+        type: 'acp-tool-call-candidate',
+        toolCall,
+      });
+    },
     builtinTools: start.builtinTools,
     hostToolServerName: HOST_TOOL_MCP_SERVER_NAME,
     hostTools: start.tools ?? [],
@@ -322,6 +328,7 @@ async function ensureSession({
     sessionMeta: bridgeConfiguration.sessionMeta,
     permissionMode: start.permissionMode,
     permissionModeMapping: start.permissionModeMapping,
+    mcpServers: start.mcpServers,
   });
   if (session != null) {
     if (catalogRefreshError != null) throw catalogRefreshError;
@@ -437,6 +444,10 @@ async function ensureSession({
       authentication,
     });
   }
+  const externalMcpServers = createExternalMcpServers({
+    mcpServers: start.mcpServers,
+    initialization,
+  });
   const tools = start.tools ?? [];
   const catalogPath = `${bridgeStateDir}/host-tools.json`;
   await writeFile(catalogPath, JSON.stringify(tools), { mode: 0o600 });
@@ -446,6 +457,7 @@ async function ensureSession({
   });
 
   const mcpServers: acp.McpServer[] = [
+    ...externalMcpServers,
     {
       name: HOST_TOOL_MCP_SERVER_NAME,
       command: process.execPath,
@@ -557,6 +569,41 @@ async function ensureSession({
   sessionConfigurationFingerprint = fingerprint;
 }
 
+function createExternalMcpServers({
+  mcpServers,
+  initialization,
+}: {
+  mcpServers: Record<string, unknown> | undefined;
+  initialization: acp.InitializeResponse;
+}): acp.McpServer[] {
+  if (mcpServers == null) return [];
+  return Object.entries(mcpServers).map(([name, value]) => {
+    if (!isRecord(value)) {
+      throw new Error(
+        `ACP MCP server ${JSON.stringify(name)} 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 } as acp.McpServer;
+  });
+}
+
 function unknownUsage() {
   return {
     inputTokens: {