@ai-sdk/harness-pi 1.0.36 → 1.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-pi",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,10 +26,10 @@
     }
   },
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "^0.79.0",
+    "@earendil-works/pi-coding-agent": "^0.80.10",
     "typebox": "^1.1.38",
-    "@ai-sdk/harness": "1.0.36",
-    "@ai-sdk/provider-utils": "5.0.11"
+    "@ai-sdk/harness": "1.0.38",
+    "@ai-sdk/provider-utils": "5.0.12"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"

package/src/pi-auth.ts

@@ -1,6 +1,6 @@
 import type {
-  AuthStorage,
   ModelRegistry,
+  ModelRuntime,
 } from '@earendil-works/pi-coding-agent';
 import { getAiGatewayAuthFromEnv } from '@ai-sdk/harness/utils';
 import { VERSION } from './version';
@@ -56,14 +56,24 @@ function createGatewayProviderConfig({
   };
 }
 
-function register(
-  registries: { authStorage: AuthStorage; modelRegistry: ModelRegistry },
-  provider: string,
-  apiKey: string,
-  config: ProviderConfigInput,
-): void {
-  registries.authStorage.setRuntimeApiKey(provider, apiKey);
+type PiRegistries = {
+  modelRegistry: ModelRegistry;
+  modelRuntime: ModelRuntime;
+};
+
+async function register({
+  registries,
+  provider,
+  apiKey,
+  config,
+}: {
+  registries: PiRegistries;
+  provider: string;
+  apiKey: string;
+  config: ProviderConfigInput;
+}): Promise<void> {
   registries.modelRegistry.registerProvider(provider, config);
+  await registries.modelRuntime.setRuntimeApiKey(provider, apiKey);
 }
 
 function hasConfiguredValue(value: unknown): boolean {
@@ -76,21 +86,13 @@ function hasConfiguredValue(value: unknown): boolean {
 export function resolvePiEnv({
   options,
   env,
-  registries,
-  clientApp = HARNESS_CLIENT_APP,
 }: {
   options: PiAuthOptions | undefined;
   env: NodeJS.ProcessEnv;
-  registries: { authStorage: AuthStorage; modelRegistry: ModelRegistry };
-  clientApp?: string;
 }): Record<string, string> {
   const customEnvConfigured = hasConfiguredValue(options?.customEnv);
   if (customEnvConfigured) {
-    return applyCustomEnv({
-      customEnv: options!.customEnv ?? {},
-      registries,
-      clientApp,
-    });
+    return resolveCustomEnv({ customEnv: options!.customEnv ?? {} });
   }
 
   const gatewayConfigured = hasConfiguredValue(options?.gateway);
@@ -99,16 +101,6 @@ export function resolvePiEnv({
     const apiKey = options!.gateway?.apiKey ?? gatewayAuthFromEnv.apiKey;
     const baseUrl = options!.gateway?.baseUrl ?? gatewayAuthFromEnv.baseUrl;
     if (apiKey) {
-      register(
-        registries,
-        'vercel-ai-gateway',
-        apiKey,
-        createGatewayProviderConfig({
-          apiKey,
-          baseUrl,
-          clientApp,
-        }),
-      );
       return { AI_GATEWAY_API_KEY: apiKey, AI_GATEWAY_BASE_URL: baseUrl };
     }
     return {};
@@ -116,16 +108,6 @@ export function resolvePiEnv({
 
   // Ambient gateway fallback.
   if (gatewayAuthFromEnv.apiKey) {
-    register(
-      registries,
-      'vercel-ai-gateway',
-      gatewayAuthFromEnv.apiKey,
-      createGatewayProviderConfig({
-        apiKey: gatewayAuthFromEnv.apiKey,
-        baseUrl: gatewayAuthFromEnv.baseUrl,
-        clientApp,
-      }),
-    );
     return {
       AI_GATEWAY_API_KEY: gatewayAuthFromEnv.apiKey,
       AI_GATEWAY_BASE_URL: gatewayAuthFromEnv.baseUrl,
@@ -135,55 +117,108 @@ export function resolvePiEnv({
   return {};
 }
 
-function applyCustomEnv({
+export async function registerPiProviders({
+  options,
+  resolvedEnv,
+  registries,
+  clientApp = HARNESS_CLIENT_APP,
+}: {
+  options: PiAuthOptions | undefined;
+  resolvedEnv: Record<string, string>;
+  registries: PiRegistries;
+  clientApp?: string;
+}): Promise<void> {
+  if (hasConfiguredValue(options?.customEnv)) {
+    await registerCustomProviders({
+      customEnv: options!.customEnv ?? {},
+      registries,
+      clientApp,
+    });
+    return;
+  }
+
+  const apiKey = resolvedEnv.AI_GATEWAY_API_KEY;
+  const baseUrl = resolvedEnv.AI_GATEWAY_BASE_URL;
+  if (!apiKey || !baseUrl) return;
+
+  await register({
+    registries,
+    provider: 'vercel-ai-gateway',
+    apiKey,
+    config: createGatewayProviderConfig({ apiKey, baseUrl, clientApp }),
+  });
+}
+
+function resolveCustomEnv({
+  customEnv,
+}: {
+  customEnv: Record<string, string>;
+}): Record<string, string> {
+  const apiKey = customEnv.AI_GATEWAY_API_KEY;
+  if (!apiKey) return {};
+
+  return {
+    AI_GATEWAY_API_KEY: apiKey,
+    AI_GATEWAY_BASE_URL:
+      customEnv.AI_GATEWAY_BASE_URL ?? DEFAULT_GATEWAY_BASE_URL,
+  };
+}
+
+async function registerCustomProviders({
   customEnv,
   registries,
   clientApp,
 }: {
   customEnv: Record<string, string>;
-  registries: { authStorage: AuthStorage; modelRegistry: ModelRegistry };
+  registries: PiRegistries;
   clientApp: string;
-}): Record<string, string> {
-  const out: Record<string, string> = {};
-
+}): Promise<void> {
   const gatewayKey = customEnv.AI_GATEWAY_API_KEY;
   if (gatewayKey) {
     const baseUrl = customEnv.AI_GATEWAY_BASE_URL ?? DEFAULT_GATEWAY_BASE_URL;
-    register(
+    await register({
       registries,
-      'vercel-ai-gateway',
-      gatewayKey,
-      createGatewayProviderConfig({
+      provider: 'vercel-ai-gateway',
+      apiKey: gatewayKey,
+      config: createGatewayProviderConfig({
         apiKey: gatewayKey,
         baseUrl,
         clientApp,
       }),
-    );
-    out.AI_GATEWAY_API_KEY = gatewayKey;
-    out.AI_GATEWAY_BASE_URL = baseUrl;
+    });
   }
 
   if (customEnv.OPENAI_API_KEY) {
     const baseUrl = customEnv.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE_URL;
-    register(registries, 'openai', customEnv.OPENAI_API_KEY, {
+    await register({
+      registries,
+      provider: 'openai',
       apiKey: customEnv.OPENAI_API_KEY,
-      baseUrl,
-      authHeader: true,
+      config: {
+        apiKey: customEnv.OPENAI_API_KEY,
+        baseUrl,
+        authHeader: true,
+      },
     });
   }
 
   if (customEnv.ANTHROPIC_API_KEY) {
     const baseUrl = customEnv.ANTHROPIC_BASE_URL ?? DEFAULT_ANTHROPIC_BASE_URL;
-    register(registries, 'anthropic', customEnv.ANTHROPIC_API_KEY, {
+    await register({
+      registries,
+      provider: 'anthropic',
       apiKey: customEnv.ANTHROPIC_API_KEY,
-      baseUrl,
-      ...(customEnv.ANTHROPIC_AUTH_TOKEN
-        ? {
-            headers: {
-              authorization: `Bearer ${customEnv.ANTHROPIC_AUTH_TOKEN}`,
-            },
-          }
-        : {}),
+      config: {
+        apiKey: customEnv.ANTHROPIC_API_KEY,
+        baseUrl,
+        ...(customEnv.ANTHROPIC_AUTH_TOKEN
+          ? {
+              headers: {
+                authorization: `Bearer ${customEnv.ANTHROPIC_AUTH_TOKEN}`,
+              },
+            }
+          : {}),
+      },
     });
   }
 
@@ -204,12 +239,15 @@ function applyCustomEnv({
     if (!baseUrl) {
       continue;
     }
-    register(registries, provider, apiKey, {
+    await register({
+      registries,
+      provider,
       apiKey,
-      baseUrl,
-      authHeader: true,
+      config: {
+        apiKey,
+        baseUrl,
+        authHeader: true,
+      },
     });
   }
-
-  return out;
 }

package/src/pi-harness.ts

@@ -33,6 +33,13 @@ export type PiHarnessSettings = {
    * `thinkingLevel` option on `createAgentSession`.
    */
   readonly thinkingLevel?: PiThinkingLevel;
+  /**
+   * Directory holding Pi's global agent config (auth.json, models.json,
+   * settings.json). When omitted, a per-session temp dir is used. Pass the
+   * user's agent dir (e.g. `~/.pi/agent/`) to reuse their CLI auth and
+   * model settings.
+   */
+  readonly agentDir?: string;
 };
 
 const PI_BUILTIN_TOOLS = {
@@ -148,6 +155,7 @@ export function createPi(
         ...(startOpts.abortSignal
           ? { abortSignal: startOpts.abortSignal }
           : {}),
+        ...(settings.agentDir ? { agentDir: settings.agentDir } : {}),
       });
     },
   };

package/src/pi-model-resolver.ts

@@ -11,10 +11,13 @@ type PiModel = ReturnType<ModelRegistry['getAll']>[number];
  */
 export const DEFAULT_PI_GATEWAY_MODEL_ID = 'anthropic/claude-sonnet-4.6';
 
-export function createPiModelResolver(
-  modelRegistry: ModelRegistry,
-  env: NodeJS.ProcessEnv = process.env,
-) {
+export function createPiModelResolver({
+  modelRegistry,
+  env = process.env,
+}: {
+  modelRegistry: ModelRegistry;
+  env?: NodeJS.ProcessEnv;
+}) {
   let cachedModels: PiModel[] | undefined;
 
   const loadModels = (): PiModel[] => {

package/src/pi-session.ts

@@ -1,9 +1,9 @@
 import {
-  AuthStorage,
   createAgentSession,
   DefaultResourceLoader,
   defineTool,
   ModelRegistry,
+  ModelRuntime,
   SessionManager,
   SettingsManager,
   type AgentSession,
@@ -30,7 +30,11 @@ import {
   type HarnessV1ToolSpec,
 } from '@ai-sdk/harness';
 import { resolveSandboxHomeDir } from '@ai-sdk/harness/utils';
-import { resolvePiEnv, type PiAuthOptions } from './pi-auth';
+import {
+  registerPiProviders,
+  resolvePiEnv,
+  type PiAuthOptions,
+} from './pi-auth';
 import { getPiTerminalError, parseNativeEvent } from './pi-events';
 import { createPiModelResolver } from './pi-model-resolver';
 import { createPiPathMapper } from './pi-paths';
@@ -202,6 +206,13 @@ export interface CreatePiSessionInput {
   readonly builtinToolFiltering?: HarnessV1BuiltinToolFiltering;
   readonly resumeSessionFileName?: string;
   readonly abortSignal?: AbortSignal;
+  /**
+   * Directory holding Pi's global agent config (auth.json, models.json,
+   * settings.json). When omitted, a per-session temp dir is used (the
+   * harness cannot reuse existing CLI logins). Pass the user's agent dir
+   * (e.g. `~/.pi/agent/`) to reuse their CLI auth and model settings.
+   */
+  readonly agentDir?: string;
 }
 
 interface PendingToolResult {
@@ -320,25 +331,39 @@ export async function createPiSession(
   });
 
   // Pi auth + model registry are global to this Pi session. These live on the
-  // real host filesystem (`hostAgentDir`), never in the sandbox/workspace.
-  const authStorage = AuthStorage.create(path.join(hostAgentDir, 'auth.json'));
-  const modelRegistry = ModelRegistry.create(
-    authStorage,
-    path.join(hostAgentDir, 'models.json'),
-  );
-  const settingsManager = SettingsManager.inMemory();
+  // real host filesystem, never in the sandbox/workspace.
+  // When `agentDir` is provided, use it instead so the harness can reuse
+  // existing CLI logins and model/settings config.
+  const agentDir = input.agentDir ?? hostAgentDir;
+  const modelRuntime = await ModelRuntime.create({
+    authPath: path.join(agentDir, 'auth.json'),
+    modelsPath: path.join(agentDir, 'models.json'),
+    allowModelNetwork: false,
+  });
+  const modelRegistry = new ModelRegistry(modelRuntime);
+  const settingsManager =
+    input.agentDir != null
+      ? SettingsManager.create(hostWorkDir, agentDir)
+      : SettingsManager.inMemory();
 
   // Run-scoped env (for the model resolver's gateway fallback heuristic).
   const resolverEnv = resolvePiEnv({
     options: input.settings.auth,
     env: process.env,
+  });
+  await registerPiProviders({
+    options: input.settings.auth,
+    resolvedEnv: resolverEnv,
     registries: {
-      authStorage,
       modelRegistry,
+      modelRuntime,
     },
     clientApp: input.clientApp,
   });
-  const resolveModel = createPiModelResolver(modelRegistry, resolverEnv);
+  const resolveModel = createPiModelResolver({
+    modelRegistry,
+    env: resolverEnv,
+  });
   // Resolve once: deterministic given the configured model. This is the Pi
   // `Model` object handed to `createAgentSession`.
   const resolvedModel = resolveModel(input.settings.model);
@@ -579,8 +604,7 @@ export async function createPiSession(
     const { session } = await createAgentSession({
       cwd: sessionWorkDir,
       agentDir: hostAgentDir,
-      authStorage,
-      modelRegistry,
+      modelRuntime,
       sessionManager,
       settingsManager,
       resourceLoader,