@ai-sdk/harness-acp 1.0.44 → 1.0.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-acp",
-  "version": "1.0.44",
+  "version": "1.0.46",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,8 +26,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.106",
-    "@ai-sdk/provider-utils": "5.0.38",
+    "@ai-sdk/harness": "1.0.108",
+    "@ai-sdk/provider-utils": "5.0.40",
     "ws": "^8.21.0"
   },
   "peerDependencies": {

package/src/acp-harness.ts

@@ -49,12 +49,14 @@ export type ACPHarnessSettings<
   readonly version?: ACPV1Settings['version'];
   readonly harnessId: ACPV1Settings['harnessId'];
   readonly auth?: ACPAuthenticationMode;
+  readonly resolveAuthenticationEnvironment?: ACPV1Settings['resolveAuthenticationEnvironment'];
   readonly source: ACPV1Settings['source'];
   readonly executable: ACPV1Settings['executable'];
   readonly args?: ACPV1Settings['args'];
   readonly forwardEnv?: ACPV1Settings['forwardEnv'];
   readonly credentialEnv?: ACPV1Settings['credentialEnv'];
   readonly credentialBrokering?: ACPV1Settings['credentialBrokering'];
+  readonly authenticationFiles?: ACPV1Settings['authenticationFiles'];
   /**
    * Customizes each credential value before it is forwarded into a sandbox
    * process. This does not restrict which credentials the harness adapter can

package/src/index.ts

@@ -21,6 +21,8 @@ export type {
 } from './acp-tool-call';
 export type {
   ACPAskUserQuestionsSettings,
+  ACPAuthenticationFile,
+  ACPAuthenticationFiles,
   ACPCredentialBrokering,
   ACPAuthentication,
   ACPHostToolMCPTransport,

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

@@ -197,15 +197,21 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
       }
       const permissionMode = startOptions.permissionMode ?? 'allow-all';
       const env = { ...process.env };
-      const authenticationEnvironment = resolveACPAuthenticationEnvironment({
-        auth: settings.auth,
-        env,
-      });
+      const authenticationEnvironment =
+        settings.resolveAuthenticationEnvironment == null
+          ? resolveACPAuthenticationEnvironment({
+              auth: settings.auth,
+              env,
+            })
+          : await settings.resolveAuthenticationEnvironment({
+              auth: settings.auth,
+              env,
+            });
       const providerAuthenticationCompatibility =
         resolveACPProviderAuthenticationCompatibility({
           auth: settings.auth,
           providerAuthentication: settings.providerAuthentication,
-          env,
+          env: authenticationEnvironment,
         });
       const implementationIdentity = createImplementationIdentity({
         harnessId: settings.harnessId,
@@ -228,7 +234,7 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
           providerAuthentication: settings.providerAuthentication,
           clientApp,
         },
-        env,
+        env: authenticationEnvironment,
         compatibility: providerAuthenticationCompatibility,
       });
       const sandboxSession = startOptions.sandboxSession;
@@ -273,7 +279,7 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
       }
       const implementationEnvironment = resolveImplementationEnvironment({
         implementation,
-        env,
+        env: { ...env, ...authenticationEnvironment },
         credentialEnv: authenticationEnvironment,
       });
       let sandboxImplementationEnvironment = implementationEnvironment;
@@ -589,6 +595,17 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
           ],
         });
       }
+      await writeACPAuthenticationFiles({
+        sandbox: toolSafeSandboxSession,
+        homePath: implementationHomeDir,
+        files:
+          settings.authenticationFiles?.({
+            env: implementationEnvironment,
+            sandboxEnv: forwardedImplementationEnvironment,
+            credentialBrokeringAvailable: sandboxCredentialEnvironment != null,
+          }) ?? [],
+        abortSignal: startOptions.abortSignal,
+      });
       const port = resolveBridgePort({
         sandboxSession,
         override: portOverride,
@@ -797,6 +814,50 @@ export function createACPV1<TBuiltinTools extends ToolSet = {}>({
   };
 }
 
+async function writeACPAuthenticationFiles({
+  sandbox,
+  homePath,
+  files,
+  abortSignal,
+}: {
+  sandbox: SandboxSession;
+  homePath: string;
+  files: ReadonlyArray<{ readonly path: string; readonly content: string }>;
+  abortSignal?: AbortSignal;
+}): Promise<void> {
+  const targetPaths = files.map(file => {
+    if (
+      file.path.length === 0 ||
+      posix.isAbsolute(file.path) ||
+      file.path.split('/').some(segment => segment === '..')
+    ) {
+      throw new Error(
+        `ACP authentication file path must be relative without traversal: ${JSON.stringify(file.path)}.`,
+      );
+    }
+    return posix.join(homePath, file.path);
+  });
+
+  for (let index = 0; index < files.length; index++) {
+    await sandbox.writeTextFile({
+      path: targetPaths[index],
+      content: files[index].content,
+      abortSignal,
+    });
+  }
+  if (targetPaths.length === 0) return;
+
+  const result = await sandbox.run({
+    command: `chmod 600 -- ${targetPaths.map(shellQuote).join(' ')}`,
+    abortSignal,
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Failed to secure ACP authentication files (exit ${result.exitCode})${result.stderr ? `: ${result.stderr}` : ''}`,
+    );
+  }
+}
+
 function resolveProviderEnvironment({
   resolvedProviderAuthentication,
   clientApp,

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

@@ -98,6 +98,20 @@ export type ACPCredentialBrokering = ({
   headers?: Readonly<Record<string, string>>;
 }) => ReadonlyArray<HarnessV1RequestTransformation>;
 
+export type ACPAuthenticationFile = {
+  /** Path relative to the ACP implementation's private home directory. */
+  readonly path: string;
+  readonly content: string;
+};
+
+export type ACPAuthenticationFiles = (options: {
+  /** Host values resolved for the implementation. */
+  readonly env: Readonly<Record<string, string>>;
+  /** Values exposed to the sandbox process after credential brokering. */
+  readonly sandboxEnv: Readonly<Record<string, string>>;
+  readonly credentialBrokeringAvailable: boolean;
+}) => ReadonlyArray<ACPAuthenticationFile>;
+
 export type ACPPermissionModeTarget =
   | {
       readonly type: 'session-mode';
@@ -169,12 +183,25 @@ export type ACPV1Settings = {
   readonly mcpServers?: Record<string, unknown>;
   readonly isMcpToolCall?: (toolCall: ACPToolCall) => boolean;
   readonly auth?: ACPAuthenticationMode;
+  /**
+   * Resolves adapter-owned authentication on the host before any environment
+   * values are forwarded to the ACP implementation.
+   */
+  readonly resolveAuthenticationEnvironment?: (options: {
+    readonly auth: ACPAuthenticationMode | undefined;
+    readonly env: Readonly<Record<string, string | undefined>>;
+  }) => Promise<Readonly<Record<string, string | undefined>>>;
   readonly source: ACPSource;
   readonly executable: string;
   readonly args?: ReadonlyArray<string>;
   readonly forwardEnv?: ReadonlyArray<string>;
   readonly credentialEnv?: ReadonlyArray<string>;
   readonly credentialBrokering?: ACPCredentialBrokering;
+  /**
+   * Materializes private authentication files below the ACP implementation's
+   * home directory before the implementation starts.
+   */
+  readonly authenticationFiles?: ACPAuthenticationFiles;
   /**
    * Customizes each credential value before it is forwarded into a sandbox
    * process. This does not restrict which credentials the harness adapter can

package/src/v1/index.ts

@@ -1,6 +1,8 @@
 export { createACPV1 } from './acp-v1-harness';
 export type {
   ACPAskUserQuestionsSettings,
+  ACPAuthenticationFile,
+  ACPAuthenticationFiles,
   ACPCredentialBrokering,
   ACPAuthentication,
   ACPAuthenticationMode,