@ai-sdk/harness-acp 1.0.8 → 1.0.9

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { HarnessV1PermissionMode, HarnessV1 } from '@ai-sdk/harness';
+import { HarnessV1RequestTransformation, HarnessV1PermissionMode, HarnessV1 } from '@ai-sdk/harness';
 import { ToolSet } from '@ai-sdk/provider-utils';
 
 type ACPMetadata = Record<string, unknown>;
@@ -139,6 +139,9 @@ type ACPProviderAuthentication = {
         readonly env: Readonly<Record<string, ACPProfileValue>>;
     };
 };
+type ACPCredentialBrokering = ({ env, }: {
+    env: Readonly<Record<string, string>>;
+}) => ReadonlyArray<HarnessV1RequestTransformation>;
 type ACPPermissionModeTarget = {
     readonly type: 'session-mode';
     readonly modeId: string;
@@ -171,6 +174,8 @@ type ACPV1Settings = {
     readonly executable: string;
     readonly args?: ReadonlyArray<string>;
     readonly forwardEnv?: ReadonlyArray<string>;
+    readonly credentialEnv?: ReadonlyArray<string>;
+    readonly credentialBrokering?: ACPCredentialBrokering;
     /**
      * Runtime environment values that are safe to persist in bootstrap and
      * lifecycle compatibility identity.
@@ -219,6 +224,8 @@ type ACPHarnessSettings<TBuiltinTools extends ToolSet = {}> = {
     readonly executable: ACPV1Settings['executable'];
     readonly args?: ACPV1Settings['args'];
     readonly forwardEnv?: ACPV1Settings['forwardEnv'];
+    readonly credentialEnv?: ACPV1Settings['credentialEnv'];
+    readonly credentialBrokering?: ACPV1Settings['credentialBrokering'];
     readonly env?: ACPV1Settings['env'];
     readonly authentication?: ACPV1Settings['authentication'];
     readonly providerAuthentication?: ACPV1Settings['providerAuthentication'];
@@ -232,4 +239,4 @@ declare function createACP<TBuiltinTools extends ToolSet = {}>(settings: ACPHarn
 
 declare const VERSION: string;
 
-export { type ACPAnnotations, type ACPAudioContent, type ACPAuthOptions, type ACPAuthentication, type ACPBlobResourceContents, type ACPClientApp, type ACPContentBlock, type ACPEmbeddedResource, type ACPHarnessSettings, type ACPImageContent, type ACPInstructionMapping, type ACPMetadata, type ACPNpmLockedSource, type ACPNpmSimpleSource, type ACPPermissionModeMapping, type ACPPermissionModeTarget, type ACPProfileValue, type ACPProviderAuthentication, type ACPProviderAuthenticationMode, type ACPResourceLink, type ACPRole, type ACPSerializablePrimitive, type ACPSerializableValue, type ACPSource, type ACPTextContent, type ACPTextResourceContents, type ACPToolCall, type ACPToolCallContent, type ACPToolCallLocation, type ACPToolCallStatus, type ACPToolKind, type ACPV1Settings, type ACPValueSource, VERSION, createACP };
+export { type ACPAnnotations, type ACPAudioContent, type ACPAuthOptions, type ACPAuthentication, type ACPBlobResourceContents, type ACPClientApp, type ACPContentBlock, type ACPCredentialBrokering, type ACPEmbeddedResource, type ACPHarnessSettings, type ACPImageContent, type ACPInstructionMapping, type ACPMetadata, type ACPNpmLockedSource, type ACPNpmSimpleSource, type ACPPermissionModeMapping, type ACPPermissionModeTarget, type ACPProfileValue, type ACPProviderAuthentication, type ACPProviderAuthenticationMode, type ACPResourceLink, type ACPRole, type ACPSerializablePrimitive, type ACPSerializableValue, type ACPSource, type ACPTextContent, type ACPTextResourceContents, type ACPToolCall, type ACPToolCallContent, type ACPToolCallLocation, type ACPToolCallStatus, type ACPToolKind, type ACPV1Settings, type ACPValueSource, VERSION, createACP };

package/dist/index.js

@@ -3,9 +3,7 @@ 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
@@ -18,9 +16,11 @@ import {
   drainBridgeProcessStream,
   forwardBridgeProcessStream,
   markBridgeStarting,
+  maskSandboxCredentials,
   resolveSandboxHomeDir,
   SandboxChannel,
   shellQuote,
+  warnCredentialBrokeringUnavailable,
   waitForBridgeReady
 } from "@ai-sdk/harness/utils";
 import {
@@ -182,6 +182,7 @@ function createACPV1Implementation({
     executable: settings.executable,
     args: settings.args,
     forwardEnv: settings.forwardEnv,
+    credentialEnv: settings.credentialEnv,
     env: settings.env
   };
 }
@@ -207,14 +208,28 @@ function validateACPV1Implementation(implementation) {
     );
   }
   validateForwardEnvironment({ forwardEnv: implementation.forwardEnv });
+  validateForwardEnvironment({ forwardEnv: implementation.credentialEnv });
   validateEnvironment({ env: implementation.env });
   const forwardedKeys = new Set(implementation.forwardEnv ?? []);
+  const credentialKeys = new Set(implementation.credentialEnv ?? []);
+  for (const key of credentialKeys) {
+    if (forwardedKeys.has(key)) {
+      throw new Error(
+        `ACP runtime environment key ${JSON.stringify(key)} cannot be configured in both forwardEnv and credentialEnv.`
+      );
+    }
+  }
   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.`
       );
     }
+    if (credentialKeys.has(key)) {
+      throw new Error(
+        `ACP runtime environment key ${JSON.stringify(key)} cannot be configured in both credentialEnv and env.`
+      );
+    }
   }
 }
 function createImplementationManifest({
@@ -278,6 +293,9 @@ function createImplementationIdentity({
   const forwardedEnvironment = [
     ...new Set(implementation.forwardEnv ?? [])
   ].sort();
+  const credentialEnvironment = [
+    ...new Set(implementation.credentialEnv ?? [])
+  ].sort();
   const literalEnvironment = Object.fromEntries(
     Object.entries(implementation.env ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [key, { value }])
   );
@@ -290,6 +308,7 @@ function createImplementationIdentity({
     clientApp,
     environment: {
       forwarded: forwardedEnvironment,
+      credential: credentialEnvironment,
       literal: literalEnvironment
     },
     providerAuthentication: providerAuthentication ?? null,
@@ -309,7 +328,10 @@ function resolveImplementationEnvironment({
   env
 }) {
   const forwardedEnvironment = {};
-  for (const name of implementation.forwardEnv ?? []) {
+  for (const name of [
+    ...implementation.forwardEnv ?? [],
+    ...implementation.credentialEnv ?? []
+  ]) {
     const value = env[name];
     if (value != null && value.length > 0) {
       forwardedEnvironment[name] = value;
@@ -365,6 +387,7 @@ function getImplementationEnvironmentKeys({
   return [
     .../* @__PURE__ */ new Set([
       ...implementation.forwardEnv ?? [],
+      ...implementation.credentialEnv ?? [],
       ...Object.keys(implementation.env ?? {})
     ])
   ].sort();
@@ -384,6 +407,103 @@ function sortValue({ value }) {
   return value;
 }
 
+// src/v1/acp-bootstrap.ts
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+function createACPBootstrap({
+  harnessId,
+  implementation
+}) {
+  const bootstrapDir = `.harness-bootstrap/${harnessId}`;
+  let cachedBootstrap;
+  return {
+    bootstrapDir,
+    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
+      });
+      cachedBootstrap = {
+        harnessId,
+        bootstrapDir,
+        files: [
+          {
+            path: `${bootstrapDir}/package.json`,
+            content: bridgePackage
+          },
+          {
+            path: `${bootstrapDir}/pnpm-lock.yaml`,
+            content: bridgeLock
+          },
+          { path: `${bootstrapDir}/bridge.mjs`, content: bridge },
+          {
+            path: `${bootstrapDir}/host-tool-mcp.mjs`,
+            content: hostToolMCP
+          },
+          {
+            path: `${bootstrapDir}/implementation/package.json`,
+            content: createImplementationManifest({ implementation })
+          },
+          {
+            path: `${bootstrapDir}/implementation/implementation.json`,
+            content: createImplementationDescriptor({ implementation })
+          },
+          ...implementationLock == null ? [] : [
+            {
+              path: `${bootstrapDir}/implementation/pnpm-lock.yaml`,
+              content: implementationLock
+            }
+          ]
+        ],
+        commands: [
+          {
+            command: "pnpm install --frozen-lockfile --store-dir .pnpm-store"
+          },
+          {
+            command: createImplementationInstallCommand({
+              implementationDir: "implementation",
+              storeDir: "../.pnpm-store",
+              implementation
+            })
+          }
+        ]
+      };
+      return cachedBootstrap;
+    }
+  };
+}
+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)
+  ];
+}
+
 // src/v1/acp-v1-bridge-protocol.ts
 import {
   harnessV1BridgeInboundCommandSchemas,
@@ -622,22 +742,120 @@ var providerAuthenticationSchema = z3.discriminatedUnion("type", [
 var bridgeConfigurationSchema = z3.object({
   authentication: authenticationSchema.optional(),
   providerAuthentication: providerAuthenticationSchema.optional(),
+  providerEnvironment: z3.record(z3.string(), z3.string()).optional(),
   sessionMeta: serializableRecordSchema.optional()
 });
 function createACPBridgeEnvironment({
   authentication,
   providerAuthentication,
+  providerEnvironment,
   sessionMeta
 }) {
   return {
     [ACP_BRIDGE_CONFIGURATION_ENV]: JSON.stringify({
       ...authentication == null ? {} : { authentication },
       ...providerAuthentication == null ? {} : { providerAuthentication },
+      ...providerEnvironment == null ? {} : { providerEnvironment },
       ...sessionMeta == null ? {} : { sessionMeta }
     })
   };
 }
 
+// src/v1/bridge/profile-values.ts
+function resolveACPProfileValue({
+  value,
+  gateway
+}) {
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveACPProfileValue({ value: item, gateway }));
+  }
+  if (value !== null && typeof value === "object") {
+    if (isValueSource(value)) {
+      const sourceValue = resolveSource({ source: value.$source, gateway });
+      const resolved = `${value.prefix ?? ""}${sourceValue}`;
+      return value.ensureSuffix == null ? `${resolved}${value.suffix ?? ""}` : ensureSuffix({
+        value: resolved,
+        suffix: value.ensureSuffix
+      });
+    }
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        resolveACPProfileValue({ value: item, gateway })
+      ])
+    );
+  }
+  return value;
+}
+function isValueSource(value) {
+  return "$source" in value && typeof value.$source === "string";
+}
+function ensureSuffix({
+  value,
+  suffix
+}) {
+  const normalized = value.replace(/\/+$/, "");
+  return normalized.endsWith(suffix) ? normalized : `${normalized}${suffix}`;
+}
+function resolveSource({
+  source,
+  gateway
+}) {
+  switch (source) {
+    case "gateway-api-key":
+      return gateway.apiKey;
+    case "gateway-base-url":
+      return gateway.baseUrl;
+    case "gateway-authorization":
+      return `Bearer ${gateway.apiKey}`;
+    case "client-app":
+      return `${gateway.clientAppName}/${gateway.clientAppVersion}`;
+    case "client-app-name":
+      return gateway.clientAppName;
+    case "client-app-version":
+      return gateway.clientAppVersion;
+  }
+}
+
+// src/v1/bridge/protocol-configuration.ts
+function resolveACPLaunchEnvironment({
+  providerAuthentication,
+  gateway
+}) {
+  if (providerAuthentication?.type !== "ai-gateway") {
+    return {};
+  }
+  const resolved = asRecord(
+    resolveACPProfileValue({
+      value: providerAuthentication.env,
+      gateway: requireGateway({ gateway })
+    })
+  );
+  return Object.fromEntries(
+    Object.entries(resolved).map(([key, value]) => [
+      key,
+      typeof value === "string" ? value : JSON.stringify(value)
+    ])
+  );
+}
+function requireGateway({
+  gateway
+}) {
+  if (gateway == null) {
+    throw new Error("ACP Gateway profile values are unavailable.");
+  }
+  return gateway;
+}
+function asRecord(value) {
+  if (!isRecord(value)) {
+    throw new Error("ACP profile data must resolve to an object.");
+  }
+  return value;
+}
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/v1/acp-v1-turn-start-config.ts
 import { createHash as createHash3 } from "crypto";
 function createACPTurnStartConfig({
@@ -925,6 +1143,11 @@ function createACPV1({
   clientApp,
   lifecycleStateSchema
 }) {
+  if (settings.credentialEnv == null !== (settings.credentialBrokering == null)) {
+    throw new Error(
+      "ACP credentialEnv and credentialBrokering must be configured together."
+    );
+  }
   if (settings.mcpServers != null && Object.prototype.hasOwnProperty.call(
     settings.mcpServers,
     "ai-sdk-harness-tools"
@@ -940,8 +1163,10 @@ function createACPV1({
   }
   const implementation = createACPV1Implementation({ settings });
   validateACPV1Implementation(implementation);
-  const BOOTSTRAP_DIR = `.harness-bootstrap/${settings.harnessId}`;
-  let cachedBootstrap;
+  const bootstrap = createACPBootstrap({
+    harnessId: settings.harnessId,
+    implementation
+  });
   const permissionModeMapping = isCompletePermissionModeMapping({
     value: settings.permissionModeMapping
   }) ? settings.permissionModeMapping : void 0;
@@ -952,68 +1177,7 @@ function createACPV1({
     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
-      });
-      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
-            })
-          },
-          {
-            path: `${BOOTSTRAP_DIR}/implementation/implementation.json`,
-            content: createImplementationDescriptor({
-              implementation
-            })
-          },
-          ...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
-            })
-          }
-        ]
-      };
-      return cachedBootstrap;
-    },
+    getBootstrap: bootstrap.getBootstrap,
     doStart: async (startOptions) => {
       if (startOptions.builtinToolFiltering != null) {
         throw unsupported({
@@ -1050,10 +1214,60 @@ function createACPV1({
         compatibility: providerAuthenticationCompatibility
       });
       const sandboxSession = startOptions.sandboxSession;
+      const implementationEnvironment = resolveImplementationEnvironment({
+        implementation,
+        env
+      });
+      let sandboxImplementationEnvironment = implementationEnvironment;
+      let sandboxProviderAuthenticationEnvironment = resolvedProviderAuthentication.env;
+      let sandboxProviderEnvironment;
+      if (settings.credentialBrokering != null && sandboxSession.addRequestTransformations != null) {
+        const providerEnvironment = resolveProviderEnvironment({
+          resolvedProviderAuthentication,
+          clientApp
+        });
+        const credentialEnvironmentVariables = [
+          .../* @__PURE__ */ new Set([
+            ...settings.credentialEnv ?? [],
+            "AI_GATEWAY_API_KEY",
+            "VERCEL_OIDC_TOKEN"
+          ])
+        ];
+        const requestTransformations = settings.credentialBrokering({
+          env: {
+            ...implementationEnvironment,
+            ...providerEnvironment
+          }
+        });
+        if (requestTransformations.length > 0) {
+          await sandboxSession.addRequestTransformations(
+            requestTransformations
+          );
+        }
+        sandboxImplementationEnvironment = maskSandboxCredentials({
+          environment: implementationEnvironment,
+          credentialEnvironmentVariables
+        });
+        sandboxProviderEnvironment = maskSandboxCredentials({
+          environment: resolveProviderEnvironment({
+            resolvedProviderAuthentication,
+            clientApp,
+            gatewayApiKey: "AI_GATEWAY_API_KEY"
+          }),
+          credentialEnvironmentVariables
+        });
+        sandboxProviderAuthenticationEnvironment = Object.fromEntries(
+          Object.entries(resolvedProviderAuthentication.env).filter(
+            ([key]) => key !== "AI_SDK_ACP_GATEWAY_API_KEY" && key !== "AI_SDK_ACP_GATEWAY_BASE_URL"
+          )
+        );
+      } else if (settings.credentialBrokering != null) {
+        warnCredentialBrokeringUnavailable();
+      }
       const sandbox = sandboxSession.restricted();
       const resolvedBridgeDir = posix.resolve(
         sandboxSession.defaultWorkingDirectory,
-        BOOTSTRAP_DIR
+        bootstrap.bootstrapDir
       );
       const resolvedImplementationDir = `${resolvedBridgeDir}/implementation`;
       const workDir = startOptions.sessionWorkDir;
@@ -1129,12 +1343,16 @@ function createACPV1({
         }
         if (coords != null) {
           try {
-            const attachUrl = await sandboxSession.getPortUrl({
+            const endpoint2 = await sandboxSession.getPortEndpoint({
               port: coords.port,
               protocol: "ws"
-            }) + `?agent_bridge_token=${encodeURIComponent(coords.token)}`;
+            });
+            const attachEndpoint = withBridgeToken({
+              endpoint: endpoint2,
+              token: coords.token
+            });
             const attachChannel = new SandboxChannel({
-              connect: () => openWebSocket({ url: attachUrl }),
+              connect: () => openWebSocket(attachEndpoint),
               outboundSchema: outboundMessageSchema,
               initialLastSeenEventId: coords.lastSeenEventId,
               onDiagnostic,
@@ -1267,16 +1485,14 @@ function createACPV1({
       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,
-            env
-          }),
+          ...sandboxImplementationEnvironment,
           ...createACPBridgeEnvironment({
             authentication: settings.authentication,
             providerAuthentication: resolvedProviderAuthentication.providerAuthentication,
+            providerEnvironment: sandboxProviderEnvironment,
             sessionMeta: settings.session?.meta
           }),
-          ...resolvedProviderAuthentication.env,
+          ...sandboxProviderAuthenticationEnvironment,
           BRIDGE_CHANNEL_TOKEN: token,
           BRIDGE_WS_PORT: String(port),
           ...respawnStrategy?.mode === "disk-replay" ? {
@@ -1316,12 +1532,13 @@ function createACPV1({
         })
       });
       void drainBridgeProcessStream(proc.stdout);
-      const wsUrl = await sandboxSession.getPortUrl({
+      const endpoint = await sandboxSession.getPortEndpoint({
         port: boundPort,
         protocol: "ws"
-      }) + `?agent_bridge_token=${encodeURIComponent(token)}`;
+      });
+      const bridgeEndpoint = withBridgeToken({ endpoint, token });
       const channel = new SandboxChannel({
-        connect: () => openWebSocket({ url: wsUrl }),
+        connect: () => openWebSocket(bridgeEndpoint),
         outboundSchema: outboundMessageSchema,
         ...respawnStrategy?.mode === "disk-replay" ? { initialLastSeenEventId: respawnStrategy.afterSeq } : {},
         onDiagnostic,
@@ -1410,30 +1627,39 @@ function createACPV1({
     }
   };
 }
-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;
-    }
+function resolveProviderEnvironment({
+  resolvedProviderAuthentication,
+  clientApp,
+  gatewayApiKey
+}) {
+  if (resolvedProviderAuthentication.providerAuthentication?.type !== "ai-gateway") {
+    return {};
   }
-  throw lastError ?? new Error(`ACP bridge asset not found: ${name}`);
+  return resolveACPLaunchEnvironment({
+    providerAuthentication: resolvedProviderAuthentication.providerAuthentication,
+    gateway: {
+      apiKey: gatewayApiKey ?? requireResolvedEnvironmentValue({
+        environment: resolvedProviderAuthentication.env,
+        name: "AI_SDK_ACP_GATEWAY_API_KEY"
+      }),
+      baseUrl: requireResolvedEnvironmentValue({
+        environment: resolvedProviderAuthentication.env,
+        name: "AI_SDK_ACP_GATEWAY_BASE_URL"
+      }),
+      clientAppName: clientApp.name,
+      clientAppVersion: clientApp.version
+    }
+  });
 }
-function resolveBridgeAssetCandidates({
-  name,
-  moduleUrl
+function requireResolvedEnvironmentValue({
+  environment,
+  name
 }) {
-  return [
-    new URL(`./bridge/${name}`, moduleUrl),
-    new URL(`../bridge/${name}`, moduleUrl)
-  ];
+  const value = environment[name];
+  if (value == null) {
+    throw new Error(`ACP resolved environment value ${name} is unavailable.`);
+  }
+  return value;
 }
 function resolveBridgePort({
   sandboxSession,
@@ -1447,9 +1673,14 @@ function resolveBridgePort({
     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 }) {
+function openWebSocket({
+  url,
+  headers
+}) {
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket(url);
+    const ws = new WebSocket(url, {
+      headers: headers == null ? void 0 : { ...headers }
+    });
     const onOpen = () => {
       ws.off("error", onError);
       resolve(ws);
@@ -1462,6 +1693,14 @@ function openWebSocket({ url }) {
     ws.once("error", onError);
   });
 }
+function withBridgeToken({
+  endpoint,
+  token
+}) {
+  const bridgeUrl = new URL(endpoint.url);
+  bridgeUrl.searchParams.set("agent_bridge_token", token);
+  return { ...endpoint, url: bridgeUrl.toString() };
+}
 function restoreColdACPSession({
   channel,
   harnessId,
@@ -1489,7 +1728,7 @@ function restoreColdACPSession({
     subscriptions.push(
       channel.on("raw", (event) => {
         const rawValue = event.rawValue;
-        if (isRecord(rawValue) && rawValue.type === "acp-session-restored" && (rawValue.method === "resume" || rawValue.method === "load")) {
+        if (isRecord2(rawValue) && rawValue.type === "acp-session-restored" && (rawValue.method === "resume" || rawValue.method === "load")) {
           restorationMethod = rawValue.method;
         }
       })
@@ -2105,7 +2344,7 @@ function assertRecoveryToolCatalog({
 function fingerprintValue({ value }) {
   return createHash5("sha256").update(JSON.stringify(value)).digest("hex");
 }
-function isRecord(value) {
+function isRecord2(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
 function unsupported({
@@ -2130,7 +2369,7 @@ function deserializeBridgeError({
 }
 
 // src/version.ts
-var VERSION = true ? "1.0.8" : "0.0.0-test";
+var VERSION = true ? "1.0.9" : "0.0.0-test";
 
 // src/acp-harness.ts
 var ACP_CLIENT_APP = {
@@ -2172,6 +2411,11 @@ var acpResumeStateSchema = z4.object({
   skillsFingerprint: z4.string().optional()
 });
 function createACP(settings) {
+  if (settings.credentialEnv == null !== (settings.credentialBrokering == null)) {
+    throw new Error(
+      "ACP credentialEnv and credentialBrokering must be configured together."
+    );
+  }
   if (settings.mcpServers != null && Object.prototype.hasOwnProperty.call(
     settings.mcpServers,
     "ai-sdk-harness-tools"