@ai-sdk/harness-acp 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -14,28 +14,22 @@ type ACPValueSource = {
 type ACPProfileValue = ACPSerializablePrimitive | ACPValueSource | ReadonlyArray<ACPProfileValue> | {
     readonly [key: string]: ACPProfileValue;
 };
-type ACPNpmLaunchSettings = {
-    readonly type: 'npm';
-    readonly executable: string;
-    readonly args?: ReadonlyArray<string>;
-    readonly forwardEnv?: ReadonlyArray<string>;
+type ACPNpmSimpleSource = {
+    readonly type: 'npm-simple';
+    readonly packageName: string;
     /**
-     * Runtime environment values that are safe to persist in bootstrap and
-     * lifecycle compatibility identity.
+     * Exact version to install. When omitted, the package's `latest` dist-tag is
+     * installed and no version takes part in the implementation identity, so a
+     * new upstream release does not invalidate existing lifecycle state.
      */
-    readonly env?: Readonly<Record<string, string>>;
-};
-type ACPSimpleNpmImplementation = ACPNpmLaunchSettings & {
-    readonly mode: 'simple';
-    readonly packageName: string;
-    readonly version: string;
+    readonly packageVersion?: string;
 };
-type ACPLockedNpmImplementation = ACPNpmLaunchSettings & {
-    readonly mode: 'locked';
+type ACPNpmLockedSource = {
+    readonly type: 'npm-locked';
     readonly packageJson: string;
     readonly pnpmLockYaml: string;
 };
-type ACPNpmImplementation = ACPSimpleNpmImplementation | ACPLockedNpmImplementation;
+type ACPSource = ACPNpmSimpleSource | ACPNpmLockedSource;
 type ACPAuthentication = {
     readonly methodId: string;
     readonly meta?: Readonly<Record<string, ACPSerializableValue>>;
@@ -60,7 +54,15 @@ type ACPV1Settings = {
     readonly version?: 'v1';
     readonly harnessId: string;
     readonly auth?: ACPProviderAuthenticationMode;
-    readonly implementation: ACPNpmImplementation;
+    readonly source: ACPSource;
+    readonly executable: string;
+    readonly args?: ReadonlyArray<string>;
+    readonly forwardEnv?: ReadonlyArray<string>;
+    /**
+     * Runtime environment values that are safe to persist in bootstrap and
+     * lifecycle compatibility identity.
+     */
+    readonly env?: Readonly<Record<string, string>>;
     readonly authentication?: ACPAuthentication;
     readonly providerAuthentication?: ACPProviderAuthentication;
     readonly modelId?: string;
@@ -84,7 +86,11 @@ type ACPHarnessSettings<TBuiltinTools extends ToolSet = {}> = {
     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'];
@@ -95,4 +101,4 @@ declare function createACP<TBuiltinTools extends ToolSet = {}>(settings: ACPHarn
 
 declare const VERSION: string;
 
-export { type ACPAuthOptions, type ACPAuthentication, type ACPClientApp, type ACPHarnessSettings, type ACPLockedNpmImplementation, type ACPNpmImplementation, type ACPPermissionModeMapping, type ACPPermissionModeTarget, type ACPProfileValue, type ACPProviderAuthentication, type ACPProviderAuthenticationMode, type ACPSerializablePrimitive, type ACPSerializableValue, type ACPSimpleNpmImplementation, type ACPV1Settings, type ACPValueSource, VERSION, createACP };
+export { type ACPAuthOptions, type ACPAuthentication, type ACPClientApp, type ACPHarnessSettings, type ACPNpmLockedSource, type ACPNpmSimpleSource, type ACPPermissionModeMapping, type ACPPermissionModeTarget, type ACPProfileValue, type ACPProviderAuthentication, type ACPProviderAuthenticationMode, type ACPSerializablePrimitive, type ACPSerializableValue, type ACPSource, type ACPV1Settings, type ACPValueSource, VERSION, createACP };

package/dist/index.js

@@ -1,6 +1,33 @@
 // src/acp-harness.ts
 import { z as z4 } from "zod/v4";
 
+// 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/acp-auth.ts
 import { createHash } from "crypto";
 import { getAiGatewayAuthFromEnv } from "@ai-sdk/harness/utils";
@@ -145,53 +172,34 @@ function sortIdentityValue({ value }) {
   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";
+function createACPV1Implementation({
+  settings
+}) {
+  return {
+    source: settings.source,
+    executable: settings.executable,
+    args: settings.args,
+    forwardEnv: settings.forwardEnv,
+    env: settings.env
+  };
+}
 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."
-      );
+  const { source } = implementation;
+  if (source.type === "npm-locked") {
+    if (source.packageJson.length === 0) {
+      throw new Error("ACP source.packageJson must not be empty.");
     }
-    if (implementation.pnpmLockYaml.length === 0) {
-      throw new Error(
-        "ACP locked npm implementation pnpmLockYaml must not be empty."
-      );
+    if (source.pnpmLockYaml.length === 0) {
+      throw new Error("ACP source.pnpmLockYaml must not be empty.");
     }
   } else {
-    validateSimpleImplementation({ implementation });
+    validateNpmSimpleSource({ source });
   }
   if (!EXECUTABLE_NAME_REGEXP.test(implementation.executable)) {
     throw new Error(
@@ -212,8 +220,9 @@ function validateACPV1Implementation(implementation) {
 function createImplementationManifest({
   implementation
 }) {
-  if (isLockedImplementation(implementation)) {
-    return implementation.packageJson;
+  const { source } = implementation;
+  if (source.type === "npm-locked") {
+    return source.packageJson;
   }
   return JSON.stringify(
     {
@@ -222,7 +231,7 @@ function createImplementationManifest({
       private: true,
       type: "module",
       dependencies: {
-        [implementation.packageName]: implementation.version
+        [source.packageName]: source.packageVersion ?? "latest"
       }
     },
     null,
@@ -232,18 +241,17 @@ function createImplementationManifest({
 function getImplementationLockfile({
   implementation
 }) {
-  return isLockedImplementation(implementation) ? implementation.pnpmLockYaml : void 0;
+  const { source } = implementation;
+  return source.type === "npm-locked" ? source.pnpmLockYaml : void 0;
 }
 function createImplementationDescriptor({
-  implementation,
-  implementationIdentity
+  implementation
 }) {
   return JSON.stringify(
     {
       executable: implementation.executable,
       args: implementation.args ?? [],
-      envKeys: getImplementationEnvironmentKeys({ implementation }),
-      implementationIdentity
+      envKeys: getImplementationEnvironmentKeys({ implementation })
     },
     null,
     2
@@ -257,14 +265,15 @@ function createImplementationIdentity({
   providerAuthentication,
   permissionModeMapping
 }) {
-  const acquisition = isLockedImplementation(implementation) ? {
-    mode: "locked",
-    packageJson: implementation.packageJson,
-    pnpmLockYaml: implementation.pnpmLockYaml
+  const { source } = implementation;
+  const sourceIdentity = source.type === "npm-locked" ? {
+    type: source.type,
+    packageJson: source.packageJson,
+    pnpmLockYaml: source.pnpmLockYaml
   } : {
-    mode: "simple",
-    packageName: implementation.packageName,
-    version: implementation.version
+    type: source.type,
+    packageName: source.packageName,
+    ...source.packageVersion == null ? {} : { packageVersion: source.packageVersion }
   };
   const forwardedEnvironment = [
     ...new Set(implementation.forwardEnv ?? [])
@@ -275,7 +284,7 @@ function createImplementationIdentity({
   const payload = {
     harnessId,
     acpVersion,
-    acquisition,
+    source: sourceIdentity,
     executable: implementation.executable,
     args: implementation.args ?? [],
     clientApp,
@@ -293,7 +302,7 @@ function createImplementationInstallCommand({
   storeDir,
   implementation
 }) {
-  return `pnpm --dir ${implementationDir} install` + (isLockedImplementation(implementation) ? " --frozen-lockfile" : "") + ` --prod --store-dir ${storeDir}`;
+  return `pnpm --dir ${implementationDir} install` + (implementation.source.type === "npm-locked" ? " --frozen-lockfile" : "") + ` --prod --store-dir ${storeDir}`;
 }
 function resolveImplementationEnvironment({
   implementation,
@@ -311,17 +320,17 @@ function resolveImplementationEnvironment({
     ...implementation.env
   };
 }
-function validateSimpleImplementation({
-  implementation
+function validateNpmSimpleSource({
+  source
 }) {
-  if (!PACKAGE_NAME_REGEXP.test(implementation.packageName)) {
+  if (!PACKAGE_NAME_REGEXP.test(source.packageName)) {
     throw new Error(
-      `ACP npm package name is invalid: ${JSON.stringify(implementation.packageName)}.`
+      `ACP npm package name is invalid: ${JSON.stringify(source.packageName)}.`
     );
   }
-  if (!EXACT_SEMVER_REGEXP.test(implementation.version)) {
+  if (source.packageVersion != null && !EXACT_SEMVER_REGEXP.test(source.packageVersion)) {
     throw new Error(
-      `ACP npm implementation version must be an exact semantic version; received ${JSON.stringify(implementation.version)}.`
+      `ACP npm package version must be an exact semantic version; received ${JSON.stringify(source.packageVersion)}.`
     );
   }
 }
@@ -360,9 +369,6 @@ function getImplementationEnvironmentKeys({
     ])
   ].sort();
 }
-function isLockedImplementation(implementation) {
-  return implementation.mode === "locked";
-}
 function stableStringify2({ value }) {
   return JSON.stringify(sortValue({ value }));
 }
@@ -889,9 +895,6 @@ function createACPV1({
   port: portOverride,
   startupTimeoutMs,
   clientApp,
-  implementationIdentity,
-  authenticationProfile,
-  providerAuthenticationCompatibility,
   lifecycleStateSchema
 }) {
   if (!HARNESS_ID_REGEXP.test(settings.harnessId)) {
@@ -899,7 +902,8 @@ function createACPV1({
       `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}`;
   let cachedBootstrap;
   const permissionModeMapping = isCompletePermissionModeMapping({
@@ -921,7 +925,7 @@ function createACPV1({
         readBridgeAsset({ name: "host-tool-mcp.mjs" })
       ]);
       const implementationLock = getImplementationLockfile({
-        implementation: settings.implementation
+        implementation
       });
       cachedBootstrap = {
         harnessId: settings.harnessId,
@@ -943,14 +947,13 @@ function createACPV1({
           {
             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 ? [] : [
@@ -968,7 +971,7 @@ function createACPV1({
             command: createImplementationInstallCommand({
               implementationDir: "implementation",
               storeDir: "../.pnpm-store",
-              implementation: settings.implementation
+              implementation
             })
           }
         ]
@@ -983,13 +986,31 @@ function createACPV1({
         });
       }
       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: {
           mode: settings.auth,
           providerAuthentication: settings.providerAuthentication,
           clientApp
         },
-        env: process.env,
+        env,
         compatibility: providerAuthenticationCompatibility
       });
       const sandboxSession = startOptions.sandboxSession;
@@ -1204,8 +1225,8 @@ function createACPV1({
         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
+            implementation,
+            env
           }),
           ...createACPBridgeEnvironment({
             authentication: settings.authentication,
@@ -2000,7 +2021,7 @@ function deserializeBridgeError({
 }
 
 // src/version.ts
-var VERSION = true ? "1.0.0" : "0.0.0-test";
+var VERSION = true ? "1.0.1" : "0.0.0-test";
 
 // src/acp-harness.ts
 var ACP_CLIENT_APP = {
@@ -2046,39 +2067,13 @@ function createACP(settings) {
   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
+        lifecycleStateSchema: acpResumeStateSchema
       });
     }
     default: