@ai-sdk/harness-acp 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-acp",
-  "version": "1.0.0",
+  "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.63",
-    "@ai-sdk/provider-utils": "5.0.24"
+    "@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

@@ -1,19 +1,12 @@
 import type { HarnessV1 } from '@ai-sdk/harness';
 import type { ToolSet } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
-import {
-  createACPAuthenticationProfileIdentity,
-  resolveACPProviderAuthenticationCompatibility,
-  type ACPAuthenticationProfileIdentity,
-  type ACPClientApp,
-} from './acp-auth';
+import type { ACPClientApp } from './acp-auth';
+import type { ACPToolCall } from './acp-tool-call';
 import { createACPV1, type ACPV1Settings } from './v1';
-import { createImplementationIdentity } from './v1/implementation';
 import {
   acpColdSessionStateSchema,
   acpTurnStartConfigSchema,
-  type ACPColdSessionState,
-  type ACPTurnStartConfig,
 } from './v1/acp-v1-bridge-protocol';
 import { VERSION } from './version';
 
@@ -24,18 +17,29 @@ 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;
   readonly version?: ACPV1Settings['version'];
   readonly harnessId: ACPV1Settings['harnessId'];
   readonly auth?: ACPV1Settings['auth'];
-  readonly implementation: ACPV1Settings['implementation'];
+  readonly source: ACPV1Settings['source'];
+  readonly executable: ACPV1Settings['executable'];
+  readonly args?: ACPV1Settings['args'];
+  readonly forwardEnv?: ACPV1Settings['forwardEnv'];
+  readonly env?: ACPV1Settings['env'];
   readonly authentication?: ACPV1Settings['authentication'];
   readonly providerAuthentication?: ACPV1Settings['providerAuthentication'];
   readonly modelId?: ACPV1Settings['modelId'];
   readonly permissionModeMapping?: ACPV1Settings['permissionModeMapping'];
   readonly session?: ACPV1Settings['session'];
+  readonly mintBridgeToken?: ACPV1Settings['mintBridgeToken'];
 };
 
 const ACP_BUILTIN_TOOLS = {} as const satisfies ToolSet;
@@ -86,59 +90,24 @@ const acpResumeStateSchema = z.object({
   skillsFingerprint: z.string().optional(),
 });
 
-type ACPBridgeCoords = z.infer<typeof acpBridgeCoordsSchema>;
-
 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': {
       const clientApp = settings.clientApp ?? ACP_CLIENT_APP;
-      const providerAuthenticationCompatibility =
-        resolveACPProviderAuthenticationCompatibility({
-          auth: settings.auth,
-          providerAuthentication: settings.providerAuthentication,
-          env: process.env,
-        });
-      const implementationIdentity = createImplementationIdentity({
-        harnessId: settings.harnessId,
-        acpVersion: version,
-        implementation: settings.implementation,
-        clientApp,
-        providerAuthentication: providerAuthenticationCompatibility,
-        permissionModeMapping: settings.permissionModeMapping,
-      });
-      const authenticationProfile = createACPAuthenticationProfileIdentity({
-        authentication: settings.authentication,
-        providerAuthenticationCompatibility,
-      });
-      const lifecycleStateSchema: z.ZodType<{
-        readonly implementationIdentity: string;
-        readonly authenticationProfile?: ACPAuthenticationProfileIdentity;
-        readonly acpSessionId?: string;
-        readonly bridge?: ACPBridgeCoords;
-        readonly coldSession?: ACPColdSessionState;
-        readonly turnStartConfig?: ACPTurnStartConfig;
-        readonly recovery?: {
-          readonly mode: 'disk-replay' | 'lossy-rerun';
-          readonly reason: string;
-        };
-        readonly restoration?: {
-          readonly method: 'resume' | 'load';
-        };
-        readonly initialGuidanceApplied?: boolean;
-        readonly skillsMaterialized?: boolean;
-        readonly skillsFingerprint?: string;
-      }> = acpResumeStateSchema.extend({
-        implementationIdentity: z.literal(implementationIdentity),
-        authenticationProfile: acpResumeStateSchema.shape.authenticationProfile
-          .unwrap()
-          .extend({
-            digest: z.literal(authenticationProfile.digest),
-          })
-          .optional(),
-      });
       return createACPV1({
         settings,
         builtinTools:
@@ -146,10 +115,7 @@ export function createACP<TBuiltinTools extends ToolSet = {}>(
         port: settings.port,
         startupTimeoutMs: settings.startupTimeoutMs,
         clientApp,
-        implementationIdentity,
-        authenticationProfile,
-        providerAuthenticationCompatibility,
-        lifecycleStateSchema,
+        lifecycleStateSchema: acpResumeStateSchema,
       });
     }
     default:

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,10 +1,28 @@
 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,
