@wix/pathgrade 1.0.10 → 1.0.12

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

@@ -9,6 +9,7 @@ import { createManagedSession } from './managed-session.js';
 import { createAgentLLM } from '../utils/llm.js';
 import { buildRunSnapshot } from './snapshots.js';
 import { buildModelAgentResultLogEntry } from './agent-result-log.js';
+import { buildToolEventLogEntry } from './tool-event-log.js';
 import { getVisibleAssistantMessage } from './visible-turn.js';
 import { getCurrentCaseContext } from './case-context.js';
 import { createVerboseEmitter } from '../reporters/verbose-emitter.js';
@@ -140,21 +141,18 @@ class AgentImpl {
         this.accumulateTurnUsage(turnResult);
         const response = getVisibleAssistantMessage(turnResult);
         const durationMs = Date.now() - turnStart;
+        const turnCompletedAt = timestamp();
+        for (const toolEvent of turnResult.toolEvents) {
+            this._log.push(buildToolEventLogEntry(toolEvent, turnCompletedAt));
+            this.verbose.toolEvent({ action: toolEvent.action, summary: toolEvent.summary });
+        }
         this._log.push(buildModelAgentResultLogEntry({
-            timestamp: timestamp(),
+            timestamp: turnCompletedAt,
             turnNumber,
             durationMs,
             turnResult,
             assistantMessage: response,
         }));
-        for (const toolEvent of turnResult.toolEvents) {
-            this._log.push({
-                type: 'tool_event',
-                timestamp: timestamp(),
-                tool_event: toolEvent,
-            });
-            this.verbose.toolEvent({ action: toolEvent.action, summary: toolEvent.summary });
-        }
         this._messages.push({ role: 'agent', content: response });
         this.verbose.turnEnd({
             turn: turnNumber,
@@ -234,11 +232,7 @@ class AgentImpl {
             // it undefined, in which case this is a no-op.
             this.accumulateTurnUsage(turnResult);
             for (const toolEvent of turnResult.toolEvents) {
-                this._log.push({
-                    type: 'tool_event',
-                    timestamp: new Date().toISOString(),
-                    tool_event: toolEvent,
-                });
+                this._log.push(buildToolEventLogEntry(toolEvent, new Date().toISOString()));
             }
             // Exit-code failures are no longer thrown here. The runConversation
             // loop projects the partial-turn through `pushModelAgentMessage`
@@ -257,6 +251,7 @@ class AgentImpl {
                 ...opts.persona,
                 llm: opts.persona.llm ?? this.llm,
                 conversationWindow: personaWindowConfig,
+                defaultSummaryModel: this.modelOpt,
             });
             personaReply = async () => {
                 const fakeChatSession = {
@@ -399,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,
@@ -407,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/chat.js

@@ -1,5 +1,6 @@
 import { buildModelAgentResultLogEntry } from './agent-result-log.js';
 import { getVisibleAssistantMessage } from './visible-turn.js';
+import { buildToolEventLogEntry } from './tool-event-log.js';
 export class ChatSessionImpl {
     _turn;
     _done = false;
@@ -51,24 +52,21 @@ export class ChatSessionImpl {
         }
         const response = getVisibleAssistantMessage(turnResult);
         const durationMs = Date.now() - turnStart;
-        this.deps.log.push(buildModelAgentResultLogEntry({
-            timestamp: timestamp(),
-            turnNumber,
-            durationMs,
-            turnResult,
-            assistantMessage: response,
-        }));
+        const turnCompletedAt = timestamp();
         for (const toolEvent of turnResult.toolEvents) {
-            this.deps.log.push({
-                type: 'tool_event',
-                timestamp: timestamp(),
-                tool_event: toolEvent,
-            });
+            this.deps.log.push(buildToolEventLogEntry(toolEvent, turnCompletedAt));
             this.deps.verbose?.toolEvent({
                 action: toolEvent.action,
                 summary: toolEvent.summary,
             });
         }
+        this.deps.log.push(buildModelAgentResultLogEntry({
+            timestamp: turnCompletedAt,
+            turnNumber,
+            durationMs,
+            turnResult,
+            assistantMessage: response,
+        }));
         this.deps.messages.push({ role: 'agent', content: response });
         this.deps.verbose?.turnEnd({
             turn: turnNumber,