@wix/pathgrade 1.0.11 → 1.0.12

package/README.md

@@ -13,7 +13,7 @@
 
 ## Quick Start
 
-**Prerequisites**: Node.js 20.11+, Vitest 4+ or Jest 30+, and at least one configured agent runtime. Claude uses the bundled `@anthropic-ai/claude-agent-sdk` binary by default; Codex requires the `codex` CLI; Cursor requires the `cursor-agent` CLI. OpenCode requires the exact v1.18.18 macOS ARM64 or Linux ARM64 executable.
+**Prerequisites**: Node.js 20.11+, Vitest 4+ or Jest 30+, and at least one configured agent runtime. Claude uses the bundled `@anthropic-ai/claude-agent-sdk` binary by default; Codex requires the `codex` CLI; Cursor requires the `cursor-agent` CLI. OpenCode requires the exact Wix-registry v1.18.14 macOS ARM64 or Linux ARM64 executable.
 
 ```bash
 yarn add -D @wix/pathgrade
@@ -41,8 +41,9 @@ By default, Pathgrade tries to reuse the agent CLI's native auth before falling
   - macOS: reuses `cursor-agent login` OAuth tokens from the login Keychain
   - surfaces a clear error when neither is available (run `cursor-agent login` or set `CURSOR_API_KEY`)
 - **OpenCode**
-  - requires an explicit `ANTHROPIC_API_KEY` in `createAgent({ env })`; ambient credentials and login state are never read
-  - accepts an optional explicit HTTPS `ANTHROPIC_BASE_URL` ending in `/v1`
+  - defaults to `anthropic/claude-sonnet-5` with an explicit or host `ANTHROPIC_API_KEY` and optional HTTPS `/v1` proxy
+  - supports `model: 'openai/gpt-5.4'` with an explicit or host `OPENAI_API_KEY`
+  - when no OpenAI key or proxy is set, stages the validated OpenAI access record with a disabled refresh sentinel; it never copies the host refresh token or writes credentials back
 
 If you set `ANTHROPIC_BASE_URL`, `OPENAI_BASE_URL`, or `CURSOR_API_BASE_URL`, set the matching API key too.
 
@@ -243,15 +244,13 @@ OpenCode v1 is only for fixtures, prompts, skills, and generated MCP mocks contr
 ```typescript
 const agent = await createAgent({
     agent: 'opencode',
-    opencodeExecutable: '/absolute/path/to/opencode-v1.18.18',
-    env: {
-        ANTHROPIC_API_KEY: process.env.APP_ANTHROPIC_API_KEY!,
-        ANTHROPIC_BASE_URL: 'https://api.example.com/v1',
-    },
+    opencodeExecutable: '/absolute/path/to/opencode-v1.18.14',
 });
 ```
 
-The backend supports only `anthropic/claude-sonnet-5`, generated stdio `mcpMock` servers, and clean hosts without system-managed OpenCode configuration. `PATHGRADE_AGENT=opencode` selects the backend but does not supply the required executable or credentials.
+The backend supports `anthropic/claude-sonnet-5` (default) and `openai/gpt-5.4`, generated stdio `mcpMock` servers, and clean hosts without system-managed OpenCode configuration. `PATHGRADE_AGENT=opencode` selects the backend but does not supply the required executable. Selecting GPT-5.4 opts into the ChatGPT Codex endpoint/account plane. A custom `OPENAI_BASE_URL` always requires a matching key and never receives the local OAuth bearer token. Explicit API keys use only an explicitly paired base URL; they never inherit an ambient host proxy.
+
+Pathgrade's default persona, summarization, and plain-judge helpers follow the selected OpenCode provider. GPT-5.4 API-key runs use the OpenAI helper provider and never fall through to Claude CLI. Local OAuth authenticates only the isolated OpenCode process; OAuth-only runs must inject an LLM for helper calls or provide an explicit `OPENAI_API_KEY`. Tool-using judges still require the Anthropic HTTP provider.
 
 ### `agent.prompt()` - One shot
 
@@ -430,8 +429,8 @@ Notes:
 
 | Variable | Purpose |
 |----------|---------|
-| `ANTHROPIC_API_KEY` | Claude auth; also required explicitly in `AgentOptions.env` for OpenCode |
-| `OPENAI_API_KEY` | Codex auth and the required key when using `OPENAI_BASE_URL` |
+| `ANTHROPIC_API_KEY` | Claude auth; explicit or host API-key auth for OpenCode's default model |
+| `OPENAI_API_KEY` | Codex auth; optional explicit or host API-key auth for OpenCode GPT-5.4, and required with `OPENAI_BASE_URL` |
 | `CURSOR_API_KEY` | Cursor auth and the required key when using `CURSOR_API_BASE_URL` |
 | `ANTHROPIC_BASE_URL` | Custom Anthropic-compatible endpoint |
 | `OPENAI_BASE_URL` | Custom OpenAI-compatible endpoint |

package/dist/agents/opencode/contract.d.ts

@@ -1,24 +1,60 @@
 import type { MockMcpServerDescriptor } from '../../core/mcp-mock.types.js';
 import type { AgentName, AgentOptions } from '../../sdk/types.js';
-export declare const OPENCODE_MODEL = "anthropic/claude-sonnet-5";
-export declare const OPENCODE_VERSION = "1.18.18";
+export declare const OPENCODE_VERSION = "1.18.14";
+export declare const DEFAULT_OPENCODE_MODEL = "anthropic/claude-sonnet-5";
+export interface OpenCodeModelContract {
+    provider: 'anthropic' | 'openai';
+    apiKeyEnv: 'ANTHROPIC_API_KEY' | 'OPENAI_API_KEY';
+    baseUrlEnv: 'ANTHROPIC_BASE_URL' | 'OPENAI_BASE_URL';
+    allowsLocalOAuth: boolean;
+}
+export declare const OPENCODE_MODELS: {
+    readonly 'anthropic/claude-sonnet-5': {
+        readonly provider: "anthropic";
+        readonly apiKeyEnv: "ANTHROPIC_API_KEY";
+        readonly baseUrlEnv: "ANTHROPIC_BASE_URL";
+        readonly allowsLocalOAuth: false;
+    };
+    readonly 'openai/gpt-5.4': {
+        readonly provider: "openai";
+        readonly apiKeyEnv: "OPENAI_API_KEY";
+        readonly baseUrlEnv: "OPENAI_BASE_URL";
+        readonly allowsLocalOAuth: true;
+    };
+};
+export type OpenCodeModel = keyof typeof OPENCODE_MODELS;
+export declare const OPENCODE_DISABLED_REFRESH_TOKEN = "pathgrade-refresh-disabled";
+export interface OpenCodeOAuthRecord {
+    type: 'oauth';
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId?: string;
+    enterpriseUrl?: string;
+}
+export declare function sanitizeOpenCodeOAuthRecord(value: unknown): OpenCodeOAuthRecord | undefined;
+export declare function resolveOpenCodeModel(model?: string): {
+    model: OpenCodeModel;
+    contract: OpenCodeModelContract;
+};
 export interface OpenCodeRuntimeLockEntry {
     version: typeof OPENCODE_VERSION;
     executableSha256: string;
 }
 export declare const OPENCODE_RUNTIME_LOCK: {
     readonly 'darwin-arm64': {
-        readonly version: "1.18.18";
-        readonly executableSha256: "4f5979c2dadb06fbff1335335afaaea274e58f92e79aa43cf2ed98618d555422";
+        readonly version: "1.18.14";
+        readonly executableSha256: "8b7c4e116c1ac5163c02fa85eee5a13d4d00c8a08e677dac4100f55aa56532fa";
     };
     readonly 'linux-arm64': {
-        readonly version: "1.18.18";
-        readonly executableSha256: "a63ef0c7271383e48ffe36c156b4146087bbbc97929dec40e8be95ed4f4d76ae";
+        readonly version: "1.18.14";
+        readonly executableSha256: "79d42436517e485e9444cfc6e92582bf9224a9e36fa77fb3957b343486fec81d";
     };
 };
 export type OpenCodePlatformKey = keyof typeof OPENCODE_RUNTIME_LOCK;
 export declare function getOpenCodePlatformKey(platform: NodeJS.Platform, arch: string): OpenCodePlatformKey | undefined;
 export declare function currentOpenCodePlatformKey(): OpenCodePlatformKey | undefined;
+export declare function validateOpenCodeBaseUrl(value: string, variable?: string): void;
 export declare function validateOpenCodeDeclaration(agent: AgentName, opts: AgentOptions): void;
 export declare function sanitizeOpenCodeToolName(value: string): string;
 export declare function collectOpenCodeMcpToolNames(declaration: MockMcpServerDescriptor | MockMcpServerDescriptor[] | undefined): string[];

package/dist/agents/opencode/contract.js

@@ -1,14 +1,54 @@
 import * as path from 'node:path';
-export const OPENCODE_MODEL = 'anthropic/claude-sonnet-5';
-export const OPENCODE_VERSION = '1.18.18';
+export const OPENCODE_VERSION = '1.18.14';
+export const DEFAULT_OPENCODE_MODEL = 'anthropic/claude-sonnet-5';
+export const OPENCODE_MODELS = {
+    'anthropic/claude-sonnet-5': {
+        provider: 'anthropic', apiKeyEnv: 'ANTHROPIC_API_KEY',
+        baseUrlEnv: 'ANTHROPIC_BASE_URL', allowsLocalOAuth: false,
+    },
+    'openai/gpt-5.4': {
+        provider: 'openai', apiKeyEnv: 'OPENAI_API_KEY',
+        baseUrlEnv: 'OPENAI_BASE_URL', allowsLocalOAuth: true,
+    },
+};
+export const OPENCODE_DISABLED_REFRESH_TOKEN = 'pathgrade-refresh-disabled';
+export function sanitizeOpenCodeOAuthRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.type !== 'oauth'
+        || typeof record.access !== 'string' || !record.access.trim()
+        || typeof record.refresh !== 'string' || !record.refresh.trim()
+        || typeof record.expires !== 'number' || !Number.isSafeInteger(record.expires) || record.expires < 0
+        || (record.accountId !== undefined && typeof record.accountId !== 'string')
+        || (record.enterpriseUrl !== undefined && typeof record.enterpriseUrl !== 'string')) {
+        return undefined;
+    }
+    return {
+        type: 'oauth',
+        access: record.access,
+        refresh: record.refresh,
+        expires: record.expires,
+        ...(record.accountId !== undefined ? { accountId: record.accountId } : {}),
+        ...(record.enterpriseUrl !== undefined ? { enterpriseUrl: record.enterpriseUrl } : {}),
+    };
+}
+export function resolveOpenCodeModel(model) {
+    const selected = model ?? DEFAULT_OPENCODE_MODEL;
+    if (!hasOwn(OPENCODE_MODELS, selected)) {
+        throw new Error(`OpenCode supports only models ${Object.keys(OPENCODE_MODELS).join(' and ')}`);
+    }
+    const normalized = selected;
+    return { model: normalized, contract: OPENCODE_MODELS[normalized] };
+}
 export const OPENCODE_RUNTIME_LOCK = {
     'darwin-arm64': {
         version: OPENCODE_VERSION,
-        executableSha256: '4f5979c2dadb06fbff1335335afaaea274e58f92e79aa43cf2ed98618d555422',
+        executableSha256: '8b7c4e116c1ac5163c02fa85eee5a13d4d00c8a08e677dac4100f55aa56532fa',
     },
     'linux-arm64': {
         version: OPENCODE_VERSION,
-        executableSha256: 'a63ef0c7271383e48ffe36c156b4146087bbbc97929dec40e8be95ed4f4d76ae',
+        executableSha256: '79d42436517e485e9444cfc6e92582bf9224a9e36fa77fb3957b343486fec81d',
     },
 };
 export function getOpenCodePlatformKey(platform, arch) {
@@ -21,16 +61,17 @@ export function currentOpenCodePlatformKey() {
 function hasOwn(record, key) {
     return Object.prototype.hasOwnProperty.call(record, key);
 }
-function assertOpenCodeBaseUrl(value) {
+export function validateOpenCodeBaseUrl(value, variable = 'ANTHROPIC_BASE_URL') {
+    const error = `OpenCode ${variable} must be an absolute HTTPS API root ending in /v1`;
     let url;
     try {
         url = new URL(value);
     }
     catch {
-        throw new Error('OpenCode ANTHROPIC_BASE_URL must be an absolute HTTPS API root ending in /v1');
+        throw new Error(error);
     }
     if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash || !url.pathname.endsWith('/v1')) {
-        throw new Error('OpenCode ANTHROPIC_BASE_URL must be an absolute HTTPS API root ending in /v1');
+        throw new Error(error);
     }
 }
 export function validateOpenCodeDeclaration(agent, opts) {
@@ -46,18 +87,20 @@ export function validateOpenCodeDeclaration(agent, opts) {
     if (!opts.opencodeExecutable || !path.isAbsolute(opts.opencodeExecutable)) {
         throw new Error('OpenCode requires an absolute opencodeExecutable path');
     }
-    if (opts.model !== undefined && opts.model !== OPENCODE_MODEL) {
-        throw new Error(`OpenCode v1 supports only model ${OPENCODE_MODEL}`);
-    }
+    const { contract } = resolveOpenCodeModel(opts.model);
     const env = opts.env ?? {};
-    if (!hasOwn(env, 'ANTHROPIC_API_KEY') || !env.ANTHROPIC_API_KEY?.trim()) {
-        throw new Error('OpenCode requires a nonempty own env.ANTHROPIC_API_KEY');
+    if (hasOwn(env, contract.apiKeyEnv) && !env[contract.apiKeyEnv]?.trim()) {
+        throw new Error(`OpenCode env.${contract.apiKeyEnv} must be nonempty when provided`);
     }
-    if (hasOwn(env, 'ANTHROPIC_BASE_URL')) {
-        if (!env.ANTHROPIC_BASE_URL) {
-            throw new Error('OpenCode ANTHROPIC_BASE_URL must be a nonempty absolute HTTPS API root ending in /v1');
+    if (hasOwn(env, contract.baseUrlEnv)) {
+        if (!env[contract.baseUrlEnv]) {
+            throw new Error(`OpenCode ${contract.baseUrlEnv} must be a nonempty absolute HTTPS API root ending in /v1`);
+        }
+        validateOpenCodeBaseUrl(env[contract.baseUrlEnv], contract.baseUrlEnv);
+        if (!hasOwn(env, contract.apiKeyEnv)) {
+            throw new Error(`OpenCode env.${contract.baseUrlEnv} requires an explicit env.${contract.apiKeyEnv}; ` +
+                'host credentials are never sent to caller-provided endpoints.');
         }
-        assertOpenCodeBaseUrl(env.ANTHROPIC_BASE_URL);
     }
     if (opts.copyFromHome !== undefined)
         throw new Error('OpenCode does not support copyFromHome');

package/dist/agents/opencode/runtime-policy.d.ts

@@ -0,0 +1,18 @@
+import { type OpenCodeModel } from './contract.js';
+export declare const OPENCODE_PERMISSION: string;
+export declare class OpenCodeRuntimePolicy {
+    readonly model: OpenCodeModel;
+    readonly oauth: boolean;
+    private readonly authPath;
+    private readonly expectedAuthDigest;
+    private readonly expectedAuthFingerprint;
+    private authWatcher;
+    private authMutationObserved;
+    private constructor();
+    static create(runtimeEnv: Record<string, string>, requestedModel?: string): Promise<OpenCodeRuntimePolicy>;
+    environment(): Record<string, string>;
+    beforeTurn(remainingMs: number, now?: number): Promise<void>;
+    afterTurn(): Promise<void>;
+    private startAuthMonitor;
+    private readUnchanged;
+}

package/dist/agents/opencode/runtime-policy.js

@@ -0,0 +1,156 @@
+import { createHash } from 'node:crypto';
+import { constants, watch } from 'node:fs';
+import { open } from 'node:fs/promises';
+import * as path from 'node:path';
+import { OPENCODE_DISABLED_REFRESH_TOKEN, resolveOpenCodeModel, sanitizeOpenCodeOAuthRecord, } from './contract.js';
+const OAUTH_SKEW_MS = 5 * 60 * 1_000;
+const FIXED_ENV = {
+    OPENCODE_CLIENT: 'pathgrade',
+    OPENCODE_DISABLE_AUTOUPDATE: '1',
+    OPENCODE_DISABLE_PRUNE: '1',
+    OPENCODE_DISABLE_MODELS_FETCH: '1',
+    OPENCODE_DISABLE_EXTERNAL_SKILLS: '1',
+    OPENCODE_DISABLE_LSP_DOWNLOAD: '1',
+    OPENCODE_DISABLE_SHARE: '1',
+    OPENCODE_PURE: '1',
+};
+export const OPENCODE_PERMISSION = JSON.stringify({
+    read: 'allow', edit: 'allow', glob: 'allow', grep: 'allow', list: 'allow',
+    bash: 'allow', todowrite: 'allow', lsp: 'allow', skill: 'allow',
+    task: 'deny', question: 'deny', plan_enter: 'deny', plan_exit: 'deny',
+    external_directory: 'deny', webfetch: 'deny', websearch: 'deny',
+});
+function digest(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function oauthExpiry(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('Staged OpenCode OpenAI login is invalid; refresh it locally and start a new agent.');
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)
+        || Object.keys(parsed).length !== 1 || !('openai' in parsed)) {
+        throw new Error('Staged OpenCode OpenAI login is invalid; refresh it locally and start a new agent.');
+    }
+    const record = sanitizeOpenCodeOAuthRecord(parsed.openai);
+    if (!record || record.refresh !== OPENCODE_DISABLED_REFRESH_TOKEN) {
+        throw new Error('Staged OpenCode OpenAI login is invalid; refresh it locally and start a new agent.');
+    }
+    return record.expires;
+}
+async function readRegularMode600(filename) {
+    const handle = await open(filename, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await handle.stat({ bigint: true });
+        if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 511n) !== 384n) {
+            throw new Error('mode');
+        }
+        return {
+            raw: await handle.readFile('utf8'),
+            fingerprint: [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(':'),
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function poisonedAuthError() {
+    return new Error('OpenCode changed its staged OpenAI login; this session is poisoned. ' +
+        'The host login was not updated; refresh it locally and start a new agent.');
+}
+export class OpenCodeRuntimePolicy {
+    model;
+    oauth;
+    authPath;
+    expectedAuthDigest;
+    expectedAuthFingerprint;
+    authWatcher;
+    authMutationObserved = false;
+    constructor(model, authPath, expectedAuthDigest, expectedAuthFingerprint) {
+        this.model = model;
+        this.authPath = authPath;
+        this.expectedAuthDigest = expectedAuthDigest;
+        this.expectedAuthFingerprint = expectedAuthFingerprint;
+        this.oauth = expectedAuthDigest !== undefined;
+    }
+    static async create(runtimeEnv, requestedModel) {
+        const { model, contract } = resolveOpenCodeModel(requestedModel);
+        const home = runtimeEnv.HOME;
+        if (!home)
+            throw new Error('OpenCode requires a managed HOME');
+        const authPath = path.join(home, '.local', 'share', 'opencode', 'auth.json');
+        const hasApiKey = Boolean(runtimeEnv[contract.apiKeyEnv]?.trim());
+        if (!contract.allowsLocalOAuth || hasApiKey) {
+            return new OpenCodeRuntimePolicy(model, authPath);
+        }
+        let snapshot;
+        try {
+            snapshot = await readRegularMode600(authPath);
+        }
+        catch {
+            throw new Error('OpenCode OpenAI OAuth staging is missing or not mode 0600.');
+        }
+        oauthExpiry(snapshot.raw);
+        return new OpenCodeRuntimePolicy(model, authPath, digest(snapshot.raw), snapshot.fingerprint);
+    }
+    environment() {
+        return this.oauth
+            ? { ...FIXED_ENV }
+            : { ...FIXED_ENV, OPENCODE_DISABLE_DEFAULT_PLUGINS: '1' };
+    }
+    async beforeTurn(remainingMs, now = Date.now()) {
+        if (!this.oauth)
+            return;
+        const raw = await this.readUnchanged();
+        const expires = oauthExpiry(raw);
+        if (expires <= now + remainingMs + OAUTH_SKEW_MS) {
+            throw new Error('Local OpenCode OpenAI login will expire before this turn can finish. ' +
+                'Refresh it with `opencode auth login` locally and start a new agent.');
+        }
+        this.startAuthMonitor();
+    }
+    async afterTurn() {
+        if (!this.oauth)
+            return;
+        try {
+            await this.readUnchanged();
+            await new Promise((resolve) => setImmediate(resolve));
+            if (this.authMutationObserved)
+                throw poisonedAuthError();
+        }
+        finally {
+            this.authWatcher?.close();
+            this.authWatcher = undefined;
+        }
+    }
+    startAuthMonitor() {
+        if (this.authWatcher)
+            throw new Error('OpenCode auth monitor is already active');
+        this.authMutationObserved = false;
+        const expectedName = path.basename(this.authPath);
+        this.authWatcher = watch(path.dirname(this.authPath), { persistent: false }, (_event, filename) => {
+            if (filename === null || filename.toString() === expectedName)
+                this.authMutationObserved = true;
+        });
+        this.authWatcher.on('error', () => {
+            this.authMutationObserved = true;
+        });
+    }
+    async readUnchanged() {
+        let snapshot;
+        try {
+            snapshot = await readRegularMode600(this.authPath);
+        }
+        catch {
+            throw poisonedAuthError();
+        }
+        if (digest(snapshot.raw) !== this.expectedAuthDigest
+            || snapshot.fingerprint !== this.expectedAuthFingerprint) {
+            throw poisonedAuthError();
+        }
+        return snapshot.raw;
+    }
+}

package/dist/agents/opencode.js

@@ -7,38 +7,11 @@ import fs from 'fs-extra';
 import { BaseAgent, getRuntimeEnv, getWorkspacePath, } from '../types.js';
 import { buildSummary, enrichSkillEvents } from '../tool-events.js';
 import { readStagedMcpServers } from '../providers/mcp-config.js';
-import { currentOpenCodePlatformKey, OPENCODE_MODEL, OPENCODE_RUNTIME_LOCK, } from './opencode/contract.js';
+import { removeSandboxRoot } from '../providers/sandbox-lifecycle.js';
+import { currentOpenCodePlatformKey, OPENCODE_RUNTIME_LOCK, } from './opencode/contract.js';
+import { OpenCodeRuntimePolicy, OPENCODE_PERMISSION } from './opencode/runtime-policy.js';
 import { killOpenCodeProcessGroup, registerOpenCodeProcessGroup, unregisterOpenCodeProcessGroup, } from './opencode/process-groups.js';
 const OUTPUT_CAP_BYTES = 16 * 1024 * 1024;
-const FIXED_OPENCODE_ENV = {
-    OPENCODE_CLIENT: 'pathgrade',
-    OPENCODE_DISABLE_AUTOUPDATE: '1',
-    OPENCODE_DISABLE_PRUNE: '1',
-    OPENCODE_DISABLE_MODELS_FETCH: '1',
-    OPENCODE_DISABLE_DEFAULT_PLUGINS: '1',
-    OPENCODE_DISABLE_EXTERNAL_SKILLS: '1',
-    OPENCODE_DISABLE_LSP_DOWNLOAD: '1',
-    OPENCODE_DISABLE_SHARE: '1',
-    OPENCODE_PURE: '1',
-};
-const OPENCODE_PERMISSION = JSON.stringify({
-    read: 'allow',
-    edit: 'allow',
-    glob: 'allow',
-    grep: 'allow',
-    list: 'allow',
-    bash: 'allow',
-    todowrite: 'allow',
-    lsp: 'allow',
-    skill: 'allow',
-    task: 'deny',
-    question: 'deny',
-    plan_enter: 'deny',
-    plan_exit: 'deny',
-    external_directory: 'deny',
-    webfetch: 'deny',
-    websearch: 'deny',
-});
 const NATIVE_TOOL_ACTIONS = {
     bash: 'run_shell',
     read: 'read_file',
@@ -170,12 +143,9 @@ function sanitizedProviderError(event) {
     const data = error.data && typeof error.data === 'object' && !Array.isArray(error.data)
         ? error.data
         : {};
-    const message = typeof data.message === 'string' && data.message.trim()
-        ? data.message.trim().slice(0, 1_000)
-        : 'OpenCode provider error';
     const status = typeof data.statusCode === 'number' ? ` status=${data.statusCode}` : '';
     const retryable = typeof data.isRetryable === 'boolean' ? ` retryable=${data.isRetryable}` : '';
-    return new Error(`${message}${status}${retryable}`);
+    return new Error(`OpenCode provider error${status}${retryable}`);
 }
 export function parseOpenCodeOutput(stdout, processResult, mcpToolNames) {
     if (processResult.overflow)
@@ -375,7 +345,10 @@ class OpenCodeSession {
     mcpConfigPath;
     mcpToolNames;
     getAbortSignal;
+    getRemainingMs;
+    requestedModel;
     xdgDirs;
+    runtimePolicy;
     resolvedExecutable;
     preflightDone = false;
     running = false;
@@ -391,6 +364,8 @@ class OpenCodeSession {
         this.mcpConfigPath = options.mcpConfigPath;
         this.mcpToolNames = new Set(options.opencodeMcpToolNames ?? []);
         this.getAbortSignal = options.getAbortSignal ?? (() => options.abortSignal);
+        this.getRemainingMs = options.getRemainingMs ?? (() => 0);
+        this.requestedModel = options.model;
         const home = this.runtimeEnv.HOME;
         if (!home)
             throw new Error('OpenCode requires a managed HOME');
@@ -432,23 +407,27 @@ class OpenCodeSession {
         try {
             await this.ensurePreflight();
             await assertNoProjectConfig(this.workspacePath);
-            const mcp = await projectMcpConfig(this.workspacePath, this.mcpConfigPath);
-            const env = this.buildEnvironment(mcp);
-            const args = [
-                'run', '--format', 'json', '--thinking', '--dir', this.workspacePath,
-                '--model', OPENCODE_MODEL, '--agent', 'build',
-                ...(this.sessionId ? ['--session', this.sessionId] : []),
-            ];
-            const turnSignal = this.getAbortSignal();
-            const signal = turnSignal
-                ? AbortSignal.any([turnSignal, this.disposeController.signal])
-                : this.disposeController.signal;
-            const processResult = await spawnOpenCode(this.resolvedExecutable, args, {
-                cwd: this.workspacePath,
-                env,
-                stdin: message,
-                signal,
-            });
+            await this.runtimePolicy.beforeTurn(this.getRemainingMs());
+            let processResult;
+            try {
+                const mcp = await projectMcpConfig(this.workspacePath, this.mcpConfigPath);
+                const env = this.buildEnvironment(mcp);
+                const args = [
+                    'run', '--format', 'json', '--thinking', '--dir', this.workspacePath,
+                    '--model', this.runtimePolicy.model, '--agent', 'build',
+                    ...(this.sessionId ? ['--session', this.sessionId] : []),
+                ];
+                const turnSignal = this.getAbortSignal();
+                const signal = turnSignal
+                    ? AbortSignal.any([turnSignal, this.disposeController.signal])
+                    : this.disposeController.signal;
+                processResult = await spawnOpenCode(this.resolvedExecutable, args, {
+                    cwd: this.workspacePath, env, stdin: message, signal,
+                });
+            }
+            finally {
+                await this.runtimePolicy.afterTurn();
+            }
             const parsed = parseOpenCodeOutput(processResult.stdout, processResult, this.mcpToolNames);
             if (this.sessionId && parsed.sessionId !== this.sessionId) {
                 throw new Error('OpenCode protocol error: resumed session ID changed');
@@ -458,7 +437,12 @@ class OpenCodeSession {
         }
         catch (error) {
             this.failed = true;
-            await this.cleanupState();
+            try {
+                await this.cleanupState();
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], 'OpenCode turn failed and isolated state cleanup also failed');
+            }
             throw error;
         }
     }
@@ -477,6 +461,7 @@ class OpenCodeSession {
         await assertCleanManagedOpenCodeHost();
         await assertNoProjectConfig(this.workspacePath);
         await Promise.all(this.xdgDirs.map((directory) => fs.ensureDir(directory)));
+        this.runtimePolicy = await OpenCodeRuntimePolicy.create(this.runtimeEnv, this.requestedModel);
         this.resolvedExecutable = resolved;
         this.preflightDone = true;
     }
@@ -488,10 +473,10 @@ class OpenCodeSession {
             XDG_CONFIG_HOME: config,
             XDG_STATE_HOME: state,
             XDG_CACHE_HOME: cache,
-            ...FIXED_OPENCODE_ENV,
+            ...this.runtimePolicy.environment(),
             OPENCODE_CONFIG_CONTENT: JSON.stringify({
                 share: 'disabled',
-                model: OPENCODE_MODEL,
+                model: this.runtimePolicy.model,
                 skills: { paths: ['.agents/skills'], urls: [] },
                 mcp,
             }),
@@ -499,7 +484,7 @@ class OpenCodeSession {
         };
     }
     async cleanupState() {
-        await Promise.all(this.xdgDirs.map((directory) => fs.remove(directory)));
+        await Promise.all(this.xdgDirs.map((directory) => removeSandboxRoot(directory)));
     }
     async dispose() {
         if (this.disposed)

package/dist/providers/credentials.d.ts

@@ -16,6 +16,13 @@ export interface CredentialPorts {
     keychainEntryExists(service: string, account: string): Promise<boolean>;
     /** Check if a path exists on the host filesystem. */
     fileExists(absolutePath: string): Promise<boolean>;
+    /** Read a sensitive host text file without exposing it to logs. */
+    readTextFile(absolutePath: string): Promise<string>;
+}
+export interface SensitiveHomeFile {
+    relativePath: string;
+    content: string;
+    mode: number;
 }
 export interface CredentialResult {
     /** Env vars to merge into sandbox env. */
@@ -30,7 +37,12 @@ export interface CredentialResult {
      * host (e.g. macOS `Library/Keychains`). Optional; defaults to none.
      */
     linkFromHome?: string[];
+    /** Filtered sensitive files to create inside the isolated HOME. */
+    sensitiveHomeFiles?: SensitiveHomeFile[];
 }
 /** Default ports using real process.env, Keychain, and filesystem. */
 export declare function defaultPorts(): CredentialPorts;
-export declare function resolveCredentials(agent: AgentName, userEnv: Record<string, string>, ports?: CredentialPorts): Promise<CredentialResult>;
+export interface CredentialContext {
+    model?: string;
+}
+export declare function resolveCredentials(agent: AgentName, userEnv: Record<string, string>, ports?: CredentialPorts, context?: CredentialContext): Promise<CredentialResult>;

package/dist/providers/credentials.js

@@ -16,6 +16,7 @@ import { execSync, execFileSync } from 'child_process';
 import * as os from 'os';
 import * as path from 'path';
 import fs from 'fs-extra';
+import { OPENCODE_DISABLED_REFRESH_TOKEN, resolveOpenCodeModel, sanitizeOpenCodeOAuthRecord, validateOpenCodeBaseUrl, } from '../agents/opencode/contract.js';
 const EMPTY = { env: {}, setupCommands: [], copyFromHome: [] };
 /** Default ports using real process.env, Keychain, and filesystem. */
 export function defaultPorts() {
@@ -49,9 +50,12 @@ export function defaultPorts() {
         async fileExists(absolutePath) {
             return fs.pathExists(absolutePath);
         },
+        async readTextFile(absolutePath) {
+            return fs.readFile(absolutePath, 'utf8');
+        },
     };
 }
-export async function resolveCredentials(agent, userEnv, ports) {
+export async function resolveCredentials(agent, userEnv, ports, context = {}) {
     const p = ports ?? defaultPorts();
     switch (agent) {
         case 'claude':
@@ -61,20 +65,99 @@ export async function resolveCredentials(agent, userEnv, ports) {
         case 'cursor':
             return resolveCursor(userEnv, p);
         case 'opencode':
-            return resolveOpenCode(userEnv);
+            return resolveOpenCode(userEnv, p, resolveOpenCodeModel(context.model).model);
         default:
             return EMPTY;
     }
 }
-function resolveOpenCode(userEnv) {
+async function resolveOpenCode(userEnv, ports, model) {
+    const { contract } = resolveOpenCodeModel(model);
     const env = {};
-    if (userEnv.ANTHROPIC_API_KEY) {
-        env.ANTHROPIC_API_KEY = userEnv.ANTHROPIC_API_KEY;
+    const hasUserKey = Object.prototype.hasOwnProperty.call(userEnv, contract.apiKeyEnv);
+    const userKey = hasUserKey ? userEnv[contract.apiKeyEnv] : undefined;
+    if (hasUserKey && !userKey?.trim()) {
+        throw new Error(`OpenCode env.${contract.apiKeyEnv} must be nonempty when provided`);
     }
-    if (userEnv.ANTHROPIC_BASE_URL) {
-        env.ANTHROPIC_BASE_URL = userEnv.ANTHROPIC_BASE_URL;
+    const hasUserBaseUrl = Object.prototype.hasOwnProperty.call(userEnv, contract.baseUrlEnv);
+    let baseUrl;
+    if (hasUserBaseUrl) {
+        baseUrl = userEnv[contract.baseUrlEnv];
+        if (!baseUrl) {
+            throw new Error(`OpenCode ${contract.baseUrlEnv} must be a nonempty absolute HTTPS API root ending in /v1`);
+        }
+        validateOpenCodeBaseUrl(baseUrl, contract.baseUrlEnv);
+        if (!hasUserKey) {
+            throw new Error(`OpenCode env.${contract.baseUrlEnv} requires an explicit env.${contract.apiKeyEnv}; ` +
+                'host credentials are never sent to caller-provided endpoints.');
+        }
     }
-    return { env, setupCommands: [], copyFromHome: [] };
+    const hostKey = hasUserKey ? undefined : ports.hostEnv(contract.apiKeyEnv);
+    const apiKey = userKey || hostKey;
+    if (!hasUserKey && hostKey?.trim())
+        env[contract.apiKeyEnv] = hostKey;
+    if (!hasUserBaseUrl && !hasUserKey) {
+        const hostBaseUrl = ports.hostEnv(contract.baseUrlEnv);
+        if (hostBaseUrl) {
+            validateOpenCodeBaseUrl(hostBaseUrl, contract.baseUrlEnv);
+            env[contract.baseUrlEnv] = hostBaseUrl;
+            baseUrl = hostBaseUrl;
+        }
+    }
+    if (apiKey?.trim())
+        return { env, setupCommands: [], copyFromHome: [] };
+    if (baseUrl) {
+        throw new Error(`OpenCode ${contract.baseUrlEnv} is set but ${contract.apiKeyEnv} is missing; ` +
+            'local OAuth is never sent to a custom endpoint.');
+    }
+    if (!contract.allowsLocalOAuth) {
+        throw new Error(`OpenCode authentication requires ${contract.apiKeyEnv}. ` +
+            'Provide it in env or set it in your host environment.');
+    }
+    const hostXdgDataHome = ports.hostEnv('XDG_DATA_HOME')?.trim();
+    if (hostXdgDataHome && !path.isAbsolute(hostXdgDataHome)) {
+        throw new Error('OpenCode host XDG_DATA_HOME must be absolute when provided.');
+    }
+    const xdgDataHome = hostXdgDataHome || path.join(ports.homedir, '.local', 'share');
+    const authPath = path.join(xdgDataHome, 'opencode', 'auth.json');
+    let raw;
+    try {
+        raw = await ports.readTextFile(authPath);
+    }
+    catch {
+        throw new Error(`OpenCode authentication requires ${contract.apiKeyEnv} or a local OpenCode OpenAI login. ` +
+            'Run `opencode auth login` locally and try again.');
+    }
+    const filtered = filterOpenCodeOAuthRecord(raw);
+    return filtered;
+}
+function filterOpenCodeOAuthRecord(raw) {
+    let store;
+    try {
+        store = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('Local OpenCode OpenAI login is invalid; run `opencode auth login` locally and try again.');
+    }
+    if (!store || typeof store !== 'object' || Array.isArray(store)) {
+        throw new Error('Local OpenCode OpenAI login is invalid; run `opencode auth login` locally and try again.');
+    }
+    const openai = store.openai;
+    if (!openai || typeof openai !== 'object' || Array.isArray(openai)) {
+        throw new Error('Local OpenCode OpenAI login is missing; run `opencode auth login` locally and try again.');
+    }
+    const record = sanitizeOpenCodeOAuthRecord(openai);
+    if (!record) {
+        throw new Error('Local OpenCode OpenAI login is invalid; run `opencode auth login` locally and try again.');
+    }
+    const sanitized = { ...record, refresh: OPENCODE_DISABLED_REFRESH_TOKEN };
+    return {
+        env: {}, setupCommands: [], copyFromHome: [],
+        sensitiveHomeFiles: [{
+                relativePath: path.join('.local', 'share', 'opencode', 'auth.json'),
+                content: JSON.stringify({ openai: sanitized }),
+                mode: 0o600,
+            }],
+    };
 }
 async function resolveClaude(userEnv, ports) {
     // User explicitly provided API key — trust it, nothing to add

package/dist/providers/sandbox.d.ts

@@ -1,5 +1,7 @@
 export interface SandboxConfig {
     agent: import('../sdk/types.js').AgentName;
+    /** Internal provider/model context; ignored by sandbox creation itself. */
+    model?: string;
     workspace?: string;
     skillDir?: string;
     copyFromHome?: string[];

package/dist/providers/workspace.js

@@ -18,6 +18,17 @@ async function copyPathsFromHostHome(pathsToCopy, sandboxHomePath) {
         await fs.copy(srcPath, destPath, { filter: isPortableCopyEntry });
     }
 }
+async function stageSensitiveHomeFiles(files, sandboxHomePath) {
+    for (const file of files) {
+        if (path.isAbsolute(file.relativePath) || file.relativePath.split(path.sep).includes('..')) {
+            throw new Error('Sensitive credential staging path must stay inside the sandbox HOME');
+        }
+        const destination = path.join(sandboxHomePath, file.relativePath);
+        await fs.ensureDir(path.dirname(destination));
+        await fs.writeFile(destination, file.content, { encoding: 'utf8', mode: file.mode, flag: 'wx' });
+        await fs.chmod(destination, file.mode);
+    }
+}
 export async function linkPathsFromHostHome(pathsToLink, sandboxHomePath) {
     const realHome = os.homedir();
     for (const relPath of pathsToLink) {
@@ -36,10 +47,11 @@ export async function prepareWorkspace(spec) {
     try {
         // Resolve credentials: pass user's original env (not sandboxEnv) so
         // the resolver can distinguish explicit user intent from auto-resolved values.
-        const creds = await resolveCredentials(spec.agent, spec.env ?? {});
+        const creds = await resolveCredentials(spec.agent, spec.env ?? {}, undefined, { model: spec.model });
         Object.assign(sandboxEnv, creds.env);
         await copyPathsFromHostHome(creds.copyFromHome, homePath);
         await linkPathsFromHostHome(creds.linkFromHome ?? [], homePath);
+        await stageSensitiveHomeFiles(creds.sensitiveHomeFiles ?? [], homePath);
         const { mcpConfigPath } = await stageMcpConfig(workspacePath, mcp);
         let disposed = false;
         return {
@@ -57,7 +69,12 @@ export async function prepareWorkspace(spec) {
         };
     }
     catch (error) {
-        await fs.remove(rootDir).catch(() => { });
+        try {
+            await removeSandboxRoot(rootDir);
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], 'Workspace setup failed and the sandbox could not be removed');
+        }
         throw error;
     }
 }

package/dist/sdk/agent.js

@@ -251,6 +251,7 @@ class AgentImpl {
                 ...opts.persona,
                 llm: opts.persona.llm ?? this.llm,
                 conversationWindow: personaWindowConfig,
+                defaultSummaryModel: this.modelOpt,
             });
             personaReply = async () => {
                 const fakeChatSession = {
@@ -393,7 +394,7 @@ export async function createAgent(opts) {
     const timeoutSetting = opts.timeout ?? 300;
     // Capture runner context now; adapters own installation and restoration.
     const testCtx = opts.debug ? resolveCaseDebugContext() : { name: '', dir: '' };
-    const { timeout: _, mcpMock, mcpConfigFile, agent: __, debug: ___, model: ____, transport: _____, mcpSafety: ______, opencodeExecutable, ...rest } = opts;
+    const { timeout: _, mcpMock, mcpConfigFile, agent: __, debug: ___, transport: _____, mcpSafety: ______, opencodeExecutable, ...rest } = opts;
     const workspace = await prepareWorkspace({
         ...rest,
         agent: agentName,
@@ -401,7 +402,7 @@ export async function createAgent(opts) {
     });
     // Create agent LLM once, using the fully-resolved sandbox env (includes
     // keychain OAuth tokens, API keys, safe host vars).
-    const llm = createAgentLLM(agentName, workspace.env);
+    const llm = createAgentLLM(agentName, workspace.env, opts.model);
     // Fall back to sandbox dir name if no test name resolved
     const debugName = testCtx.name || path.basename(path.dirname(workspace.path));
     // Default debug dir is next to the eval file, fallback to cwd

package/dist/sdk/managed-session.js

@@ -28,6 +28,7 @@ export function createManagedSession(deps) {
         ...(deps.opencodeExecutable !== undefined ? { opencodeExecutable: deps.opencodeExecutable } : {}),
         ...(deps.opencodeMcpToolNames !== undefined ? { opencodeMcpToolNames: deps.opencodeMcpToolNames } : {}),
         getAbortSignal: () => currentSignal,
+        getRemainingMs: () => Math.max(0, deadlineMs - Date.now()),
     };
     let session = null;
     let setupDone = false;

package/dist/sdk/persona.d.ts

@@ -2,4 +2,5 @@ import type { LLMPort } from '../utils/llm-types.js';
 import type { Persona, PersonaConfig } from './types.js';
 export declare function createPersona(config: PersonaConfig & {
     llm: LLMPort;
+    defaultSummaryModel?: string;
 }): Persona;

package/dist/sdk/persona.js

@@ -1,8 +1,12 @@
 import { createConversationWindow } from './conversation-window.js';
 export function createPersona(config) {
     const llm = config.llm;
+    const configuredWindowModel = config.conversationWindow === false
+        ? undefined
+        : config.conversationWindow?.model;
+    const summaryModel = config.model ?? configuredWindowModel ?? config.defaultSummaryModel;
     const window = config.conversationWindow !== false
-        ? createConversationWindow({ ...config.conversationWindow, model: config.model, llm })
+        ? createConversationWindow({ ...config.conversationWindow, model: summaryModel, llm })
         : null;
     return {
         async reply(chat) {

package/dist/types.d.ts

@@ -379,6 +379,8 @@ export interface AgentSessionOptions {
     abortSignal?: AbortSignal;
     /** Supplies the current timeout/cancellation signal for reused sessions. */
     getAbortSignal?: () => AbortSignal | undefined;
+    /** Supplies the remaining managed-session deadline for credential validity checks. */
+    getRemainingMs?: () => number;
     /** Absolute pinned runtime path for the OpenCode adapter. */
     opencodeExecutable?: string;
     /** Exact generated MCP tool names accepted by the OpenCode event normalizer. */

package/dist/utils/llm-providers/anthropic.js

@@ -1,16 +1,20 @@
 function getApiKey(env) {
-    return env?.ANTHROPIC_API_KEY
-        || env?.APP_ANTHROPIC_API_KEY
-        || process.env.ANTHROPIC_API_KEY
-        || process.env.APP_ANTHROPIC_API_KEY;
+    return env === undefined
+        ? process.env.ANTHROPIC_API_KEY || process.env.APP_ANTHROPIC_API_KEY
+        : env.ANTHROPIC_API_KEY || env.APP_ANTHROPIC_API_KEY;
 }
 function resolveBaseUrl(env) {
-    return env?.ANTHROPIC_BASE_URL
-        || env?.APP_ANTHROPIC_BASE_URL
-        || process.env.ANTHROPIC_BASE_URL
-        || process.env.APP_ANTHROPIC_BASE_URL
+    return (env === undefined
+        ? process.env.ANTHROPIC_BASE_URL || process.env.APP_ANTHROPIC_BASE_URL
+        : env.ANTHROPIC_BASE_URL || env.APP_ANTHROPIC_BASE_URL)
         || 'https://api.anthropic.com';
 }
+function normalizeModel(model) {
+    const normalized = model.trim();
+    return normalized.toLowerCase().startsWith('anthropic/')
+        ? normalized.slice('anthropic/'.length)
+        : normalized;
+}
 function resolveMessagesUrl(env) {
     const baseUrl = resolveBaseUrl(env).replace(/\/+$/, '');
     const apiRoot = baseUrl.endsWith('/v1') ? baseUrl : `${baseUrl}/v1`;
@@ -79,14 +83,14 @@ export const anthropicProvider = {
         return !!getApiKey(env);
     },
     supportsModel(model) {
-        return model.trim().toLowerCase().startsWith('claude');
+        return normalizeModel(model).toLowerCase().startsWith('claude');
     },
     async call(prompt, opts) {
         const apiKey = getApiKey(opts.env);
         if (!apiKey) {
             throw new Error('No ANTHROPIC_API_KEY available');
         }
-        const model = opts.model || DEFAULT_ANTHROPIC_MODEL;
+        const model = normalizeModel(opts.model || DEFAULT_ANTHROPIC_MODEL);
         const modelConfig = getAnthropicModelConfig(model);
         assertRawAnthropicModel(model, modelConfig);
         const temperature = resolveTemperature(model, modelConfig, opts.temperature);
@@ -120,7 +124,7 @@ export const anthropicProvider = {
         if (!apiKey) {
             throw new Error('No ANTHROPIC_API_KEY available');
         }
-        const model = opts.model || DEFAULT_ANTHROPIC_MODEL;
+        const model = normalizeModel(opts.model || DEFAULT_ANTHROPIC_MODEL);
         const modelConfig = getAnthropicModelConfig(model);
         assertRawAnthropicModel(model, modelConfig);
         const temperature = resolveTemperature(model, modelConfig, opts.temperature);

package/dist/utils/llm-providers/openai.js

@@ -1,5 +1,11 @@
 function getApiKey(env) {
-    return env?.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+    return env === undefined ? process.env.OPENAI_API_KEY : env.OPENAI_API_KEY;
+}
+function normalizeModel(model) {
+    const normalized = model.trim();
+    return normalized.toLowerCase().startsWith('openai/')
+        ? normalized.slice('openai/'.length)
+        : normalized;
 }
 export const openaiProvider = {
     name: 'openai',
@@ -7,7 +13,7 @@ export const openaiProvider = {
         return !!getApiKey(env);
     },
     supportsModel(model) {
-        const normalized = model.trim().toLowerCase();
+        const normalized = normalizeModel(model).toLowerCase();
         return (normalized.startsWith('gpt-')
             || normalized.startsWith('chatgpt-')
             || normalized.startsWith('o1')
@@ -19,9 +25,12 @@ export const openaiProvider = {
         if (!apiKey) {
             throw new Error('No OPENAI_API_KEY available');
         }
-        const model = opts.model || 'gpt-4o';
+        const model = normalizeModel(opts.model || 'gpt-4o');
         const temperature = opts.temperature ?? 0;
-        const baseUrl = (opts.env?.OPENAI_BASE_URL || process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1').replace(/\/$/, '');
+        const configuredBaseUrl = opts.env === undefined
+            ? process.env.OPENAI_BASE_URL
+            : opts.env.OPENAI_BASE_URL;
+        const baseUrl = (configuredBaseUrl || 'https://api.openai.com/v1').replace(/\/$/, '');
         try {
             const response = await fetch(`${baseUrl}/chat/completions`, {
                 method: 'POST',

package/dist/utils/llm.d.ts

@@ -25,7 +25,7 @@ export declare function createLLMClient(opts: CreateLLMClientOptions): LLMPort;
 export declare function createLLMClient(providers: LLMProviderAdapter[], agentName?: string): LLMPort;
 export declare function callLLM(prompt: string, opts?: LLMCallOptions): Promise<LLMCallResult>;
 /**
- * Create an LLM client scoped to the providers that match the given agent.
+ * Create an LLM client scoped to the providers that match the given agent and model.
  *
  * - claude → CLI + Anthropic API (no OpenAI fallthrough)
  * - codex  → OpenAI API
@@ -33,4 +33,4 @@ export declare function callLLM(prompt: string, opts?: LLMCallOptions): Promise<
  * If `agentEnv` is provided, it is merged into every LLM call so that
  * the agent's env propagates to persona/judge/summarization calls.
  */
-export declare function createAgentLLM(agentName: string, agentEnv?: Record<string, string>): LLMPort;
+export declare function createAgentLLM(agentName: string, agentEnv?: Record<string, string>, agentModel?: string): LLMPort;

package/dist/utils/llm.js

@@ -17,6 +17,10 @@ function inferProviderFromModel(model) {
     const normalized = model?.trim().toLowerCase();
     if (!normalized)
         return undefined;
+    if (normalized.startsWith('anthropic/'))
+        return 'anthropic';
+    if (normalized.startsWith('openai/'))
+        return 'openai';
     if (normalized.startsWith('claude'))
         return 'anthropic';
     if (normalized.startsWith('gpt-')
@@ -178,7 +182,7 @@ export async function callLLM(prompt, opts = {}) {
     return defaultClient.call(prompt, opts);
 }
 /**
- * Create an LLM client scoped to the providers that match the given agent.
+ * Create an LLM client scoped to the providers that match the given agent and model.
  *
  * - claude → CLI + Anthropic API (no OpenAI fallthrough)
  * - codex  → OpenAI API
@@ -186,17 +190,18 @@ export async function callLLM(prompt, opts = {}) {
  * If `agentEnv` is provided, it is merged into every LLM call so that
  * the agent's env propagates to persona/judge/summarization calls.
  */
-export function createAgentLLM(agentName, agentEnv) {
+export function createAgentLLM(agentName, agentEnv, agentModel) {
     // Tool-using judges need a provider that implements callWithTools.
     // For claude, anthropicProvider is added as a tool-use-capable fallback
     // alongside the CLI. The CLI still wins for plain call() when available.
     // Cursor inherits the Claude chain by design (judge consistency across
     // harnesses — see PRD §"LLM-backend routing"). Cursor evals therefore
     // depend on Claude CLI or ANTHROPIC_API_KEY being available at judge time.
-    const baseAdapters = agentName === 'codex'
+    const openCodeUsesOpenAI = agentName === 'opencode' && agentModel === 'openai/gpt-5.4';
+    const baseAdapters = agentName === 'codex' || openCodeUsesOpenAI
         ? [openaiProvider]
         : [cliProvider, anthropicProvider];
-    const adapters = agentEnv && Object.keys(agentEnv).length > 0
+    const adapters = agentEnv !== undefined
         ? baseAdapters.map((a) => ({
             ...a,
             isAvailable: (env) => a.isAvailable({ ...agentEnv, ...env }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/pathgrade",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "packageManager": "yarn@4.12.0",
   "description": "Evaluate whether AI agents discover and use your skills correctly",
   "exports": {
@@ -132,5 +132,5 @@
     "typescript": "^5.9.3",
     "zod": "4.3.6"
   },
-  "falconPackageHash": "0bfcf787a0b4fe0c48683c6aa662dd0e3c9679800fdcc9811414571d"
+  "falconPackageHash": "48e95ba80576ede589f0a5e47d60b9c94fd53c1ef435d8ca9af35392"
 }