@ai-sdk/harness-acp 0.0.0 → 1.0.0

package/dist/index.js

@@ -0,0 +1,2094 @@
+// src/acp-harness.ts
+import { z as z4 } from "zod/v4";
+
+// src/acp-auth.ts
+import { createHash } from "crypto";
+import { getAiGatewayAuthFromEnv } from "@ai-sdk/harness/utils";
+var DEFAULT_AI_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh";
+function createACPAuthenticationProfileIdentity({
+  authentication,
+  providerAuthenticationCompatibility
+}) {
+  const providerKind = providerAuthenticationCompatibility?.type ?? "direct";
+  const digest = createHash("sha256").update(
+    stableStringify({
+      value: {
+        authentication: authentication ?? null,
+        providerAuthentication: providerAuthenticationCompatibility ?? null
+      }
+    })
+  ).digest("hex");
+  return {
+    digest,
+    ...authentication == null ? {} : { acpMethodId: authentication.methodId },
+    providerKind,
+    ...providerAuthenticationCompatibility == null ? {} : { providerMode: providerAuthenticationCompatibility.mode },
+    ...providerAuthenticationCompatibility?.type === "ai-gateway" ? {
+      gatewayCredentialSource: providerAuthenticationCompatibility.credentialSource
+    } : {}
+  };
+}
+function resolveACPProviderAuthentication({
+  auth,
+  env,
+  compatibility
+}) {
+  const clientAppEnv = {
+    AI_SDK_ACP_CLIENT_APP_NAME: auth.clientApp.name,
+    AI_SDK_ACP_CLIENT_APP_VERSION: auth.clientApp.version
+  };
+  const providerAuthentication = auth.providerAuthentication;
+  if (providerAuthentication == null) {
+    return { providerAuthentication: void 0, env: clientAppEnv };
+  }
+  if (compatibility?.type === "direct") {
+    return {
+      providerAuthentication: { type: "direct" },
+      env: clientAppEnv
+    };
+  }
+  const mode = auth.mode ?? "auto";
+  if (mode === "direct") {
+    return {
+      providerAuthentication: { type: "direct" },
+      env: clientAppEnv
+    };
+  }
+  const gateway = compatibility?.type === "ai-gateway" ? {
+    apiKey: resolveGatewayCredential({
+      env,
+      credentialSource: compatibility.credentialSource
+    }),
+    baseUrl: compatibility.baseUrl
+  } : getAiGatewayAuthFromEnv({ env });
+  const apiKey = gateway.apiKey;
+  if (compatibility == null && mode === "auto" && apiKey == null) {
+    return {
+      providerAuthentication: { type: "direct" },
+      env: clientAppEnv
+    };
+  }
+  if (apiKey == null) {
+    throw new Error(
+      "AI Gateway authentication was selected, but neither AI_GATEWAY_API_KEY nor VERCEL_OIDC_TOKEN is set."
+    );
+  }
+  return {
+    providerAuthentication: {
+      type: "ai-gateway",
+      env: compatibility?.type === "ai-gateway" ? compatibility.env : providerAuthentication.gateway.env
+    },
+    env: {
+      AI_SDK_ACP_GATEWAY_API_KEY: apiKey,
+      AI_SDK_ACP_GATEWAY_BASE_URL: gateway.baseUrl,
+      ...clientAppEnv
+    }
+  };
+}
+function resolveACPProviderAuthenticationCompatibility({
+  auth = "auto",
+  providerAuthentication,
+  env
+}) {
+  if (providerAuthentication == null) return void 0;
+  const mode = auth;
+  if (mode === "direct") {
+    return { type: "direct", mode };
+  }
+  const credentialSource = resolveGatewayCredentialSource({
+    env
+  });
+  if (mode === "auto" && credentialSource == null) {
+    return { type: "direct", mode };
+  }
+  return {
+    type: "ai-gateway",
+    mode,
+    env: providerAuthentication.gateway.env,
+    credentialSource,
+    baseUrl: env.AI_GATEWAY_BASE_URL ?? DEFAULT_AI_GATEWAY_BASE_URL
+  };
+}
+function resolveGatewayCredentialSource({
+  env
+}) {
+  return env.AI_GATEWAY_API_KEY ? "AI_GATEWAY_API_KEY" : env.VERCEL_OIDC_TOKEN ? "VERCEL_OIDC_TOKEN" : null;
+}
+function resolveGatewayCredential({
+  env,
+  credentialSource
+}) {
+  const gatewayFromEnv = getAiGatewayAuthFromEnv({ env });
+  switch (credentialSource) {
+    case "AI_GATEWAY_API_KEY":
+      return env.AI_GATEWAY_API_KEY == null ? void 0 : gatewayFromEnv.apiKey;
+    case "VERCEL_OIDC_TOKEN":
+      return getAiGatewayAuthFromEnv({
+        env: { VERCEL_OIDC_TOKEN: env.VERCEL_OIDC_TOKEN }
+      }).apiKey;
+    case null:
+      return void 0;
+  }
+}
+function stableStringify({ value }) {
+  return JSON.stringify(sortIdentityValue({ value }));
+}
+function sortIdentityValue({ value }) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortIdentityValue({ value: item }));
+  }
+  if (value != null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, sortIdentityValue({ value: entry })])
+    );
+  }
+  return value;
+}
+
+// src/v1/acp-v1-harness.ts
+import { createHash as createHash5, randomBytes } from "crypto";
+import { readFile } from "fs/promises";
+import { posix } from "path";
+import { fileURLToPath } from "url";
+import {
+  HarnessCapabilityUnsupportedError as HarnessCapabilityUnsupportedError2,
+  harnessV1DiagnosticFromBridgeFrame
+} from "@ai-sdk/harness";
+import { HarnessBridgeCapabilityUnsupportedError } from "@ai-sdk/harness/bridge";
+import {
+  createBridgeErrorHandler,
+  createBridgeStartupError,
+  classifyDiskLog,
+  drainBridgeProcessStream,
+  forwardBridgeProcessStream,
+  markBridgeStarting,
+  resolveSandboxHomeDir,
+  SandboxChannel,
+  shellQuote,
+  waitForBridgeReady
+} from "@ai-sdk/harness/utils";
+import {
+  asSchema
+} from "@ai-sdk/provider-utils";
+import { WebSocket } from "ws";
+
+// src/v1/implementation.ts
+import { createHash as createHash2 } from "crypto";
+var EXACT_SEMVER_REGEXP = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var PACKAGE_NAME_REGEXP = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+var EXECUTABLE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var ENVIRONMENT_VARIABLE_NAME_REGEXP = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function validateACPV1Implementation(implementation) {
+  if (isLockedImplementation(implementation)) {
+    if (implementation.packageJson.length === 0) {
+      throw new Error(
+        "ACP locked npm implementation packageJson must not be empty."
+      );
+    }
+    if (implementation.pnpmLockYaml.length === 0) {
+      throw new Error(
+        "ACP locked npm implementation pnpmLockYaml must not be empty."
+      );
+    }
+  } else {
+    validateSimpleImplementation({ implementation });
+  }
+  if (!EXECUTABLE_NAME_REGEXP.test(implementation.executable)) {
+    throw new Error(
+      `ACP executable must be a package bin name without a path; received ${JSON.stringify(implementation.executable)}.`
+    );
+  }
+  validateForwardEnvironment({ forwardEnv: implementation.forwardEnv });
+  validateEnvironment({ env: implementation.env });
+  const forwardedKeys = new Set(implementation.forwardEnv ?? []);
+  for (const key of Object.keys(implementation.env ?? {})) {
+    if (forwardedKeys.has(key)) {
+      throw new Error(
+        `ACP runtime environment key ${JSON.stringify(key)} cannot be configured in both forwardEnv and env.`
+      );
+    }
+  }
+}
+function createImplementationManifest({
+  implementation
+}) {
+  if (isLockedImplementation(implementation)) {
+    return implementation.packageJson;
+  }
+  return JSON.stringify(
+    {
+      name: "harness-acp-implementation",
+      version: "0.0.0",
+      private: true,
+      type: "module",
+      dependencies: {
+        [implementation.packageName]: implementation.version
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function getImplementationLockfile({
+  implementation
+}) {
+  return isLockedImplementation(implementation) ? implementation.pnpmLockYaml : void 0;
+}
+function createImplementationDescriptor({
+  implementation,
+  implementationIdentity
+}) {
+  return JSON.stringify(
+    {
+      executable: implementation.executable,
+      args: implementation.args ?? [],
+      envKeys: getImplementationEnvironmentKeys({ implementation }),
+      implementationIdentity
+    },
+    null,
+    2
+  ) + "\n";
+}
+function createImplementationIdentity({
+  harnessId,
+  acpVersion,
+  implementation,
+  clientApp,
+  providerAuthentication,
+  permissionModeMapping
+}) {
+  const acquisition = isLockedImplementation(implementation) ? {
+    mode: "locked",
+    packageJson: implementation.packageJson,
+    pnpmLockYaml: implementation.pnpmLockYaml
+  } : {
+    mode: "simple",
+    packageName: implementation.packageName,
+    version: implementation.version
+  };
+  const forwardedEnvironment = [
+    ...new Set(implementation.forwardEnv ?? [])
+  ].sort();
+  const literalEnvironment = Object.fromEntries(
+    Object.entries(implementation.env ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [key, { value }])
+  );
+  const payload = {
+    harnessId,
+    acpVersion,
+    acquisition,
+    executable: implementation.executable,
+    args: implementation.args ?? [],
+    clientApp,
+    environment: {
+      forwarded: forwardedEnvironment,
+      literal: literalEnvironment
+    },
+    providerAuthentication: providerAuthentication ?? null,
+    permissionModeMapping: permissionModeMapping ?? null
+  };
+  return createHash2("sha256").update(stableStringify2({ value: payload })).digest("hex");
+}
+function createImplementationInstallCommand({
+  implementationDir,
+  storeDir,
+  implementation
+}) {
+  return `pnpm --dir ${implementationDir} install` + (isLockedImplementation(implementation) ? " --frozen-lockfile" : "") + ` --prod --store-dir ${storeDir}`;
+}
+function resolveImplementationEnvironment({
+  implementation,
+  env
+}) {
+  const forwardedEnvironment = {};
+  for (const name of implementation.forwardEnv ?? []) {
+    const value = env[name];
+    if (value != null && value.length > 0) {
+      forwardedEnvironment[name] = value;
+    }
+  }
+  return {
+    ...forwardedEnvironment,
+    ...implementation.env
+  };
+}
+function validateSimpleImplementation({
+  implementation
+}) {
+  if (!PACKAGE_NAME_REGEXP.test(implementation.packageName)) {
+    throw new Error(
+      `ACP npm package name is invalid: ${JSON.stringify(implementation.packageName)}.`
+    );
+  }
+  if (!EXACT_SEMVER_REGEXP.test(implementation.version)) {
+    throw new Error(
+      `ACP npm implementation version must be an exact semantic version; received ${JSON.stringify(implementation.version)}.`
+    );
+  }
+}
+function validateEnvironment({
+  env
+}) {
+  for (const [key, value] of Object.entries(env ?? {})) {
+    if (!ENVIRONMENT_VARIABLE_NAME_REGEXP.test(key)) {
+      throw new Error(
+        `ACP environment variable name is invalid: ${JSON.stringify(key)}.`
+      );
+    }
+    if (value.includes("\0")) {
+      throw new Error(`ACP runtime environment value for ${key} contains NUL.`);
+    }
+  }
+}
+function validateForwardEnvironment({
+  forwardEnv
+}) {
+  for (const name of forwardEnv ?? []) {
+    if (!ENVIRONMENT_VARIABLE_NAME_REGEXP.test(name)) {
+      throw new Error(
+        `ACP environment variable name is invalid: ${JSON.stringify(name)}.`
+      );
+    }
+  }
+}
+function getImplementationEnvironmentKeys({
+  implementation
+}) {
+  return [
+    .../* @__PURE__ */ new Set([
+      ...implementation.forwardEnv ?? [],
+      ...Object.keys(implementation.env ?? {})
+    ])
+  ].sort();
+}
+function isLockedImplementation(implementation) {
+  return implementation.mode === "locked";
+}
+function stableStringify2({ value }) {
+  return JSON.stringify(sortValue({ value }));
+}
+function sortValue({ value }) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortValue({ value: item }));
+  }
+  if (value != null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, sortValue({ value: item })])
+    );
+  }
+  return value;
+}
+
+// src/v1/acp-v1-bridge-protocol.ts
+import {
+  harnessV1BridgeInboundCommandSchemas,
+  harnessV1BridgeOutboundMessageSchema,
+  harnessV1BridgeReadySchema,
+  harnessV1BridgeStartBaseSchema,
+  harnessV1BridgeToolWireSchema
+} from "@ai-sdk/harness";
+import { z as z2 } from "zod/v4";
+
+// src/v1/acp-v1-prompt.ts
+import {
+  HarnessCapabilityUnsupportedError
+} from "@ai-sdk/harness";
+import { z } from "zod/v4";
+var acpTextContentBlockSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+});
+function convertHarnessPromptToACPTextBlocks({
+  prompt,
+  harnessId
+}) {
+  if (typeof prompt === "string") {
+    return [{ type: "text", text: prompt }];
+  }
+  if (typeof prompt.content === "string") {
+    return [{ type: "text", text: prompt.content }];
+  }
+  const content = [];
+  for (const part of prompt.content) {
+    if (part.type === "text") {
+      content.push({ type: "text", text: part.text });
+      continue;
+    }
+    if (part.type === "image") {
+      throw unsupportedPromptContent({
+        harnessId,
+        category: "image content"
+      });
+    }
+    if (part.type === "file") {
+      const mediaCategory = part.mediaType.toLowerCase().split("/", 1)[0];
+      if (mediaCategory === "image") {
+        throw unsupportedPromptContent({
+          harnessId,
+          category: "image content"
+        });
+      }
+      if (mediaCategory === "audio") {
+        throw unsupportedPromptContent({
+          harnessId,
+          category: "audio content"
+        });
+      }
+      throw unsupportedPromptContent({
+        harnessId,
+        category: `embedded resource content with media type ${JSON.stringify(part.mediaType)}`
+      });
+    }
+    throw unsupportedPromptContent({
+      harnessId,
+      category: `content parts of type ${JSON.stringify(
+        part.type
+      )}`
+    });
+  }
+  return content;
+}
+function prependACPInitialGuidance({
+  prompt,
+  instructions,
+  skills
+}) {
+  const hasInstructions = instructions != null && instructions.length > 0;
+  if (!hasInstructions && skills.length === 0) return [...prompt];
+  const lines = [
+    "<session-guidance>",
+    "This block is operating guidance from the harness, not user-authored content."
+  ];
+  if (hasInstructions) {
+    lines.push("<instructions>", instructions, "</instructions>");
+  }
+  if (skills.length > 0) {
+    lines.push(
+      "<available-skills>",
+      "Load a skill only when relevant by reading its SKILL.md file at the listed absolute path."
+    );
+    for (const skill of skills) {
+      lines.push(`- ${skill.name}: ${skill.description} (${skill.path})`);
+    }
+    lines.push("</available-skills>");
+  }
+  lines.push("</session-guidance>");
+  return [{ type: "text", text: lines.join("\n") }, ...prompt];
+}
+function unsupportedPromptContent({
+  harnessId,
+  category
+}) {
+  return new HarnessCapabilityUnsupportedError({
+    harnessId,
+    message: `The ${harnessId} ACP harness supports only portable text prompts and does not support ${category}. Pass a string or a user message whose content contains only text parts.`
+  });
+}
+
+// src/v1/acp-v1-bridge-protocol.ts
+var builtinToolSchema = z2.object({
+  toolName: z2.string(),
+  nativeName: z2.string().optional(),
+  inputSchema: z2.json().optional()
+});
+var jsonValueSchema = z2.json();
+var acpSerializableToolSpecSchema = harnessV1BridgeToolWireSchema.extend({
+  inputSchema: z2.custom(
+    (value) => value != null && typeof value === "object" && !Array.isArray(value) && jsonValueSchema.safeParse(value).success
+  ).optional()
+});
+var permissionModeTargetSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("session-mode"),
+    modeId: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("session-config-option"),
+    configId: z2.string(),
+    value: z2.union([z2.string(), z2.boolean()])
+  })
+]);
+var permissionModeMappingSchema = z2.object({
+  "allow-reads": permissionModeTargetSchema.nullable(),
+  "allow-edits": permissionModeTargetSchema.nullable(),
+  "allow-all": permissionModeTargetSchema.nullable()
+});
+var acpTurnStartConfigSchema = z2.object({
+  version: z2.literal(1),
+  configurationFingerprint: z2.string(),
+  prompt: z2.array(acpTextContentBlockSchema),
+  tools: z2.array(acpSerializableToolSpecSchema).default([]),
+  builtinTools: z2.array(builtinToolSchema).default([]),
+  permissionMode: harnessV1BridgeStartBaseSchema.shape.permissionMode.unwrap(),
+  permissionModeMapping: permissionModeMappingSchema.optional(),
+  debug: harnessV1BridgeStartBaseSchema.shape.debug.optional()
+});
+var acpColdSessionStateSchema = acpTurnStartConfigSchema.omit({ prompt: true, debug: true }).extend({
+  modelId: z2.string().optional()
+});
+var lossyRecoverySchema = z2.object({
+  type: z2.literal("lossy-rerun"),
+  acpSessionId: z2.string(),
+  reason: z2.string()
+});
+var coldRestoreSchema = z2.object({
+  type: z2.literal("cold-restore"),
+  acpSessionId: z2.string()
+});
+var outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+var startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+  prompt: z2.array(acpTextContentBlockSchema),
+  tools: z2.array(acpSerializableToolSpecSchema).optional(),
+  builtinTools: z2.array(builtinToolSchema).readonly().default([]),
+  permissionModeMapping: permissionModeMappingSchema.optional(),
+  turnStartConfig: acpTurnStartConfigSchema,
+  recoveryMode: z2.discriminatedUnion("type", [lossyRecoverySchema, coldRestoreSchema]).optional()
+});
+var inboundMessageSchema = z2.discriminatedUnion("type", [
+  startMessageSchema,
+  ...harnessV1BridgeInboundCommandSchemas
+]);
+
+// src/v1/bridge/acp-v1-bridge-environment.ts
+import { z as z3 } from "zod/v4";
+var ACP_BRIDGE_CONFIGURATION_ENV = "AI_SDK_ACP_BRIDGE_CONFIGURATION";
+var serializableValueSchema = z3.json();
+var profileValueSchema = z3.lazy(
+  () => z3.union([
+    z3.string(),
+    z3.number(),
+    z3.boolean(),
+    z3.null(),
+    z3.object({
+      $source: z3.enum([
+        "gateway-api-key",
+        "gateway-base-url",
+        "gateway-authorization",
+        "client-app",
+        "client-app-name",
+        "client-app-version"
+      ]),
+      prefix: z3.string().optional(),
+      suffix: z3.string().optional(),
+      ensureSuffix: z3.string().optional()
+    }),
+    z3.array(profileValueSchema),
+    z3.record(z3.string(), profileValueSchema)
+  ])
+);
+var serializableRecordSchema = z3.record(z3.string(), serializableValueSchema);
+var profileRecordSchema = z3.record(z3.string(), profileValueSchema);
+var authenticationSchema = z3.object({
+  methodId: z3.string(),
+  meta: serializableRecordSchema.optional(),
+  clientCapabilities: serializableRecordSchema.optional()
+});
+var providerAuthenticationSchema = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("direct") }),
+  z3.object({
+    type: z3.literal("ai-gateway"),
+    env: profileRecordSchema
+  })
+]);
+var bridgeConfigurationSchema = z3.object({
+  authentication: authenticationSchema.optional(),
+  providerAuthentication: providerAuthenticationSchema.optional(),
+  sessionMeta: serializableRecordSchema.optional()
+});
+function createACPBridgeEnvironment({
+  authentication,
+  providerAuthentication,
+  sessionMeta
+}) {
+  return {
+    [ACP_BRIDGE_CONFIGURATION_ENV]: JSON.stringify({
+      ...authentication == null ? {} : { authentication },
+      ...providerAuthentication == null ? {} : { providerAuthentication },
+      ...sessionMeta == null ? {} : { sessionMeta }
+    })
+  };
+}
+
+// src/v1/acp-v1-turn-start-config.ts
+import { createHash as createHash3 } from "crypto";
+function createACPTurnStartConfig({
+  prompt,
+  tools,
+  builtinTools,
+  permissionMode,
+  permissionModeMapping,
+  debug,
+  authenticationProfile,
+  sessionMeta
+}) {
+  return {
+    version: 1,
+    configurationFingerprint: createHash3("sha256").update(
+      stableStringify3({
+        authenticationProfile,
+        sessionMeta: sessionMeta ?? null,
+        builtinTools,
+        permissionModeMapping: permissionModeMapping ?? null
+      })
+    ).digest("hex"),
+    prompt: [...prompt],
+    tools: tools.map((tool) => acpSerializableToolSpecSchema.parse(tool)),
+    builtinTools: [...builtinTools],
+    permissionMode,
+    ...permissionModeMapping == null ? {} : { permissionModeMapping },
+    ...debug == null ? {} : { debug }
+  };
+}
+function createACPColdSessionState({
+  turnStartConfig,
+  modelId
+}) {
+  return {
+    version: turnStartConfig.version,
+    configurationFingerprint: turnStartConfig.configurationFingerprint,
+    tools: turnStartConfig.tools,
+    builtinTools: turnStartConfig.builtinTools,
+    permissionMode: turnStartConfig.permissionMode,
+    ...turnStartConfig.permissionModeMapping == null ? {} : { permissionModeMapping: turnStartConfig.permissionModeMapping },
+    ...modelId == null ? {} : { modelId }
+  };
+}
+function stableStringify3(value) {
+  return JSON.stringify(sortValue2(value));
+}
+function sortValue2(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortValue2(item));
+  }
+  if (value != null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, sortValue2(entry)])
+    );
+  }
+  return value;
+}
+
+// src/v1/acp-v1-lifecycle.ts
+function resolveACPInitialGuidanceApplied({
+  isResume,
+  lifecycleState
+}) {
+  if (!isResume) return false;
+  return lifecycleState?.initialGuidanceApplied ?? true;
+}
+function shouldMaterializeACPSkills({
+  isResume,
+  lifecycleState,
+  skillsFingerprint
+}) {
+  if (isResume && lifecycleState?.skillsFingerprint != null && lifecycleState.skillsFingerprint !== skillsFingerprint) {
+    throw new Error(
+      "ACP lifecycle state was created with a different set of skills."
+    );
+  }
+  return !isResume || lifecycleState?.skillsMaterialized !== true;
+}
+function validateACPLifecycleCompatibility({
+  harnessId,
+  lifecycleHarnessId,
+  implementationIdentity,
+  authenticationProfile,
+  lifecycleData,
+  sandboxId
+}) {
+  if (lifecycleHarnessId !== harnessId) {
+    throw new Error(
+      `ACP lifecycle state was produced by harness ${JSON.stringify(
+        lifecycleHarnessId
+      )}, but this harness is ${JSON.stringify(harnessId)}.`
+    );
+  }
+  if (lifecycleData.implementationIdentity !== implementationIdentity) {
+    throw new Error(
+      "ACP lifecycle state is incompatible with the configured implementation."
+    );
+  }
+  if (lifecycleData.authenticationProfile?.digest !== authenticationProfile.digest) {
+    throw new Error(
+      "ACP lifecycle state is incompatible with the configured authentication profile."
+    );
+  }
+  const expectedSandboxId = lifecycleData.bridge?.sandboxId;
+  if (expectedSandboxId != null && sandboxId != null && expectedSandboxId !== sandboxId) {
+    throw new Error(
+      `ACP lifecycle state belongs to sandbox ${JSON.stringify(
+        expectedSandboxId
+      )}, not ${JSON.stringify(sandboxId)}.`
+    );
+  }
+}
+
+// src/v1/acp-v1-skills.ts
+import { createHash as createHash4 } from "crypto";
+import path from "path";
+import { writeSkills } from "@ai-sdk/harness/utils";
+var ACP_SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function createACPSkillsFingerprint({
+  skills
+}) {
+  const canonicalSkills = skills.map((skill) => ({
+    name: skill.name,
+    description: skill.description,
+    content: skill.content,
+    files: [...skill.files ?? []].map((file) => ({
+      path: path.posix.normalize(file.path),
+      content: file.content
+    })).sort(
+      (left, right) => compareCanonicalStrings({ left: left.path, right: right.path })
+    )
+  })).sort(
+    (left, right) => compareCanonicalStrings({ left: left.name, right: right.name })
+  );
+  return createHash4("sha256").update(JSON.stringify(canonicalSkills)).digest("hex");
+}
+function resolveACPPrivateSessionDirectory({
+  sandboxHomeDir,
+  sessionWorkDir,
+  harnessId,
+  sessionId
+}) {
+  const sessionKey = createHash4("sha256").update(sessionId).digest("hex");
+  const rootDir = path.posix.join(
+    sandboxHomeDir,
+    ".ai-sdk",
+    "harness-acp",
+    harnessId,
+    sessionKey
+  );
+  assertOutsideSessionWorkDir({ rootDir, sessionWorkDir });
+  return rootDir;
+}
+async function materializeACPSkills({
+  sandbox,
+  sandboxHomeDir,
+  sessionWorkDir,
+  harnessId,
+  sessionId,
+  skills,
+  shouldMaterialize,
+  abortSignal
+}) {
+  validateACPSkills({ skills });
+  const rootDir = path.posix.join(
+    resolveACPPrivateSessionDirectory({
+      sandboxHomeDir,
+      sessionWorkDir,
+      harnessId,
+      sessionId
+    }),
+    "skills"
+  );
+  if (shouldMaterialize) {
+    await writeSkills({
+      sandbox,
+      rootDir,
+      skills,
+      abortSignal,
+      skillNamePattern: ACP_SKILL_NAME_PATTERN,
+      invalidSkillNameMessage: ({ name }) => `Invalid ACP skill name ${JSON.stringify(name)}: expected a kebab-case slug.`,
+      invalidSkillFilePathMessage: ({ skillName, filePath }) => `Invalid ACP skill file path ${JSON.stringify(filePath)} for skill ${JSON.stringify(
+        skillName
+      )}: expected a relative POSIX path without traversal.`
+    });
+  }
+  return {
+    rootDir,
+    catalog: skills.map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      path: path.posix.join(rootDir, skill.name, "SKILL.md")
+    }))
+  };
+}
+function validateACPSkills({
+  skills
+}) {
+  const skillNames = /* @__PURE__ */ new Set();
+  for (const skill of skills) {
+    if (!ACP_SKILL_NAME_PATTERN.test(skill.name) || skill.name === "." || skill.name === "..") {
+      throw new Error(
+        `Invalid ACP skill name ${JSON.stringify(skill.name)}: expected a kebab-case slug.`
+      );
+    }
+    if (skillNames.has(skill.name)) {
+      throw new Error(
+        `Duplicate ACP skill name ${JSON.stringify(skill.name)}.`
+      );
+    }
+    skillNames.add(skill.name);
+    const filePaths = /* @__PURE__ */ new Set();
+    for (const file of skill.files ?? []) {
+      const normalizedPath = validateACPAttachedFilePath({
+        skillName: skill.name,
+        filePath: file.path
+      });
+      if (normalizedPath === "SKILL.md") {
+        throw new Error(
+          `Invalid ACP skill file path ${JSON.stringify(file.path)} for skill ${JSON.stringify(
+            skill.name
+          )}: SKILL.md is reserved for the skill definition.`
+        );
+      }
+      if (filePaths.has(normalizedPath)) {
+        throw new Error(
+          `Duplicate ACP skill file path ${JSON.stringify(file.path)} for skill ${JSON.stringify(
+            skill.name
+          )}.`
+        );
+      }
+      filePaths.add(normalizedPath);
+    }
+  }
+}
+function validateACPAttachedFilePath({
+  skillName,
+  filePath
+}) {
+  const containsTraversal = filePath.split(/[\\/]/).some((segment) => segment === "..");
+  const normalizedPath = path.posix.normalize(filePath);
+  const invalid = filePath.length === 0 || filePath.endsWith("/") || filePath.includes("\\") || path.posix.isAbsolute(filePath) || path.win32.isAbsolute(filePath) || containsTraversal || normalizedPath === "." || normalizedPath.startsWith("../") || normalizedPath.includes("/../") || normalizedPath.endsWith("/..");
+  if (invalid) {
+    throw new Error(
+      `Invalid ACP skill file path ${JSON.stringify(filePath)} for skill ${JSON.stringify(
+        skillName
+      )}: expected a relative POSIX path without traversal.`
+    );
+  }
+  return normalizedPath;
+}
+function assertOutsideSessionWorkDir({
+  rootDir,
+  sessionWorkDir
+}) {
+  const relative = path.posix.relative(sessionWorkDir, rootDir);
+  const isInside = relative === "" || !relative.startsWith("../") && !path.posix.isAbsolute(relative);
+  if (isInside) {
+    throw new Error(
+      `ACP skill directory ${JSON.stringify(rootDir)} must be outside sessionWorkDir ${JSON.stringify(
+        sessionWorkDir
+      )}.`
+    );
+  }
+}
+function compareCanonicalStrings({
+  left,
+  right
+}) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// src/v1/acp-v1-harness.ts
+var HARNESS_ID_REGEXP = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function createACPV1({
+  settings,
+  builtinTools,
+  port: portOverride,
+  startupTimeoutMs,
+  clientApp,
+  implementationIdentity,
+  authenticationProfile,
+  providerAuthenticationCompatibility,
+  lifecycleStateSchema
+}) {
+  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 BOOTSTRAP_DIR = `.harness-bootstrap/${settings.harnessId}`;
+  let cachedBootstrap;
+  const permissionModeMapping = isCompletePermissionModeMapping({
+    value: settings.permissionModeMapping
+  }) ? settings.permissionModeMapping : void 0;
+  return {
+    specificationVersion: "harness-v1",
+    harnessId: settings.harnessId,
+    builtinTools,
+    supportsBuiltinToolApprovals: true,
+    supportsBuiltinToolFiltering: false,
+    lifecycleStateSchema,
+    getBootstrap: async () => {
+      if (cachedBootstrap != null) return cachedBootstrap;
+      const [bridgePackage, bridgeLock, bridge, hostToolMCP] = await Promise.all([
+        readBridgeAsset({ name: "package.json" }),
+        readBridgeAsset({ name: "pnpm-lock.yaml" }),
+        readBridgeAsset({ name: "index.mjs" }),
+        readBridgeAsset({ name: "host-tool-mcp.mjs" })
+      ]);
+      const implementationLock = getImplementationLockfile({
+        implementation: settings.implementation
+      });
+      cachedBootstrap = {
+        harnessId: settings.harnessId,
+        bootstrapDir: BOOTSTRAP_DIR,
+        files: [
+          {
+            path: `${BOOTSTRAP_DIR}/package.json`,
+            content: bridgePackage
+          },
+          {
+            path: `${BOOTSTRAP_DIR}/pnpm-lock.yaml`,
+            content: bridgeLock
+          },
+          { path: `${BOOTSTRAP_DIR}/bridge.mjs`, content: bridge },
+          {
+            path: `${BOOTSTRAP_DIR}/host-tool-mcp.mjs`,
+            content: hostToolMCP
+          },
+          {
+            path: `${BOOTSTRAP_DIR}/implementation/package.json`,
+            content: createImplementationManifest({
+              implementation: settings.implementation
+            })
+          },
+          {
+            path: `${BOOTSTRAP_DIR}/implementation/implementation.json`,
+            content: createImplementationDescriptor({
+              implementation: settings.implementation,
+              implementationIdentity
+            })
+          },
+          ...implementationLock == null ? [] : [
+            {
+              path: `${BOOTSTRAP_DIR}/implementation/pnpm-lock.yaml`,
+              content: implementationLock
+            }
+          ]
+        ],
+        commands: [
+          {
+            command: "pnpm install --frozen-lockfile --store-dir .pnpm-store"
+          },
+          {
+            command: createImplementationInstallCommand({
+              implementationDir: "implementation",
+              storeDir: "../.pnpm-store",
+              implementation: settings.implementation
+            })
+          }
+        ]
+      };
+      return cachedBootstrap;
+    },
+    doStart: async (startOptions) => {
+      if (startOptions.builtinToolFiltering != null) {
+        throw unsupported({
+          harnessId: settings.harnessId,
+          message: "ACP built-in tool filtering is not available in this initial ACP v1 implementation."
+        });
+      }
+      const permissionMode = startOptions.permissionMode ?? "allow-all";
+      const resolvedProviderAuthentication = resolveACPProviderAuthentication({
+        auth: {
+          mode: settings.auth,
+          providerAuthentication: settings.providerAuthentication,
+          clientApp
+        },
+        env: process.env,
+        compatibility: providerAuthenticationCompatibility
+      });
+      const sandboxSession = startOptions.sandboxSession;
+      const sandbox = sandboxSession.restricted();
+      const resolvedBridgeDir = posix.resolve(
+        sandboxSession.defaultWorkingDirectory,
+        BOOTSTRAP_DIR
+      );
+      const resolvedImplementationDir = `${resolvedBridgeDir}/implementation`;
+      const workDir = startOptions.sessionWorkDir;
+      const sandboxHomeDir = await resolveSandboxHomeDir({
+        sandbox,
+        abortSignal: startOptions.abortSignal
+      });
+      const privateSessionDir = resolveACPPrivateSessionDirectory({
+        sandboxHomeDir,
+        sessionWorkDir: workDir,
+        harnessId: settings.harnessId,
+        sessionId: startOptions.sessionId
+      });
+      const bridgeStateDir = `${privateSessionDir}/bridge`;
+      const continueFrom = startOptions.continueFrom ?? startOptions.resumeFrom?.continueFrom;
+      const lifecycleState = continueFrom ?? startOptions.resumeFrom;
+      const isContinue = continueFrom != null;
+      const isResume = lifecycleState != null;
+      const lifecycleData = lifecycleState != null ? lifecycleState.data : void 0;
+      if (lifecycleData != null && lifecycleState != null) {
+        validateACPLifecycleCompatibility({
+          harnessId: settings.harnessId,
+          lifecycleHarnessId: lifecycleState.harnessId,
+          implementationIdentity,
+          authenticationProfile,
+          lifecycleData,
+          sandboxId: sandboxSession.id
+        });
+      }
+      const skills = startOptions.skills ?? [];
+      const skillsFingerprint = createACPSkillsFingerprint({ skills });
+      const shouldMaterializeSkills = shouldMaterializeACPSkills({
+        isResume,
+        lifecycleState: lifecycleData,
+        skillsFingerprint
+      });
+      let skillCatalog = [];
+      if (skills.length > 0) {
+        skillCatalog = (await materializeACPSkills({
+          sandbox,
+          sandboxHomeDir,
+          sessionWorkDir: workDir,
+          harnessId: settings.harnessId,
+          sessionId: startOptions.sessionId,
+          skills,
+          shouldMaterialize: shouldMaterializeSkills,
+          abortSignal: startOptions.abortSignal
+        })).catalog;
+      }
+      const report = startOptions.observability?.report;
+      const onDiagnostic = report ? (frame) => report(
+        harnessV1DiagnosticFromBridgeFrame(frame, {
+          sessionId: startOptions.sessionId,
+          timestamp: Date.now()
+        })
+      ) : void 0;
+      const onBridgeError = createBridgeErrorHandler({
+        harnessId: settings.harnessId,
+        sessionId: startOptions.sessionId
+      });
+      const builtinToolCatalog = serializeBuiltinTools({ builtinTools });
+      let respawnStrategy;
+      if (isResume) {
+        if (lifecycleData == null) {
+          throw new Error("ACP lifecycle state data is missing.");
+        }
+        const coords = lifecycleData.bridge;
+        if (coords == null && isContinue) {
+          throw unsupported({
+            harnessId: settings.harnessId,
+            message: "ACP continuation state does not contain bridge coordinates required for replay or process-loss rerun."
+          });
+        }
+        if (coords != null) {
+          try {
+            const attachUrl = await sandboxSession.getPortUrl({
+              port: coords.port,
+              protocol: "ws"
+            }) + `?agent_bridge_token=${encodeURIComponent(coords.token)}`;
+            const attachChannel = new SandboxChannel({
+              connect: () => openWebSocket({ url: attachUrl }),
+              outboundSchema: outboundMessageSchema,
+              initialLastSeenEventId: coords.lastSeenEventId,
+              onDiagnostic,
+              onBridgeError
+            });
+            await attachChannel.open(isContinue ? { resume: true } : void 0);
+            return createSession({
+              sessionId: startOptions.sessionId,
+              harnessId: settings.harnessId,
+              channel: attachChannel,
+              proc: void 0,
+              modelId: settings.modelId,
+              sessionMeta: settings.session?.meta,
+              debug: startOptions.observability?.debug,
+              implementationIdentity,
+              authenticationProfile,
+              builtinTools: builtinToolCatalog,
+              permissionMode,
+              permissionModeMapping,
+              initialGuidanceApplied: resolveACPInitialGuidanceApplied({
+                isResume: true,
+                lifecycleState: lifecycleData
+              }),
+              skillCatalog,
+              skillsFingerprint,
+              acpSessionId: lifecycleData.acpSessionId,
+              bridgePort: coords.port,
+              bridgeToken: coords.token,
+              sandboxId: sandboxSession.id,
+              isResume: true,
+              turnInFlight: isContinue,
+              bridgeStateDir,
+              turnStartConfig: lifecycleData.turnStartConfig,
+              recoveryStatus: lifecycleData.recovery,
+              restoration: lifecycleData.restoration,
+              replayOnly: false,
+              lossyRerun: false
+            });
+          } catch (error) {
+            if (isContinue) {
+              const eventLog = await Promise.resolve(
+                sandbox.readTextFile({
+                  path: `${bridgeStateDir}/event-log.ndjson`,
+                  abortSignal: startOptions.abortSignal
+                })
+              );
+              const recoveryMode = await classifyDiskLog(eventLog);
+              if (recoveryMode === "replay") {
+                respawnStrategy = {
+                  mode: "disk-replay",
+                  reason: "completed coherent event log",
+                  afterSeq: coords.lastSeenEventId
+                };
+              } else {
+                const turnStartConfig = lifecycleData.turnStartConfig;
+                const acpSessionId = lifecycleData.acpSessionId;
+                if (turnStartConfig == null || acpSessionId == null) {
+                  throw unsupported({
+                    harnessId: settings.harnessId,
+                    message: "ACP process-loss recovery is unavailable because the lifecycle state does not contain the persisted turn start configuration and ACP session identifier.",
+                    cause: error
+                  });
+                }
+                validateACPTurnStartConfig({
+                  turnStartConfig,
+                  authenticationProfile,
+                  sessionMeta: settings.session?.meta,
+                  builtinTools: builtinToolCatalog,
+                  permissionModeMapping
+                });
+                respawnStrategy = {
+                  mode: "lossy-rerun",
+                  reason: "event log not replayable",
+                  turnStartConfig,
+                  acpSessionId
+                };
+              }
+            }
+          }
+        }
+        if (!isContinue) {
+          const coldSession = lifecycleData.coldSession;
+          const acpSessionId = lifecycleData.acpSessionId;
+          if (coldSession == null || acpSessionId == null) {
+            throw unsupported({
+              harnessId: settings.harnessId,
+              message: "Cold ACP session restoration requires persisted cold-session configuration and an ACP session identifier."
+            });
+          }
+          const turnStartConfig = validateACPColdSessionConfiguration({
+            coldSession,
+            modelId: settings.modelId,
+            permissionMode,
+            authenticationProfile,
+            sessionMeta: settings.session?.meta,
+            builtinTools: builtinToolCatalog,
+            permissionModeMapping,
+            debug: startOptions.observability?.debug
+          });
+          respawnStrategy = {
+            mode: "cold-restore",
+            turnStartConfig,
+            acpSessionId
+          };
+        }
+      }
+      const port = resolveBridgePort({
+        sandboxSession,
+        override: portOverride,
+        harnessId: settings.harnessId
+      });
+      const token = randomBytes(32).toString("hex");
+      await sandbox.run({
+        command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)}`,
+        abortSignal: startOptions.abortSignal
+      });
+      await markBridgeStarting({
+        sandbox,
+        bridgeStateDir,
+        bridgeType: settings.harnessId,
+        abortSignal: startOptions.abortSignal
+      });
+      const proc = await sandbox.spawn({
+        command: `node ${shellQuote(`${resolvedBridgeDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)} --implementation-dir ${shellQuote(resolvedImplementationDir)} --bridge-type ${shellQuote(settings.harnessId)}`,
+        env: {
+          ...resolveImplementationEnvironment({
+            implementation: settings.implementation,
+            env: process.env
+          }),
+          ...createACPBridgeEnvironment({
+            authentication: settings.authentication,
+            providerAuthentication: resolvedProviderAuthentication.providerAuthentication,
+            sessionMeta: settings.session?.meta
+          }),
+          ...resolvedProviderAuthentication.env,
+          BRIDGE_CHANNEL_TOKEN: token,
+          BRIDGE_WS_PORT: String(port),
+          ...respawnStrategy?.mode === "disk-replay" ? {
+            BRIDGE_REPLAY_FROM_DISK: "1"
+          } : {}
+        },
+        abortSignal: startOptions.abortSignal
+      });
+      const stderrTail = [];
+      const bridgeStderrDone = forwardBridgeProcessStream({
+        stream: proc.stderr,
+        streamName: "stderr",
+        source: settings.harnessId,
+        collectTail: stderrTail
+      });
+      const timeoutMs = startupTimeoutMs ?? 12e4;
+      const { port: boundPort } = await waitForBridgeReady({
+        proc,
+        sandbox,
+        bridgeStateDir,
+        bridgeType: settings.harnessId,
+        timeoutMs,
+        abortSignal: startOptions.abortSignal,
+        createTimeoutError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
+          message: `${settings.harnessId} ACP bridge did not become ready in time.`,
+          proc: proc2,
+          stdoutTail,
+          stderrTail,
+          stderrDone: bridgeStderrDone
+        }),
+        createExitError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
+          message: `${settings.harnessId} ACP bridge exited before becoming ready.`,
+          proc: proc2,
+          stdoutTail,
+          stderrTail,
+          stderrDone: bridgeStderrDone
+        })
+      });
+      void drainBridgeProcessStream(proc.stdout);
+      const wsUrl = await sandboxSession.getPortUrl({
+        port: boundPort,
+        protocol: "ws"
+      }) + `?agent_bridge_token=${encodeURIComponent(token)}`;
+      const channel = new SandboxChannel({
+        connect: () => openWebSocket({ url: wsUrl }),
+        outboundSchema: outboundMessageSchema,
+        ...respawnStrategy?.mode === "disk-replay" ? { initialLastSeenEventId: respawnStrategy.afterSeq } : {},
+        onDiagnostic,
+        onBridgeError
+      });
+      await channel.open(
+        respawnStrategy?.mode === "disk-replay" ? { resume: true } : void 0
+      );
+      let coldRestoration;
+      if (respawnStrategy?.mode === "cold-restore") {
+        try {
+          coldRestoration = await restoreColdACPSession({
+            channel,
+            harnessId: settings.harnessId,
+            start: {
+              type: "start",
+              prompt: [],
+              debug: startOptions.observability?.debug,
+              builtinTools: builtinToolCatalog,
+              permissionMode,
+              permissionModeMapping,
+              tools: respawnStrategy.turnStartConfig.tools,
+              turnStartConfig: respawnStrategy.turnStartConfig,
+              recoveryMode: {
+                type: "cold-restore",
+                acpSessionId: respawnStrategy.acpSessionId
+              }
+            }
+          });
+        } catch (error) {
+          channel.beginClose();
+          try {
+            if (!channel.isClosed()) {
+              channel.send({ type: "destroy" });
+            }
+          } catch {
+          }
+          try {
+            await proc.kill();
+          } catch {
+          }
+          channel.close();
+          throw error;
+        }
+      }
+      return createSession({
+        sessionId: startOptions.sessionId,
+        harnessId: settings.harnessId,
+        channel,
+        proc,
+        modelId: settings.modelId,
+        sessionMeta: settings.session?.meta,
+        debug: startOptions.observability?.debug,
+        implementationIdentity,
+        authenticationProfile,
+        builtinTools: builtinToolCatalog,
+        permissionMode,
+        permissionModeMapping,
+        initialGuidanceApplied: resolveACPInitialGuidanceApplied({
+          isResume,
+          lifecycleState: lifecycleData
+        }),
+        skillCatalog,
+        skillsFingerprint,
+        acpSessionId: lifecycleData?.acpSessionId,
+        bridgePort: boundPort,
+        bridgeToken: token,
+        sandboxId: sandboxSession.id,
+        isResume,
+        turnInFlight: respawnStrategy?.mode === "disk-replay" || respawnStrategy?.mode === "lossy-rerun",
+        bridgeStateDir,
+        turnStartConfig: respawnStrategy?.mode === "lossy-rerun" || respawnStrategy?.mode === "cold-restore" ? respawnStrategy.turnStartConfig : lifecycleData?.turnStartConfig,
+        recoveryStatus: respawnStrategy?.mode === "disk-replay" || respawnStrategy?.mode === "lossy-rerun" ? {
+          mode: respawnStrategy.mode,
+          reason: respawnStrategy.reason
+        } : void 0,
+        restoration: coldRestoration == null ? lifecycleData?.restoration : { method: coldRestoration },
+        replayOnly: respawnStrategy?.mode === "disk-replay",
+        lossyRerun: respawnStrategy?.mode === "lossy-rerun"
+      });
+    }
+  };
+}
+async function readBridgeAsset({ name }) {
+  const candidates = resolveBridgeAssetCandidates({
+    name,
+    moduleUrl: import.meta.url
+  });
+  let lastError;
+  for (const url of candidates) {
+    try {
+      return await readFile(fileURLToPath(url), "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      lastError = error;
+    }
+  }
+  throw lastError ?? new Error(`ACP bridge asset not found: ${name}`);
+}
+function resolveBridgeAssetCandidates({
+  name,
+  moduleUrl
+}) {
+  return [
+    new URL(`./bridge/${name}`, moduleUrl),
+    new URL(`../bridge/${name}`, moduleUrl)
+  ];
+}
+function resolveBridgePort({
+  sandboxSession,
+  override,
+  harnessId
+}) {
+  if (override !== void 0) return override;
+  if (sandboxSession.ports.length > 0) return sandboxSession.ports[0];
+  throw unsupported({
+    harnessId,
+    message: `The ${harnessId} ACP harness needs a TCP port exposed by the sandbox. Create the sandbox with \`ports: [<port>]\` or configure the harness \`port\`.`
+  });
+}
+function openWebSocket({ url }) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const onOpen = () => {
+      ws.off("error", onError);
+      resolve(ws);
+    };
+    const onError = (error) => {
+      ws.off("open", onOpen);
+      reject(error);
+    };
+    ws.once("open", onOpen);
+    ws.once("error", onError);
+  });
+}
+function restoreColdACPSession({
+  channel,
+  harnessId,
+  start
+}) {
+  return new Promise((complete) => {
+    let restorationMethod;
+    let settled = false;
+    const subscriptions = [];
+    const cleanup = () => {
+      for (const unsubscribe of subscriptions) unsubscribe();
+    };
+    const settle = ({
+      method,
+      error
+    }) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      complete({
+        ...method == null ? {} : { method },
+        ...error === void 0 ? {} : { error }
+      });
+    };
+    subscriptions.push(
+      channel.on("raw", (event) => {
+        const rawValue = event.rawValue;
+        if (isRecord(rawValue) && rawValue.type === "acp-session-restored" && (rawValue.method === "resume" || rawValue.method === "load")) {
+          restorationMethod = rawValue.method;
+        }
+      })
+    );
+    subscriptions.push(
+      channel.on("finish", () => {
+        settle({ method: restorationMethod });
+      })
+    );
+    subscriptions.push(
+      channel.on("error", (event) => {
+        settle({
+          error: deserializeBridgeError({
+            error: event.error,
+            harnessId
+          })
+        });
+      })
+    );
+    channel.onClose((_code, reason) => {
+      settle({
+        error: new Error(
+          `${harnessId} ACP bridge closed during cold restoration: ${reason}`
+        )
+      });
+    });
+    try {
+      channel.send(start);
+    } catch (error) {
+      settle({ error });
+    }
+  }).then((result) => {
+    if (result.error !== void 0) throw result.error;
+    if (result.method == null) {
+      throw new Error(
+        `${harnessId} ACP cold restoration completed without identifying the negotiated method.`
+      );
+    }
+    return result.method;
+  });
+}
+function createSession({
+  sessionId,
+  harnessId,
+  channel,
+  proc,
+  modelId,
+  sessionMeta,
+  debug,
+  implementationIdentity,
+  authenticationProfile,
+  builtinTools,
+  permissionMode,
+  permissionModeMapping,
+  initialGuidanceApplied: initialGuidanceAppliedAtStart,
+  skillCatalog,
+  skillsFingerprint,
+  acpSessionId: acpSessionIdAtStart,
+  bridgePort,
+  bridgeToken,
+  sandboxId,
+  isResume,
+  turnInFlight: turnInFlightAtStart,
+  bridgeStateDir,
+  turnStartConfig: turnStartConfigAtStart,
+  recoveryStatus,
+  restoration,
+  replayOnly,
+  lossyRerun
+}) {
+  let stopped = false;
+  let turnInFlight = turnInFlightAtStart;
+  let initialGuidanceApplied = initialGuidanceAppliedAtStart;
+  let latestACPSessionId = acpSessionIdAtStart;
+  let latestTurnStartConfig = turnStartConfigAtStart;
+  const markTurnFinished = () => {
+    turnInFlight = false;
+  };
+  channel.on("bridge-thread", (event) => {
+    latestACPSessionId = event.threadId;
+  });
+  channel.on("finish", markTurnFinished);
+  channel.on("error", markTurnFinished);
+  channel.onClose(markTurnFinished);
+  const wireTurn = ({
+    emit,
+    abortSignal,
+    start
+  }) => {
+    let resolveDone;
+    let rejectDone;
+    const done = new Promise((resolve, reject) => {
+      resolveDone = resolve;
+      rejectDone = reject;
+    });
+    let settled = false;
+    let abortRequested = false;
+    let abortError;
+    let abortListenerAttached = false;
+    let openBlock;
+    const subscriptions = [];
+    const forward = (event) => {
+      if (event.type === "text-start" || event.type === "reasoning-start") {
+        openBlock = {
+          type: event.type === "text-start" ? "text" : "reasoning",
+          id: event.id
+        };
+      } else if ((event.type === "text-end" || event.type === "reasoning-end") && openBlock?.id === event.id) {
+        openBlock = void 0;
+      }
+      try {
+        emit(event);
+      } catch {
+      }
+    };
+    const closeForwardedBlock = () => {
+      if (openBlock == null) return;
+      const block = openBlock;
+      openBlock = void 0;
+      forward({
+        type: block.type === "text" ? "text-end" : "reasoning-end",
+        id: block.id
+      });
+    };
+    const eventTypes = [
+      "stream-start",
+      "text-start",
+      "text-delta",
+      "text-end",
+      "reasoning-start",
+      "reasoning-delta",
+      "reasoning-end",
+      "tool-call",
+      "tool-approval-request",
+      "tool-result",
+      "file-change",
+      "finish-step",
+      "raw"
+    ];
+    const cleanup = () => {
+      for (const unsubscribe of subscriptions) unsubscribe();
+      if (abortListenerAttached) {
+        abortSignal?.removeEventListener("abort", onAbort);
+      }
+    };
+    const settle = ({ error }) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error === void 0) resolveDone();
+      else rejectDone(error);
+    };
+    const onAbort = () => {
+      if (settled || abortRequested) return;
+      abortRequested = true;
+      abortError = abortSignal?.reason ?? new DOMException("Aborted", "AbortError");
+      try {
+        channel.send({ type: "abort" });
+      } catch {
+        settle({ error: abortError });
+      }
+    };
+    for (const type of eventTypes) {
+      subscriptions.push(channel.on(type, (event) => forward(event)));
+    }
+    subscriptions.push(
+      channel.on("finish", (event) => {
+        closeForwardedBlock();
+        forward(event);
+        settle(abortRequested ? { error: abortError } : {});
+      })
+    );
+    subscriptions.push(
+      channel.on("error", (event) => {
+        closeForwardedBlock();
+        const error = deserializeBridgeError({
+          error: event.error,
+          harnessId
+        });
+        forward({ ...event, error });
+        settle({ error });
+      })
+    );
+    channel.onClose((_code, reason) => {
+      if (reason === "suspended") {
+        settle({});
+        return;
+      }
+      closeForwardedBlock();
+      settle({
+        error: abortRequested && abortError !== void 0 ? abortError : new Error(`${harnessId} ACP bridge closed before turn end.`)
+      });
+    });
+    try {
+      start();
+    } catch (error) {
+      settled = true;
+      cleanup();
+      throw error;
+    }
+    if (abortSignal?.aborted) onAbort();
+    else if (abortSignal != null) {
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+      abortListenerAttached = true;
+    }
+    return {
+      submitToolApproval: async (input) => {
+        channel.send({
+          type: "tool-approval-response",
+          approvalId: input.approvalId,
+          approved: input.approved,
+          reason: input.reason
+        });
+      },
+      submitToolResult: async (input) => {
+        channel.send({
+          type: "tool-result",
+          toolCallId: input.toolCallId,
+          output: input.output,
+          isError: input.isError
+        });
+      },
+      done
+    };
+  };
+  const terminateBridge = async ({
+    command
+  }) => {
+    if (stopped) return;
+    stopped = true;
+    channel.beginClose();
+    const channelClosed = new Promise((resolve) => {
+      channel.onClose(() => resolve());
+    });
+    try {
+      if (!channel.isClosed()) {
+        channel.send({ type: command });
+      }
+    } catch {
+    }
+    let timer;
+    try {
+      await Promise.race([
+        proc == null ? channelClosed : proc.wait(),
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, 5e3);
+          timer.unref?.();
+        })
+      ]);
+    } finally {
+      if (timer != null) clearTimeout(timer);
+      try {
+        await proc?.kill();
+      } catch {
+      }
+      channel.close();
+    }
+  };
+  const createLifecycleData = ({
+    bridge,
+    includeTurnStartConfig = true
+  }) => ({
+    implementationIdentity,
+    authenticationProfile,
+    ...latestACPSessionId == null ? {} : { acpSessionId: latestACPSessionId },
+    ...bridge == null ? {} : { bridge },
+    ...latestTurnStartConfig == null ? {} : {
+      coldSession: createACPColdSessionState({
+        turnStartConfig: latestTurnStartConfig,
+        modelId
+      })
+    },
+    ...!includeTurnStartConfig || latestTurnStartConfig == null ? {} : { turnStartConfig: latestTurnStartConfig },
+    ...recoveryStatus == null ? {} : { recovery: recoveryStatus },
+    ...restoration == null ? {} : { restoration },
+    initialGuidanceApplied,
+    skillsMaterialized: true,
+    skillsFingerprint
+  });
+  return {
+    sessionId,
+    isResume,
+    ...modelId == null ? {} : { modelId },
+    doPromptTurn: async (options) => {
+      if (replayOnly) {
+        throw new Error(
+          `${harnessId} recovered this turn through disk replay only and has no restored ACP process for a subsequent prompt.`
+        );
+      }
+      if (options.abortSignal?.aborted) {
+        throw options.abortSignal.reason ?? new DOMException("Aborted", "AbortError");
+      }
+      const prompt = convertHarnessPromptToACPTextBlocks({
+        prompt: options.prompt,
+        harnessId
+      });
+      const turnStartConfig = createACPTurnStartConfig({
+        prompt,
+        tools: options.tools ?? [],
+        builtinTools,
+        permissionMode,
+        permissionModeMapping,
+        debug,
+        authenticationProfile,
+        sessionMeta
+      });
+      const control = wireTurn({
+        emit: options.emit,
+        abortSignal: options.abortSignal,
+        start: () => {
+          if (turnInFlight) {
+            throw new Error(
+              `${harnessId} cannot start a new ACP prompt while a turn is in flight.`
+            );
+          }
+          turnInFlight = true;
+          channel.send({
+            type: "start",
+            prompt: initialGuidanceApplied ? prompt : prependACPInitialGuidance({
+              prompt,
+              instructions: options.instructions,
+              skills: skillCatalog
+            }),
+            debug,
+            builtinTools,
+            permissionMode,
+            permissionModeMapping,
+            tools: options.tools == null ? void 0 : turnStartConfig.tools,
+            turnStartConfig
+          });
+          latestTurnStartConfig = turnStartConfig;
+          initialGuidanceApplied = true;
+        }
+      });
+      return control;
+    },
+    doContinueTurn: async (options) => {
+      if (!turnInFlight) {
+        throw new Error(`${harnessId} has no in-flight ACP turn to continue.`);
+      }
+      if (lossyRerun) {
+        if (latestTurnStartConfig == null || latestACPSessionId == null) {
+          throw new Error(
+            `${harnessId} cannot perform lossy ACP rerun without persisted start configuration and an ACP session identifier.`
+          );
+        }
+        assertRecoveryToolCatalog({
+          persisted: latestTurnStartConfig.tools,
+          current: options.tools ?? []
+        });
+      }
+      return wireTurn({
+        emit: options.emit,
+        abortSignal: options.abortSignal,
+        start: () => {
+          if (!lossyRerun) return;
+          const turnStartConfig = latestTurnStartConfig;
+          channel.send({
+            type: "start",
+            prompt: turnStartConfig.prompt,
+            debug: turnStartConfig.debug,
+            builtinTools: turnStartConfig.builtinTools,
+            permissionMode: turnStartConfig.permissionMode,
+            permissionModeMapping: turnStartConfig.permissionModeMapping,
+            tools: turnStartConfig.tools,
+            turnStartConfig,
+            recoveryMode: {
+              type: "lossy-rerun",
+              acpSessionId: latestACPSessionId,
+              reason: recoveryStatus?.reason ?? "bridge process loss"
+            }
+          });
+        }
+      });
+    },
+    doCompact: async () => {
+      throw unsupported({
+        harnessId,
+        message: "ACP v1 does not define manual session compaction."
+      });
+    },
+    doSuspendTurn: async () => {
+      if (stopped) {
+        throw new Error(
+          `${harnessId} ACP session ${sessionId} is stopped; cannot suspend.`
+        );
+      }
+      if (!turnInFlight) {
+        throw new Error(
+          `${harnessId} ACP session ${sessionId} has no in-flight turn to suspend.`
+        );
+      }
+      stopped = true;
+      const lastSeenEventId = await channel.suspend();
+      return {
+        type: "continue-turn",
+        harnessId,
+        specificationVersion: "harness-v1",
+        data: createLifecycleData({
+          bridge: {
+            port: bridgePort,
+            token: bridgeToken,
+            lastSeenEventId,
+            ...sandboxId == null ? {} : { sandboxId },
+            stateDir: bridgeStateDir
+          }
+        })
+      };
+    },
+    doDetach: async () => {
+      if (stopped) {
+        throw new Error(
+          `${harnessId} ACP session ${sessionId} is stopped; cannot detach.`
+        );
+      }
+      if (turnInFlight) {
+        throw new Error(
+          `${harnessId} ACP session ${sessionId} has an in-flight turn; suspend it instead.`
+        );
+      }
+      stopped = true;
+      const lastSeenEventId = await channel.suspend();
+      return {
+        type: "resume-session",
+        harnessId,
+        specificationVersion: "harness-v1",
+        data: createLifecycleData({
+          bridge: {
+            port: bridgePort,
+            token: bridgeToken,
+            lastSeenEventId,
+            ...sandboxId == null ? {} : { sandboxId },
+            stateDir: bridgeStateDir
+          }
+        })
+      };
+    },
+    doStop: async () => {
+      const data = createLifecycleData({ includeTurnStartConfig: false });
+      await terminateBridge({ command: "stop" });
+      return {
+        type: "resume-session",
+        harnessId,
+        specificationVersion: "harness-v1",
+        data
+      };
+    },
+    doDestroy: async () => {
+      await terminateBridge({ command: "destroy" });
+    }
+  };
+}
+function isCompletePermissionModeMapping({
+  value
+}) {
+  return isPermissionModeMappingValue({ value: value?.["allow-reads"] }) && isPermissionModeMappingValue({ value: value?.["allow-edits"] }) && isPermissionModeMappingValue({ value: value?.["allow-all"] });
+}
+function isPermissionModeMappingValue({
+  value
+}) {
+  return value === null || isPermissionModeTarget({ value });
+}
+function isPermissionModeTarget({
+  value
+}) {
+  if (value?.type === "session-mode") {
+    return typeof value.modeId === "string";
+  }
+  return value?.type === "session-config-option" && typeof value.configId === "string" && (typeof value.value === "string" || typeof value.value === "boolean");
+}
+function serializeBuiltinTools({
+  builtinTools
+}) {
+  return Object.entries(builtinTools).map(([toolName, tool]) => {
+    const nativeName = tool != null && typeof tool === "object" && "nativeName" in tool && typeof tool.nativeName === "string" ? tool.nativeName : void 0;
+    let inputSchema;
+    if (tool != null && typeof tool === "object" && "inputSchema" in tool && tool.inputSchema != null) {
+      try {
+        inputSchema = asSchema(
+          tool.inputSchema
+        ).jsonSchema;
+      } catch {
+      }
+    }
+    return {
+      toolName,
+      ...nativeName == null ? {} : { nativeName },
+      ...inputSchema == null ? {} : { inputSchema }
+    };
+  });
+}
+function validateACPTurnStartConfig({
+  turnStartConfig,
+  authenticationProfile,
+  sessionMeta,
+  builtinTools,
+  permissionModeMapping
+}) {
+  const current = createACPTurnStartConfig({
+    prompt: turnStartConfig.prompt,
+    tools: turnStartConfig.tools,
+    builtinTools,
+    permissionMode: turnStartConfig.permissionMode,
+    permissionModeMapping,
+    debug: turnStartConfig.debug,
+    authenticationProfile,
+    sessionMeta
+  });
+  if (current.configurationFingerprint !== turnStartConfig.configurationFingerprint) {
+    throw new Error(
+      "The persisted ACP turn start configuration is incompatible with the current non-secret start configuration."
+    );
+  }
+}
+function validateACPColdSessionConfiguration({
+  coldSession,
+  modelId,
+  permissionMode,
+  authenticationProfile,
+  sessionMeta,
+  builtinTools,
+  permissionModeMapping,
+  debug
+}) {
+  const current = createACPTurnStartConfig({
+    prompt: [],
+    tools: coldSession.tools,
+    builtinTools,
+    permissionMode,
+    permissionModeMapping,
+    debug,
+    authenticationProfile,
+    sessionMeta
+  });
+  if (current.configurationFingerprint !== coldSession.configurationFingerprint || coldSession.permissionMode !== permissionMode || coldSession.modelId !== modelId) {
+    throw new Error(
+      "ACP cold-session state is incompatible with the current non-secret session configuration."
+    );
+  }
+  return current;
+}
+function assertRecoveryToolCatalog({
+  persisted,
+  current
+}) {
+  if (fingerprintValue({ value: persisted }) !== fingerprintValue({ value: current })) {
+    throw new Error(
+      "ACP lossy rerun requires the same active host tool catalog as the original turn."
+    );
+  }
+}
+function fingerprintValue({ value }) {
+  return createHash5("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function unsupported({
+  harnessId,
+  message,
+  cause
+}) {
+  return new HarnessCapabilityUnsupportedError2({
+    harnessId,
+    message,
+    cause
+  });
+}
+function deserializeBridgeError({
+  error,
+  harnessId
+}) {
+  if (HarnessBridgeCapabilityUnsupportedError.isInstance(error)) {
+    return unsupported({ harnessId, message: error.message });
+  }
+  return error;
+}
+
+// src/version.ts
+var VERSION = true ? "1.0.0" : "0.0.0-test";
+
+// src/acp-harness.ts
+var ACP_CLIENT_APP = {
+  name: "ai-sdk/harness-acp",
+  version: VERSION
+};
+var ACP_BUILTIN_TOOLS = {};
+var acpBridgeCoordsSchema = z4.object({
+  port: z4.number(),
+  token: z4.string(),
+  lastSeenEventId: z4.number(),
+  sandboxId: z4.string().optional(),
+  stateDir: z4.string().optional()
+});
+var acpResumeStateSchema = z4.object({
+  implementationIdentity: z4.string(),
+  authenticationProfile: z4.object({
+    digest: z4.string(),
+    acpMethodId: z4.string().optional(),
+    providerKind: z4.enum(["implementation-default", "direct", "ai-gateway"]).transform(
+      (value) => value === "implementation-default" ? "direct" : value
+    ),
+    providerMode: z4.enum(["auto", "direct", "ai-gateway"]).optional(),
+    gatewayCredentialSource: z4.enum(["AI_GATEWAY_API_KEY", "VERCEL_OIDC_TOKEN"]).nullable().optional()
+  }).optional(),
+  acpSessionId: z4.string().optional(),
+  bridge: acpBridgeCoordsSchema.optional(),
+  coldSession: acpColdSessionStateSchema.optional(),
+  turnStartConfig: acpTurnStartConfigSchema.optional(),
+  recovery: z4.object({
+    mode: z4.enum(["disk-replay", "lossy-rerun"]),
+    reason: z4.string()
+  }).optional(),
+  restoration: z4.object({
+    method: z4.enum(["resume", "load"])
+  }).optional(),
+  initialGuidanceApplied: z4.boolean().optional(),
+  skillsMaterialized: z4.boolean().optional(),
+  skillsFingerprint: z4.string().optional()
+});
+function createACP(settings) {
+  const version = settings.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 = acpResumeStateSchema.extend({
+        implementationIdentity: z4.literal(implementationIdentity),
+        authenticationProfile: acpResumeStateSchema.shape.authenticationProfile.unwrap().extend({
+          digest: z4.literal(authenticationProfile.digest)
+        }).optional()
+      });
+      return createACPV1({
+        settings,
+        builtinTools: settings.builtinTools ?? ACP_BUILTIN_TOOLS,
+        port: settings.port,
+        startupTimeoutMs: settings.startupTimeoutMs,
+        clientApp,
+        implementationIdentity,
+        authenticationProfile,
+        providerAuthenticationCompatibility,
+        lifecycleStateSchema
+      });
+    }
+    default:
+      throw new Error(
+        `Unsupported ACP protocol version ${JSON.stringify(version)}. Supported versions: "v1".`
+      );
+  }
+}
+export {
+  VERSION,
+  createACP
+};
+//# sourceMappingURL=index.js.map