-  ACPLockedNpmImplementation,
-  ACPNpmImplementation,
+  ACPNpmLockedSource,
+  ACPNpmSimpleSource,
   ACPPermissionModeMapping,
   ACPPermissionModeTarget,
   ACPProfileValue,
@@ -12,7 +30,7 @@ export type {
   ACPProviderAuthenticationMode,
   ACPSerializablePrimitive,
   ACPSerializableValue,
-  ACPSimpleNpmImplementation,
+  ACPSource,
   ACPV1Settings,
   ACPValueSource,
 } from './v1';

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

@@ -34,13 +34,17 @@ import {
 } from '@ai-sdk/provider-utils';
 import { WebSocket } from 'ws';
 import {
+  createACPAuthenticationProfileIdentity,
   resolveACPProviderAuthentication,
+  resolveACPProviderAuthenticationCompatibility,
   type ACPAuthenticationProfileIdentity,
   type ACPClientApp,
-  type ACPProviderAuthenticationCompatibility,
 } from '../acp-auth';
+import type { ACPToolCall } from '../acp-tool-call';
 import {
+  createACPV1Implementation,
   createImplementationDescriptor,
+  createImplementationIdentity,
   createImplementationInstallCommand,
   createImplementationManifest,
   getImplementationLockfile,
@@ -112,9 +116,6 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
   port: portOverride,
   startupTimeoutMs,
   clientApp,
-  implementationIdentity,
-  authenticationProfile,
-  providerAuthenticationCompatibility,
   lifecycleStateSchema,
 }: {
   settings: ACPV1Settings;
@@ -122,21 +123,28 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
   port?: number;
   startupTimeoutMs?: number;
   clientApp: ACPClientApp;
-  implementationIdentity: string;
-  authenticationProfile: ACPAuthenticationProfileIdentity;
-  providerAuthenticationCompatibility:
-    | ACPProviderAuthenticationCompatibility
-    | undefined;
   lifecycleStateSchema: NonNullable<
     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)}.`,
     );
   }
-  validateACPV1Implementation(settings.implementation);
+  const implementation = createACPV1Implementation({ settings });
+  validateACPV1Implementation(implementation);
 
   const BOOTSTRAP_DIR = `.harness-bootstrap/${settings.harnessId}`;
 
@@ -164,7 +172,7 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
           readBridgeAsset({ name: 'host-tool-mcp.mjs' }),
         ]);
       const implementationLock = getImplementationLockfile({
-        implementation: settings.implementation,
+        implementation,
       });
       cachedBootstrap = {
         harnessId: settings.harnessId,
@@ -186,14 +194,13 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
           {
             path: `${BOOTSTRAP_DIR}/implementation/package.json`,
             content: createImplementationManifest({
-              implementation: settings.implementation,
+              implementation,
             }),
           },
           {
             path: `${BOOTSTRAP_DIR}/implementation/implementation.json`,
             content: createImplementationDescriptor({
-              implementation: settings.implementation,
-              implementationIdentity,
+              implementation,
             }),
           },
           ...(implementationLock == null
@@ -213,7 +220,7 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
             command: createImplementationInstallCommand({
               implementationDir: 'implementation',
               storeDir: '../.pnpm-store',
-              implementation: settings.implementation,
+              implementation,
             }),
           },
         ],
@@ -229,6 +236,25 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
         });
       }
       const permissionMode = startOptions.permissionMode ?? 'allow-all';
+      const env = { ...process.env };
+      const providerAuthenticationCompatibility =
+        resolveACPProviderAuthenticationCompatibility({
+          auth: settings.auth,
+          providerAuthentication: settings.providerAuthentication,
+          env,
+        });
+      const implementationIdentity = createImplementationIdentity({
+        harnessId: settings.harnessId,
+        acpVersion: 'v1',
+        implementation,
+        clientApp,
+        providerAuthentication: providerAuthenticationCompatibility,
+        permissionModeMapping: settings.permissionModeMapping,
+      });
+      const authenticationProfile = createACPAuthenticationProfileIdentity({
+        authentication: settings.authentication,
+        providerAuthenticationCompatibility,
+      });
 
       const resolvedProviderAuthentication = resolveACPProviderAuthentication({
         auth: {
@@ -236,7 +262,7 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
           providerAuthentication: settings.providerAuthentication,
           clientApp,
         },
-        env: process.env,
+        env,
         compatibility: providerAuthenticationCompatibility,
       });
       const sandboxSession = startOptions.sandboxSession;
@@ -356,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,
@@ -407,6 +435,7 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
                   sessionMeta: settings.session?.meta,
                   builtinTools: builtinToolCatalog,
                   permissionModeMapping,
+                  mcpServers: settings.mcpServers,
                 });
                 respawnStrategy = {
                   mode: 'lossy-rerun',
@@ -436,6 +465,7 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
             sessionMeta: settings.session?.meta,
             builtinTools: builtinToolCatalog,
             permissionModeMapping,
+            mcpServers: settings.mcpServers,
             debug: startOptions.observability?.debug,
           });
           respawnStrategy = {
@@ -451,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,
@@ -472,8 +505,8 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
           ` --bridge-type ${shellQuote(settings.harnessId)}`,
         env: {
           ...resolveImplementationEnvironment({
-            implementation: settings.implementation,
-            env: process.env,
+            implementation,
+            env,
           }),
           ...createACPBridgeEnvironment({
             authentication: settings.authentication,
@@ -556,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: {
@@ -592,6 +628,8 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
         builtinTools: builtinToolCatalog,
         permissionMode,
         permissionModeMapping,
+        mcpServers: settings.mcpServers,
+        isMcpToolCall: settings.isMcpToolCall,
         initialGuidanceApplied: resolveACPInitialGuidanceApplied({
           isResume,
           lifecycleState: lifecycleData,
@@ -793,6 +831,8 @@ function createSession({
   builtinTools,
   permissionMode,
   permissionModeMapping,
+  mcpServers,
+  isMcpToolCall,
   initialGuidanceApplied: initialGuidanceAppliedAtStart,
   skillCatalog,
   skillsFingerprint,
@@ -821,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;
@@ -875,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') {
@@ -909,9 +953,7 @@ function createSession({
       'reasoning-start',
       'reasoning-delta',
       'reasoning-end',
-      'tool-call',
       'tool-approval-request',
-      'tool-result',
       'file-change',
       'finish-step',
       'raw',
@@ -940,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)));
     }
@@ -1096,6 +1177,7 @@ function createSession({
         builtinTools,
         permissionMode,
         permissionModeMapping,
+        mcpServers,
         debug,
         authenticationProfile,
         sessionMeta,
@@ -1123,6 +1205,7 @@ function createSession({
             builtinTools,
             permissionMode,
             permissionModeMapping,
+            ...(mcpServers == null ? {} : { mcpServers }),
             tools: options.tools == null ? undefined : turnStartConfig.tools,
             turnStartConfig,
           });
@@ -1160,6 +1243,7 @@ function createSession({
             builtinTools: turnStartConfig.builtinTools,
             permissionMode: turnStartConfig.permissionMode,
             permissionModeMapping: turnStartConfig.permissionModeMapping,
+            ...(mcpServers == null ? {} : { mcpServers }),
             tools: turnStartConfig.tools,
             turnStartConfig,
             recoveryMode: {
@@ -1324,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,
@@ -1337,6 +1423,7 @@ function validateACPTurnStartConfig({
     builtinTools,
     permissionMode: turnStartConfig.permissionMode,
     permissionModeMapping,
+    mcpServers,
     debug: turnStartConfig.debug,
     authenticationProfile,
     sessionMeta,
@@ -1359,6 +1446,7 @@ function validateACPColdSessionConfiguration({
   sessionMeta,
   builtinTools,
   permissionModeMapping,
+  mcpServers,
   debug,
 }: {
   coldSession: ACPColdSessionState;
@@ -1368,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({
@@ -1376,6 +1465,7 @@ function validateACPColdSessionConfiguration({
     builtinTools,
     permissionMode,
     permissionModeMapping,
+    mcpServers,
     debug,
     authenticationProfile,
     sessionMeta,