@open-cr-agent/runtime-opencode 0.4.0 → 0.6.0

package/dist/effort-setup.d.ts

@@ -0,0 +1,14 @@
+import type { CustomProvider } from "@open-cr-agent/core";
+import type { OpencodeClient } from "@opencode-ai/sdk/v2";
+import { EffortRoutes } from "./effort.js";
+type ConfigApi = Pick<OpencodeClient["config"], "providers">;
+export interface EffortSetup {
+    models: readonly string[];
+    custom?: Readonly<Record<string, CustomProvider>>;
+    probe: ConfigApi;
+    workspace: ConfigApi;
+    file: string;
+}
+export declare function setUpEfforts(setup: EffortSetup): Promise<EffortRoutes>;
+export {};
+//# sourceMappingURL=effort-setup.d.ts.map

package/dist/effort-setup.js

@@ -0,0 +1,43 @@
+import { writeFile } from "node:fs/promises";
+import { EffortRoutes } from "./effort.js";
+const CATALOG_TIMEOUT_MS = 30_000;
+// The variants derive thinking budgets from the models' output limits,
+// which only OpenCode's catalog knows, and the catalog is loaded only once
+// OpenCode runs: the variants are written after it started and before the
+// workspace is first used. Any failure leaves effort unsent, with a warning
+// per agent, and never fails the review.
+export async function setUpEfforts(setup) {
+    const { models, custom = {} } = setup;
+    const everyModel = new Map(models.map((m) => [m, 0]));
+    if (new EffortRoutes(models, custom, everyModel).empty)
+        return new EffortRoutes([]);
+    try {
+        const catalog = await catalogModels(setup.probe);
+        const routes = new EffortRoutes(models, custom, new Map([...catalog].map(([model, entry]) => [model, entry.outputLimit])));
+        if (routes.empty)
+            return routes;
+        await writeFile(setup.file, JSON.stringify({ provider: routes.providerConfig() }), {
+            mode: 0o600,
+        });
+        const loaded = await catalogModels(setup.workspace);
+        routes.keepLoaded(new Map([...loaded].map(([model, entry]) => [model, entry.variants])));
+        return routes;
+    }
+    catch {
+        return new EffortRoutes([]);
+    }
+}
+async function catalogModels(config) {
+    const answer = await config.providers({}, { signal: AbortSignal.timeout(CATALOG_TIMEOUT_MS) });
+    const models = new Map();
+    for (const provider of answer.data?.providers ?? []) {
+        for (const [id, model] of Object.entries(provider.models)) {
+            models.set(`${provider.id}/${id}`, {
+                outputLimit: model.limit?.output ?? 0,
+                variants: new Set(Object.keys(model.variants ?? {})),
+            });
+        }
+    }
+    return models;
+}
+//# sourceMappingURL=effort-setup.js.map

package/dist/effort.d.ts

@@ -0,0 +1,27 @@
+import { type AppliedSettings, type CustomProvider, type Effort, type Sampling } from "@open-cr-agent/core";
+type Options = Record<string, unknown>;
+export declare function effortOptions(model: string, level: Effort, custom?: Readonly<Record<string, CustomProvider>>, outputLimit?: number): Options | undefined;
+export declare class EffortRoutes {
+    private readonly routes;
+    constructor(models: readonly string[], custom?: Readonly<Record<string, CustomProvider>>, known?: ReadonlyMap<string, number>);
+    get empty(): boolean;
+    providerConfig(): Record<string, {
+        models: Record<string, {
+            variants: Options;
+        }>;
+    }>;
+    keepLoaded(loaded: ReadonlyMap<string, ReadonlySet<string>>): void;
+    route(model: string, level: Effort): {
+        variant?: string;
+    } | undefined;
+}
+export declare class AppliedEfforts {
+    private readonly applied;
+    private readonly sampling;
+    constructor(sampling?: Sampling);
+    record(agent: string, effort: Effort, model: string, sent: boolean): boolean;
+    appliedTo(agent: string): AppliedSettings | undefined;
+    private requested;
+}
+export {};
+//# sourceMappingURL=effort.d.ts.map

package/dist/effort.js

@@ -0,0 +1,149 @@
+import { EFFORT_LEVELS, effortCapability, parseModel, thinkingBudget, } from "@open-cr-agent/core";
+const GOOGLE_PROVIDERS = new Set(["google", "google-vertex"]);
+// OpenCode merges a configured variant over a built-in one of the same name
+// (1.18.32 has "high" and "max" for most models), so ocra's carry a prefix.
+function effortVariant(level) {
+    return `ocra-${level}`;
+}
+// The provider options that carry a level to one model through OpenCode, in
+// the option names of the provider's AI SDK package; {} when the level means
+// sending nothing (no thinking for Anthropic), undefined when ocra knows no
+// way to send it. A provider declared in configuration takes a level the
+// way it says (`effort`), for any model the table does not rule out, as on
+// the direct runtime.
+export function effortOptions(model, level, custom = {}, outputLimit) {
+    const { providerID } = parseModel(model);
+    const capability = effortCapability(model);
+    if (capability && !capability.levels.includes(level))
+        return undefined;
+    const declared = custom[providerID];
+    if (declared) {
+        return declared.effort === "openrouter"
+            ? { reasoning: { effort: level } }
+            : { reasoningEffort: level };
+    }
+    if (!capability)
+        return undefined;
+    if (providerID === "openrouter")
+        return { reasoning: { effort: level } };
+    const google = GOOGLE_PROVIDERS.has(providerID);
+    switch (capability.parameter) {
+        case "reasoningEffort":
+            return providerID === "openai" ? { reasoningEffort: level } : undefined;
+        case "thinkingLevel":
+            return google ? { thinkingConfig: { thinkingLevel: level } } : undefined;
+        case "thinkingBudget": {
+            const budget = thinkingBudget(capability, level, outputLimit);
+            if (budget === undefined)
+                return undefined;
+            if (providerID === "anthropic") {
+                return budget === 0 ? {} : { thinking: { type: "enabled", budgetTokens: budget } };
+            }
+            // OpenCode asks Gemini for thoughts, which Gemini refuses with
+            // thinking off.
+            if (google) {
+                return {
+                    thinkingConfig: budget === 0
+                        ? { thinkingBudget: 0, includeThoughts: false }
+                        : { thinkingBudget: budget },
+                };
+            }
+            return undefined;
+        }
+    }
+}
+// What each model can take, as OpenCode variants: one per (model, level)
+// that sends something, so two agents on one model at different levels get
+// different options. Only models OpenCode's catalog (or the configuration)
+// knows get any, since declaring an unknown model would make OpenCode
+// accept it at a price of 0.
+export class EffortRoutes {
+    routes = new Map();
+    constructor(models, custom = {}, 
+    // Output limits by model, from OpenCode's catalog; 0 when it has none.
+    known = new Map()) {
+        for (const model of new Set(models)) {
+            if (!known.has(model))
+                continue;
+            const levels = new Map();
+            for (const level of EFFORT_LEVELS) {
+                const options = effortOptions(model, level, custom, known.get(model));
+                if (options)
+                    levels.set(level, options);
+            }
+            if (levels.size > 0)
+                this.routes.set(model, levels);
+        }
+    }
+    get empty() {
+        return this.routes.size === 0;
+    }
+    // The `provider` section that declares the variants.
+    providerConfig() {
+        const config = {};
+        for (const [model, levels] of this.routes) {
+            const { providerID, modelID } = parseModel(model);
+            const variants = Object.fromEntries([...levels]
+                .filter(([, options]) => Object.keys(options).length > 0)
+                .map(([level, options]) => [effortVariant(level), options]));
+            if (Object.keys(variants).length === 0)
+                continue;
+            config[providerID] ??= { models: {} };
+            config[providerID].models[modelID] = { variants };
+        }
+        return config;
+    }
+    // Keeps the levels whose variant OpenCode loaded, so a level is never
+    // recorded as sent when OpenCode would have ignored its variant.
+    keepLoaded(loaded) {
+        for (const [model, levels] of this.routes) {
+            for (const [level, options] of levels) {
+                const needsVariant = Object.keys(options).length > 0;
+                if (needsVariant && !loaded.get(model)?.has(effortVariant(level)))
+                    levels.delete(level);
+            }
+        }
+    }
+    // Undefined: the level cannot be sent to the model. No variant: the level
+    // is sent by sending nothing.
+    route(model, level) {
+        const options = this.routes.get(model)?.get(level);
+        if (!options)
+            return undefined;
+        return Object.keys(options).length > 0 ? { variant: effortVariant(level) } : {};
+    }
+}
+// What the run applied per agent (ADR-0025), as the direct runtime records
+// it: a call that asks for an effort other than "none" goes without the
+// configured sampling, even when its level could not be sent, so an
+// agent's calls stay alike within a run.
+export class AppliedEfforts {
+    applied = new Map();
+    sampling;
+    constructor(sampling = {}) {
+        this.sampling = sampling;
+    }
+    // Whether the call keeps the configured sampling.
+    record(agent, effort, model, sent) {
+        const keepsSampling = effort === "none";
+        const before = this.applied.get(agent);
+        const notApplied = [
+            ...new Set([...(before?.notApplied ?? []), ...(keepsSampling ? [] : this.requested())]),
+        ];
+        const unsupported = [...new Set([...(before?.unsupported ?? []), ...(sent ? [] : [model])])];
+        this.applied.set(agent, {
+            effort: (before?.effort ?? true) && sent,
+            ...(unsupported.length > 0 ? { unsupported } : {}),
+            ...(notApplied.length > 0 ? { notApplied } : {}),
+        });
+        return keepsSampling;
+    }
+    appliedTo(agent) {
+        const applied = this.applied.get(agent);
+        return applied && structuredClone(applied);
+    }
+    requested() {
+        return ["temperature", "seed"].filter((key) => this.sampling[key] !== undefined);
+    }
+}
+//# sourceMappingURL=effort.js.map

package/dist/opencode-config.d.ts

@@ -0,0 +1,101 @@
+import { type AppliedSampling, type CustomProvider, type Sampling } from "@open-cr-agent/core";
+import type { ToolServer } from "./tool-server.js";
+export declare const MCP_SERVER = "ocra";
+export declare const REVIEW_AGENT = "ocra-reviewer";
+export declare const HELPER_AGENT = "ocra-helper";
+export declare const WITHOUT_SAMPLING = "-effort";
+export declare const HELPER_AGENT_STEPS = 2;
+export declare const OPENCODE_BUILTIN_TOOLS: readonly ["invalid", "question", "bash", "read", "glob", "grep", "edit", "write", "task", "webfetch", "todowrite", "websearch", "skill", "apply_patch"];
+export declare const DISABLED_BUILTINS: {
+    [k: string]: boolean;
+};
+export declare function openCodeSampling(sampling?: Sampling): AppliedSampling;
+export declare function openCodeConfig(tools: Pick<ToolServer, "url" | "headers">, helperTools: Record<string, boolean>, custom?: Readonly<Record<string, CustomProvider>>, sampling?: Sampling): {
+    share: string;
+    autoupdate: boolean;
+    provider?: {
+        [k: string]: {
+            npm: string;
+            name: string;
+            options: {
+                baseURL: string;
+                apiKey?: string;
+            };
+            models: {
+                [k: string]: {
+                    name: string;
+                    temperature?: boolean;
+                    cost: {
+                        input: number;
+                        output: number;
+                        cache_read?: number;
+                    };
+                };
+            };
+        };
+    };
+    mcp: {
+        ocra: {
+            type: string;
+            url: string;
+            headers: Record<string, string>;
+            oauth: boolean;
+            enabled: boolean;
+        };
+    };
+    agent: {
+        [k: string]: {
+            mode: string;
+            prompt: string;
+            steps: number;
+            tools: {
+                [k: string]: boolean;
+            };
+            permission: {
+                edit: string;
+                bash: string;
+                webfetch: string;
+                skill: string;
+            };
+        } | {
+            mode: string;
+            prompt: string;
+            steps: number;
+            tools: Record<string, boolean>;
+            permission: {
+                edit: string;
+                bash: string;
+                webfetch: string;
+                skill: string;
+            };
+        };
+    } | {
+        "ocra-reviewer": {
+            mode: string;
+            prompt: string;
+            steps: number;
+            tools: {
+                [k: string]: boolean;
+            };
+            permission: {
+                edit: string;
+                bash: string;
+                webfetch: string;
+                skill: string;
+            };
+        };
+        "ocra-helper": {
+            mode: string;
+            prompt: string;
+            steps: number;
+            tools: Record<string, boolean>;
+            permission: {
+                edit: string;
+                bash: string;
+                webfetch: string;
+                skill: string;
+            };
+        };
+    };
+};
+//# sourceMappingURL=opencode-config.d.ts.map

package/dist/opencode-config.js

@@ -0,0 +1,137 @@
+import { MAX_AGENT_STEPS, OcraError, } from "@open-cr-agent/core";
+export const MCP_SERVER = "ocra";
+export const REVIEW_AGENT = "ocra-reviewer";
+export const HELPER_AGENT = "ocra-helper";
+// The same agents without the configured temperature, for calls that send
+// an effort (ADR-0025): OpenCode sets sampling per agent.
+export const WITHOUT_SAMPLING = "-effort";
+// Must not be empty: OpenCode falls back to its full coding prompt otherwise.
+const REVIEW_AGENT_PROMPT = "You are a code review agent run by ocra. Follow the review instructions below.";
+const HELPER_AGENT_PROMPT = "You answer exactly as the instructions below ask, with no tools.";
+// The helper answers in one step and has no tools. It still needs two:
+// OpenCode appends an assistant message on an agent's last allowed step, and
+// Gemini rejects a request that ends with a model turn (#66).
+export const HELPER_AGENT_STEPS = 2;
+// Every OpenCode built-in tool of the pinned version; a test fails when an
+// upgrade adds one, so a new write-capable tool can never be enabled silently.
+export const OPENCODE_BUILTIN_TOOLS = [
+    "invalid",
+    "question",
+    "bash",
+    "read",
+    "glob",
+    "grep",
+    "edit",
+    "write",
+    "task",
+    "webfetch",
+    "todowrite",
+    "websearch",
+    "skill",
+    "apply_patch",
+];
+export const DISABLED_BUILTINS = Object.fromEntries(OPENCODE_BUILTIN_TOOLS.map((t) => [t, false]));
+// OpenCode 1.18.32 takes a temperature per agent and sends it when the
+// model's catalog entry says the model accepts one; a model declared in
+// configuration is marked so (providerConfig). It has no seed setting: the
+// request it builds carries temperature, topP, topK and the output limit only.
+export function openCodeSampling(sampling = {}) {
+    return {
+        ...(sampling.temperature === undefined ? {} : { temperature: sampling.temperature }),
+        ...(sampling.seed === undefined ? {} : { notApplied: ["seed"] }),
+    };
+}
+export function openCodeConfig(tools, helperTools, custom = {}, sampling = {}) {
+    const permission = { edit: "deny", bash: "deny", webfetch: "deny", skill: "deny" };
+    const { temperature } = sampling;
+    const agents = {
+        [REVIEW_AGENT]: {
+            mode: "primary",
+            prompt: REVIEW_AGENT_PROMPT,
+            steps: MAX_AGENT_STEPS,
+            tools: DISABLED_BUILTINS,
+            permission,
+        },
+        [HELPER_AGENT]: {
+            mode: "primary",
+            prompt: HELPER_AGENT_PROMPT,
+            steps: HELPER_AGENT_STEPS,
+            tools: helperTools,
+            permission,
+        },
+    };
+    return {
+        share: "disabled",
+        autoupdate: false,
+        ...(Object.keys(custom).length > 0
+            ? { provider: providerConfig(custom, temperature !== undefined) }
+            : {}),
+        mcp: {
+            [MCP_SERVER]: {
+                type: "remote",
+                url: tools.url,
+                headers: tools.headers,
+                oauth: false,
+                enabled: true,
+            },
+        },
+        agent: temperature === undefined
+            ? agents
+            : Object.fromEntries(Object.entries(agents).flatMap(([name, agent]) => [
+                [name, { ...agent, temperature }],
+                [`${name}${WITHOUT_SAMPLING}`, agent],
+            ])),
+    };
+}
+// OpenCode's form of a provider declared in configuration. OpenCode bundles
+// the OpenAI-compatible client, so nothing is installed to reach it
+// (docs/spikes/0002). The key stays in the environment: OpenCode reads
+// {env:NAME} itself, and the configuration, which OpenCode may log, never
+// holds it. Prices are per million tokens, as OpenCode's catalog has them.
+// OpenCode assumes a declared model takes no temperature and drops one;
+// with a temperature configured, the models are marked as taking it.
+function providerConfig(custom, temperature) {
+    for (const [id, provider] of Object.entries(custom))
+        checkProvider(id, provider);
+    return Object.fromEntries(Object.entries(custom).map(([id, provider]) => [
+        id,
+        {
+            npm: "@ai-sdk/openai-compatible",
+            name: id,
+            options: {
+                baseURL: provider.baseUrl,
+                ...(provider.apiKeyEnv ? { apiKey: `{env:${provider.apiKeyEnv}}` } : {}),
+            },
+            models: Object.fromEntries(Object.entries(provider.models).map(([model, price]) => [
+                model,
+                {
+                    name: model,
+                    ...(temperature ? { temperature: true } : {}),
+                    cost: {
+                        input: price.input,
+                        output: price.output,
+                        ...(price.cachedInput === undefined ? {} : { cache_read: price.cachedInput }),
+                    },
+                },
+            ])),
+        },
+    ]));
+}
+// Checked here once, whatever declared the provider: a configuration file,
+// ocra Cloud or another caller of this package.
+function checkProvider(id, provider) {
+    const fields = [
+        ["id", id],
+        ["baseUrl", provider.baseUrl],
+        ...Object.keys(provider.models).map((model) => ["model", model]),
+    ];
+    for (const [field, value] of fields) {
+        if (/[{}]/.test(value)) {
+            throw new OcraError("CONFIG_INVALID", `Provider "${id}": ${field} must not contain { or }`);
+        }
+    }
+    if (provider.apiKeyEnv !== undefined && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(provider.apiKeyEnv)) {
+        throw new OcraError("CONFIG_INVALID", `Provider "${id}": apiKeyEnv must be an environment variable name`);
+    }
+}
+//# sourceMappingURL=opencode-config.js.map

package/dist/runtime.d.ts

@@ -1,120 +1,28 @@
-import { type AgentEvent, type AgentRuntime, type AgentTaskSpec, type AppliedSampling, type CompletionRequest, type CompletionResult, type CustomProvider, type RuntimeOptions, type Sampling } from "@open-cr-agent/core";
-import { type ToolServer } from "./tool-server.js";
-export declare const MCP_SERVER = "ocra";
-export declare const HELPER_AGENT_STEPS = 2;
-export declare const REVIEW_RESUME: {
-    doneTool: "task_done";
-    maxSteps: number;
-    message: string;
-};
-export declare const OPENCODE_BUILTIN_TOOLS: readonly ["invalid", "question", "bash", "read", "glob", "grep", "edit", "write", "task", "webfetch", "todowrite", "websearch", "skill", "apply_patch"];
+import { type AgentEvent, type AgentRuntime, type AgentTaskSpec, type AppliedSampling, type AppliedSettings, type CompletionRequest, type CompletionResult, type RuntimeOptions } from "@open-cr-agent/core";
 export interface OpenCodeRuntimeOptions extends RuntimeOptions {
     binary?: string;
 }
 export declare class OpenCodeRuntime implements AgentRuntime {
-    private readonly options;
     readonly name = "opencode";
     readonly sampling: AppliedSampling;
     private infra;
     private context;
-    private readonly health;
+    private readonly chains;
     private readonly helperTools;
+    private readonly applied;
+    private readonly options;
     constructor(options: OpenCodeRuntimeOptions);
+    appliedTo(agent: string): AppliedSettings | undefined;
     runTask(spec: AgentTaskSpec, signal: AbortSignal): AsyncIterable<AgentEvent>;
     complete(request: CompletionRequest, signal: AbortSignal): Promise<CompletionResult>;
     dispose(): Promise<void>;
+    private attemptTask;
+    private attemptCompletion;
+    private effortCall;
     private prompt;
+    private unprepared;
     private start;
     private launch;
 }
-export declare function openCodeConfig(tools: Pick<ToolServer, "url" | "headers">, helperTools: Record<string, boolean>, custom?: Readonly<Record<string, CustomProvider>>, sampling?: Sampling): {
-    share: string;
-    autoupdate: boolean;
-    provider?: {
-        [k: string]: {
-            npm: string;
-            name: string;
-            options: {
-                baseURL: string;
-                apiKey?: string;
-            };
-            models: {
-                [k: string]: {
-                    name: string;
-                    temperature?: boolean;
-                    cost: {
-                        input: number;
-                        output: number;
-                        cache_read?: number;
-                    };
-                };
-            };
-        };
-    };
-    mcp: {
-        ocra: {
-            type: string;
-            url: string;
-            headers: Record<string, string>;
-            oauth: boolean;
-            enabled: boolean;
-        };
-    };
-    agent: {
-        "ocra-reviewer": {
-            temperature?: never;
-            mode: string;
-            prompt: string;
-            steps: number;
-            tools: {
-                [k: string]: boolean;
-            };
-            permission: {
-                edit: string;
-                bash: string;
-                webfetch: string;
-                skill: string;
-            };
-        } | {
-            temperature: number;
-            mode: string;
-            prompt: string;
-            steps: number;
-            tools: {
-                [k: string]: boolean;
-            };
-            permission: {
-                edit: string;
-                bash: string;
-                webfetch: string;
-                skill: string;
-            };
-        };
-        "ocra-helper": {
-            temperature?: never;
-            mode: string;
-            prompt: string;
-            steps: number;
-            tools: Record<string, boolean>;
-            permission: {
-                edit: string;
-                bash: string;
-                webfetch: string;
-                skill: string;
-            };
-        } | {
-            temperature: number;
-            mode: string;
-            prompt: string;
-            steps: number;
-            tools: Record<string, boolean>;
-            permission: {
-                edit: string;
-                bash: string;
-                webfetch: string;
-                skill: string;
-            };
-        };
-    };
-};
+export declare function providersOf(options: Pick<RuntimeOptions, "models" | "agentModels">): string[];
 //# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.js

@@ -2,58 +2,32 @@ import { rmSync } from "node:fs";
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { OcraError, } from "@open-cr-agent/core";
-import { completeWithFailback, MAX_AGENT_STEPS, ModelHealth, parseModel, RESUME_MESSAGE, REVIEW_TOOLS, reviewTools, withFailback, withoutSecrets, } from "@open-cr-agent/core/internal";
+import { ChainRunner, MAX_AGENT_STEPS, OcraError, parseModel, RESUME_MESSAGE, REVIEW_TOOLS, reviewTools, withoutSecrets, } from "@open-cr-agent/core";
 import { createOpencodeClient } from "@opencode-ai/sdk/v2";
 import { resolveOpencodeBinary } from "./binary.js";
+import { AppliedEfforts } from "./effort.js";
+import { setUpEfforts } from "./effort-setup.js";
+import { DISABLED_BUILTINS, HELPER_AGENT, MCP_SERVER, openCodeConfig, openCodeSampling, REVIEW_AGENT, WITHOUT_SAMPLING, } from "./opencode-config.js";
 import { startOpencodeServer } from "./opencode-server.js";
 import { credentialValues, missingCredentials, serverEnv } from "./server-env.js";
 import { promptSession } from "./session-prompt.js";
 import { startToolServer } from "./tool-server.js";
 import { createUntimedDispatcher, untimedFetch } from "./transport.js";
-export const MCP_SERVER = "ocra";
-const REVIEW_AGENT = "ocra-reviewer";
-const HELPER_AGENT = "ocra-helper";
-// Must not be empty: OpenCode falls back to its full coding prompt otherwise.
-const REVIEW_AGENT_PROMPT = "You are a code review agent run by ocra. Follow the review instructions below.";
-const HELPER_AGENT_PROMPT = "You answer exactly as the instructions below ask, with no tools.";
-// The helper answers in one step and has no tools. It still needs two:
-// OpenCode appends an assistant message on an agent's last allowed step, and
-// Gemini rejects a request that ends with a model turn (#66).
-export const HELPER_AGENT_STEPS = 2;
 // Sent once to a review agent that stopped before finishing (session-prompt.ts).
-export const REVIEW_RESUME = {
+const REVIEW_RESUME = {
     doneTool: REVIEW_TOOLS.taskDone,
     maxSteps: MAX_AGENT_STEPS,
     message: RESUME_MESSAGE,
 };
-// Every OpenCode built-in tool of the pinned version; a test fails when an
-// upgrade adds one, so a new write-capable tool can never be enabled silently.
-export const OPENCODE_BUILTIN_TOOLS = [
-    "invalid",
-    "question",
-    "bash",
-    "read",
-    "glob",
-    "grep",
-    "edit",
-    "write",
-    "task",
-    "webfetch",
-    "todowrite",
-    "websearch",
-    "skill",
-    "apply_patch",
-];
-const DISABLED_BUILTINS = Object.fromEntries(OPENCODE_BUILTIN_TOOLS.map((t) => [t, false]));
 export class OpenCodeRuntime {
-    options;
     name = "opencode";
     sampling;
     infra;
     context;
-    health = new ModelHealth();
+    chains;
     helperTools;
+    applied;
+    options;
     constructor(options) {
         this.options = options;
         const mcpTools = [...reviewTools, ...options.tools].map((t) => [
@@ -62,61 +36,28 @@ export class OpenCodeRuntime {
         ]);
         this.helperTools = { ...DISABLED_BUILTINS, ...Object.fromEntries(mcpTools) };
         this.sampling = openCodeSampling(options.sampling);
+        this.applied = new AppliedEfforts(options.sampling);
+        this.chains = new ChainRunner(options.models, {
+            refuse: (chain, own) => this.unprepared(chain, own),
+            ready: async () => {
+                await this.start();
+            },
+            task: (model, spec, signal, onUsage) => this.attemptTask(model, spec, signal, onUsage),
+            complete: (model, request, signal) => this.attemptCompletion(model, request, signal),
+        });
+    }
+    appliedTo(agent) {
+        return this.applied.appliedTo(agent);
     }
     async *runTask(spec, signal) {
         if (this.context && this.context !== spec.context) {
             throw new OcraError("INTERNAL", "An OpenCodeRuntime instance serves a single review run");
         }
         this.context = spec.context;
-        const chain = this.options.models[spec.modelTier] ?? [];
-        if (chain.length === 0) {
-            yield {
-                type: "error",
-                taskId: spec.taskId,
-                retryable: false,
-                error: noModel(spec.modelTier),
-            };
-            return;
-        }
-        const infra = await this.start();
-        yield* withFailback({
-            taskId: spec.taskId,
-            tier: spec.modelTier,
-            chain,
-            health: this.health,
-            signal,
-            attempt: (model, onUsage) => this.prompt(infra, {
-                title: `ocra ${spec.taskId}`,
-                agent: REVIEW_AGENT,
-                model,
-                system: spec.systemPrompt,
-                user: spec.userPrompt,
-                tools: DISABLED_BUILTINS,
-                toolPrefix: `${MCP_SERVER}_`,
-                resume: REVIEW_RESUME,
-            }, signal, onUsage),
-        });
+        yield* this.chains.runTask(spec, signal);
     }
-    async complete(request, signal) {
-        const chain = this.options.models[request.tier] ?? [];
-        if (chain.length === 0)
-            throw new OcraError("CONFIG_INVALID", noModel(request.tier));
-        const infra = await this.start();
-        return completeWithFailback({
-            tier: request.tier,
-            chain,
-            health: this.health,
-            signal,
-            attempt: (model) => this.prompt(infra, {
-                title: "ocra helper",
-                agent: HELPER_AGENT,
-                model,
-                system: request.system,
-                user: request.user,
-                tools: this.helperTools,
-                toolPrefix: `${MCP_SERVER}_`,
-            }, signal),
-        });
+    complete(request, signal) {
+        return this.chains.complete(request, signal);
     }
     async dispose() {
         const infra = await this.infra?.catch(() => undefined);
@@ -127,6 +68,45 @@ export class OpenCodeRuntime {
         await Promise.allSettled([infra.server.close(), infra.tools.close(), infra.dispatcher.close()]);
         await rm(infra.root, { recursive: true, force: true });
     }
+    async attemptTask(model, spec, signal, onUsage) {
+        const infra = await this.start();
+        return this.prompt(infra, {
+            title: `ocra ${spec.taskId}`,
+            ...this.effortCall(infra, REVIEW_AGENT, spec.reviewer, spec.effort, model),
+            model,
+            system: spec.systemPrompt,
+            user: spec.userPrompt,
+            tools: DISABLED_BUILTINS,
+            toolPrefix: `${MCP_SERVER}_`,
+            resume: REVIEW_RESUME,
+        }, signal, onUsage);
+    }
+    async attemptCompletion(model, request, signal) {
+        const infra = await this.start();
+        return this.prompt(infra, {
+            title: "ocra helper",
+            ...this.effortCall(infra, HELPER_AGENT, request.agent ?? request.tier, request.effort, model),
+            model,
+            system: request.system,
+            user: request.user,
+            tools: this.helperTools,
+            toolPrefix: `${MCP_SERVER}_`,
+        }, signal);
+    }
+    // The OpenCode agent and variant one attempt runs with, recorded for the
+    // agent's provenance.
+    effortCall(infra, base, agent, effort, model) {
+        if (effort === undefined)
+            return { agent: base };
+        const route = infra.efforts.route(model, effort);
+        const keepsSampling = this.applied.record(agent, effort, model, route !== undefined);
+        return {
+            agent: keepsSampling || this.options.sampling?.temperature === undefined
+                ? base
+                : `${base}${WITHOUT_SAMPLING}`,
+            ...(route?.variant ? { variant: route.variant } : {}),
+        };
+    }
     prompt(infra, input, signal, onUsage) {
         return promptSession(infra.client.session, input, `${MCP_SERVER}_${REVIEW_TOOLS.reportFinding}`, signal, onUsage ? { onUsage } : {}).then((outcome) => outcome.error
             ? {
@@ -138,13 +118,25 @@ export class OpenCodeRuntime {
             }
             : outcome);
     }
+    // The server holds the credentials of the providers it started with; an
+    // agent's own chain naming another would fail at OpenCode as "model not
+    // found". The tier chains are always among them.
+    unprepared(chain, own) {
+        if (!own)
+            return undefined;
+        const prepared = new Set(providersOf(this.options));
+        const model = chain.find((m) => !prepared.has(parseModel(m).providerID));
+        return model === undefined
+            ? undefined
+            : new OcraError("CONFIG_INVALID", `"${model}" is not among the models the runtime was started with (RuntimeOptions.models or agentModels)`);
+    }
     start() {
         this.infra ??= this.launch();
         return this.infra;
     }
     async launch() {
         const custom = this.options.providers ?? {};
-        const missing = missingCredentials(this.options.env, providersOf(this.options.models), custom);
+        const missing = missingCredentials(this.options.env, providersOf(this.options), custom);
         if (missing.length > 0)
             throw new OcraError("CONFIG_CREDENTIALS_MISSING", missing.join("; "));
         const root = await mkdtemp(join(tmpdir(), "ocra-opencode-"));
@@ -154,24 +146,26 @@ export class OpenCodeRuntime {
             state: join(root, "state"),
         };
         const workspace = join(root, "workspace");
-        await Promise.all([...Object.values(dirs), workspace].map((d) => mkdir(d, { recursive: true })));
+        const probe = join(root, "probe");
+        await Promise.all([...Object.values(dirs), workspace, probe].map((d) => mkdir(d, { recursive: true })));
         const tools = await startToolServer([...reviewTools, ...this.options.tools], () => this.context);
         let started;
         try {
             const server = await startOpencodeServer({
                 binary: this.options.binary ?? resolveOpencodeBinary(this.options.env),
                 cwd: workspace,
-                env: serverEnv(this.options.env, dirs, providersOf(this.options.models), custom),
+                env: serverEnv(this.options.env, dirs, providersOf(this.options), custom),
                 config: openCodeConfig(tools, this.helperTools, custom, this.options.sampling),
             });
             started = server;
             const dispatcher = createUntimedDispatcher();
-            const client = createOpencodeClient({
+            const clientFor = (directory) => createOpencodeClient({
                 baseUrl: server.url,
-                directory: workspace,
+                directory,
                 headers: { Authorization: server.authorization },
                 fetch: untimedFetch(dispatcher),
             });
+            const client = clientFor(workspace);
             // A second Ctrl-C exits at once, before dispose() can run: stop
             // OpenCode and remove its directory synchronously on the way out.
             const onExit = () => {
@@ -179,8 +173,15 @@ export class OpenCodeRuntime {
                 rmSync(root, { recursive: true, force: true });
             };
             process.on("exit", onExit);
-            const secrets = credentialValues(this.options.env, providersOf(this.options.models), custom);
-            return { root, tools, server, client, dispatcher, onExit, secrets };
+            const efforts = await setUpEfforts({
+                models: chainModels(this.options),
+                custom,
+                probe: clientFor(probe).config,
+                workspace: client.config,
+                file: join(dirs.config, "opencode.json"),
+            });
+            const secrets = credentialValues(this.options.env, providersOf(this.options), custom);
+            return { root, tools, server, client, efforts, dispatcher, onExit, secrets };
         }
         catch (error) {
             await Promise.allSettled([tools.close(), started?.close()]);
@@ -189,91 +190,13 @@ export class OpenCodeRuntime {
         }
     }
 }
-// OpenCode 1.18.32 takes a temperature per agent and sends it when the
-// model's catalog entry says the model accepts one; a model declared in
-// configuration is marked so (providerConfig). It has no seed setting: the
-// request it builds carries temperature, topP, topK and the output limit only.
-function openCodeSampling(sampling = {}) {
-    return {
-        ...(sampling.temperature === undefined ? {} : { temperature: sampling.temperature }),
-        ...(sampling.seed === undefined ? {} : { notApplied: ["seed"] }),
-    };
-}
-export function openCodeConfig(tools, helperTools, custom = {}, sampling = {}) {
-    const permission = { edit: "deny", bash: "deny", webfetch: "deny", skill: "deny" };
-    const { temperature } = sampling;
-    const agentSampling = temperature === undefined ? {} : { temperature };
-    return {
-        share: "disabled",
-        autoupdate: false,
-        ...(Object.keys(custom).length > 0
-            ? { provider: providerConfig(custom, temperature !== undefined) }
-            : {}),
-        mcp: {
-            [MCP_SERVER]: {
-                type: "remote",
-                url: tools.url,
-                headers: tools.headers,
-                oauth: false,
-                enabled: true,
-            },
-        },
-        agent: {
-            [REVIEW_AGENT]: {
-                mode: "primary",
-                prompt: REVIEW_AGENT_PROMPT,
-                steps: MAX_AGENT_STEPS,
-                tools: DISABLED_BUILTINS,
-                permission,
-                ...agentSampling,
-            },
-            [HELPER_AGENT]: {
-                mode: "primary",
-                prompt: HELPER_AGENT_PROMPT,
-                steps: HELPER_AGENT_STEPS,
-                tools: helperTools,
-                permission,
-                ...agentSampling,
-            },
-        },
-    };
-}
-// OpenCode's form of a provider declared in configuration. OpenCode bundles
-// the OpenAI-compatible client, so nothing is installed to reach it
-// (docs/spikes/0002). The key stays in the environment: OpenCode reads
-// {env:NAME} itself, and the configuration, which OpenCode may log, never
-// holds it. Prices are per million tokens, as OpenCode's catalog has them.
-// OpenCode assumes a declared model takes no temperature and drops one;
-// with a temperature configured, the models are marked as taking it.
-function providerConfig(custom, temperature) {
-    return Object.fromEntries(Object.entries(custom).map(([id, provider]) => [
-        id,
-        {
-            npm: "@ai-sdk/openai-compatible",
-            name: id,
-            options: {
-                baseURL: provider.baseUrl,
-                ...(provider.apiKeyEnv ? { apiKey: `{env:${provider.apiKeyEnv}}` } : {}),
-            },
-            models: Object.fromEntries(Object.entries(provider.models).map(([model, price]) => [
-                model,
-                {
-                    name: model,
-                    ...(temperature ? { temperature: true } : {}),
-                    cost: {
-                        input: price.input,
-                        output: price.output,
-                        ...(price.cachedInput === undefined ? {} : { cache_read: price.cachedInput }),
-                    },
-                },
-            ])),
-        },
-    ]));
-}
-function providersOf(models) {
-    return Object.values(models).flatMap((chain) => (chain ?? []).map((m) => parseModel(m).providerID));
+// Every model a call may run on: the tiers' chains and the agents' own
+// (ADR-0025).
+function chainModels(options) {
+    return [...Object.values(options.models), ...Object.values(options.agentModels ?? {})].flatMap((chain) => [...(chain ?? [])]);
 }
-function noModel(tier) {
-    return `No model configured for the "${tier}" tier; set models.${tier} in .ocra/config.json or OCRA_MODEL_${tier.toUpperCase()}`;
+// The providers of those models, so each gets its credentials like a tier's.
+export function providersOf(options) {
+    return chainModels(options).map((m) => parseModel(m).providerID);
 }
 //# sourceMappingURL=runtime.js.map

package/dist/server-env.d.ts

@@ -6,8 +6,6 @@ export interface IsolatedDirs {
 }
 type CustomProviders = Readonly<Record<string, CustomProvider>>;
 export declare function missingCredentials(base: Env, providers: readonly string[], custom?: CustomProviders): string[];
-export declare const EXTRA_ENV_VARIABLE = "OCRA_RUNTIME_ENV";
-export declare function credentialNames(base: Env, providers: readonly string[], custom?: CustomProviders): string[];
 export declare function credentialValues(base: Env, providers: readonly string[], custom?: CustomProviders): string[];
 export declare function serverEnv(base: Env, dirs: IsolatedDirs, providers: readonly string[], custom?: CustomProviders): Record<string, string>;
 export {};

package/dist/server-env.js

@@ -88,7 +88,7 @@ export function missingCredentials(base, providers, custom = {}) {
 }
 const GOOGLE_KEY = "GOOGLE_GENERATIVE_AI_API_KEY";
 const GOOGLE_KEY_ALIASES = ["GEMINI_API_KEY", "GOOGLE_API_KEY"];
-export const EXTRA_ENV_VARIABLE = "OCRA_RUNTIME_ENV";
+const EXTRA_ENV_VARIABLE = "OCRA_RUNTIME_ENV";
 // OpenCode installs its plugin package from npm into every config directory
 // when it starts, and the SDK of a provider it does not bundle when a model
 // first uses it; no flag turns either off. ocra loads no OpenCode plugins and
@@ -121,7 +121,7 @@ const NEVER_BY_PREFIX = [
 // a provider declared in configuration only the one it names, for a known
 // catalog provider its variables, for any other every variable with its
 // prefix that is not a platform token.
-export function credentialNames(base, providers, custom = {}) {
+function credentialNames(base, providers, custom = {}) {
     const names = [];
     for (const provider of new Set(providers)) {
         const declared = custom[provider];

package/dist/session-outcome.d.ts

@@ -1,36 +1,39 @@
-import type { Usage } from "@open-cr-agent/core";
-import { type AttemptOutcome } from "@open-cr-agent/core/internal";
-export interface SessionMessage {
-    info: {
-        role: string;
-        cost?: number;
-        tokens?: {
-            input?: number;
-            output?: number;
-            reasoning?: number;
-            cache?: {
-                read?: number;
-            };
-        };
-        error?: {
-            name?: string;
-            data?: {
-                message?: string;
-                statusCode?: number;
-                isRetryable?: boolean;
-            };
-        };
-    };
-    parts: {
-        type: string;
-        text?: string;
-        tool?: string;
-        state?: {
-            status?: string;
-            input?: unknown;
-        };
-    }[];
-}
+import { type AttemptOutcome, type Usage } from "@open-cr-agent/core";
+import { z } from "zod";
+declare const sessionMessageSchema: z.ZodObject<{
+    info: z.ZodObject<{
+        role: z.ZodString;
+        cost: z.ZodOptional<z.ZodNumber>;
+        tokens: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            reasoning: z.ZodOptional<z.ZodNumber>;
+            cache: z.ZodOptional<z.ZodObject<{
+                read: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        error: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            data: z.ZodOptional<z.ZodObject<{
+                message: z.ZodOptional<z.ZodString>;
+                statusCode: z.ZodOptional<z.ZodNumber>;
+                isRetryable: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    parts: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
+        tool: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodObject<{
+            status: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SessionMessage = z.output<typeof sessionMessageSchema>;
+export declare function parseSessionMessages(data: unknown): SessionMessage[];
 export declare function summarizeSession(messages: readonly SessionMessage[], reportTool: string, toolPrefix?: string): AttemptOutcome;
 export declare function sessionUsage(messages: readonly SessionMessage[]): Usage;
+export {};
 //# sourceMappingURL=session-outcome.d.ts.map

package/dist/session-outcome.js

@@ -1,4 +1,44 @@
-import { parseQuotaError } from "@open-cr-agent/core/internal";
+import { parseQuotaError } from "@open-cr-agent/core";
+import { z } from "zod";
+// The part of OpenCode's session messages ocra reads, validated rather than
+// cast: the SDK's types are not checked at runtime, and a server of another
+// version could answer in another shape. Unknown fields are dropped.
+const sessionMessageSchema = z.object({
+    info: z.object({
+        role: z.string(),
+        cost: z.number().optional(),
+        tokens: z
+            .object({
+            input: z.number().optional(),
+            output: z.number().optional(),
+            reasoning: z.number().optional(),
+            cache: z.object({ read: z.number().optional() }).optional(),
+        })
+            .optional(),
+        error: z
+            .object({
+            name: z.string().optional(),
+            data: z
+                .object({
+                message: z.string().optional(),
+                statusCode: z.number().optional(),
+                isRetryable: z.boolean().optional(),
+            })
+                .optional(),
+        })
+            .optional(),
+    }),
+    parts: z.array(z.object({
+        type: z.string(),
+        text: z.string().optional(),
+        tool: z.string().optional(),
+        state: z.object({ status: z.string().optional(), input: z.unknown().optional() }).optional(),
+    })),
+});
+// Throws when the answer is not a list of messages ocra can read.
+export function parseSessionMessages(data) {
+    return z.array(sessionMessageSchema).parse(data ?? []);
+}
 const AUTH_STATUS = new Set([401, 403]);
 const AUTH_MESSAGE = /api key|unauthori[sz]ed|permission denied|forbidden/i;
 // Tool names come back with the MCP server's prefix (MCP_SERVER in

package/dist/session-prompt.d.ts

@@ -1,10 +1,5 @@
-import { type Usage } from "@open-cr-agent/core";
-import { type AttemptOutcome } from "@open-cr-agent/core/internal";
+import { type AttemptOutcome, type Usage } from "@open-cr-agent/core";
 import type { OpencodeClient } from "@opencode-ai/sdk/v2";
-import { type SessionMessage } from "./session-outcome.js";
-export declare const HARVEST_TIMEOUT_MS = 5000;
-export declare const INACTIVITY_MS: number;
-export declare const ACTIVITY_POLL_MS = 10000;
 export interface ActivityOptions {
     inactivityMs?: number;
     pollMs?: number;
@@ -14,21 +9,19 @@ export interface PromptInput {
     title: string;
     agent: string;
     model: string;
+    variant?: string;
     system: string;
     user: string;
     tools: Record<string, boolean>;
     toolPrefix?: string;
     resume?: ResumeOptions;
 }
-export interface ResumeOptions {
+interface ResumeOptions {
     doneTool: string;
     maxSteps: number;
     message: string;
 }
-export declare function stoppedEarly(outcome: AttemptOutcome, resume: ResumeOptions): boolean;
 type SessionApi = Pick<OpencodeClient["session"], "create" | "prompt" | "messages" | "abort">;
 export declare function promptSession(session: SessionApi, input: PromptInput, reportTool: string, signal: AbortSignal, activity?: ActivityOptions): Promise<AttemptOutcome>;
-export declare function activitySignature(messages: readonly SessionMessage[]): string;
-export declare function emptyOutcome(): AttemptOutcome;
 export {};
 //# sourceMappingURL=session-prompt.d.ts.map

package/dist/session-prompt.js

@@ -1,24 +1,23 @@
-import { OcraError } from "@open-cr-agent/core";
-import { emptyUsage, errorMessage, parseModel, } from "@open-cr-agent/core/internal";
-import { sessionUsage, summarizeSession } from "./session-outcome.js";
+import { emptyUsage, errorMessage, OcraError, parseModel, } from "@open-cr-agent/core";
+import { parseSessionMessages, sessionUsage, summarizeSession, } from "./session-outcome.js";
 // A session that was cut off has still spent tokens and may have reported
 // findings; this bounds the one extra request that collects them.
-export const HARVEST_TIMEOUT_MS = 5_000;
+const HARVEST_TIMEOUT_MS = 5_000;
 // A prompt returns only when the agent is done, so silence on the request is
 // normal; silence in the session is not. A session whose messages have not
 // changed for this long (no new step, no streamed text, no tool progress) is
 // stopped and the task moves to the next model instead of waiting for its
 // full timeout. Generous, so a slow step that is still writing survives.
-export const INACTIVITY_MS = 5 * 60_000;
+const INACTIVITY_MS = 5 * 60_000;
 // Each poll also reports what the session has spent, and a run's spend limit
 // stops running tasks on those reports: this bounds how far past the limit a
 // task can get before it is stopped.
-export const ACTIVITY_POLL_MS = 10_000;
+const ACTIVITY_POLL_MS = 10_000;
 // About one review attempt in twelve on Gemini ended after a step or two
 // with no text, no done tool and steps to spare (2026-09-28), and the task
 // counted as completed with its files unread. Continuing the same session
 // keeps what it read and is cheaper than starting over.
-export function stoppedEarly(outcome, resume) {
+function stoppedEarly(outcome, resume) {
     return (!outcome.toolCalls.includes(resume.doneTool) &&
         outcome.steps < resume.maxSteps &&
         outcome.text.trim() === "");
@@ -38,6 +37,7 @@ export async function promptSession(session, input, reportTool, signal, activity
             sessionID,
             agent: input.agent,
             model: parseModel(input.model),
+            ...(input.variant ? { variant: input.variant } : {}),
             system: input.system,
             tools: input.tools,
             parts: [{ type: "text", text: input.user }],
@@ -53,7 +53,7 @@ export async function promptSession(session, input, reportTool, signal, activity
         let outcome;
         try {
             const messages = await session.messages({ sessionID }, { signal: attempt });
-            outcome = summarizeSession((messages.data ?? []), reportTool, input.toolPrefix);
+            outcome = summarizeSession(parseSessionMessages(messages.data), reportTool, input.toolPrefix);
         }
         catch (error) {
             // The session finished; running it again on the next model would pay
@@ -72,6 +72,7 @@ export async function promptSession(session, input, reportTool, signal, activity
             sessionID,
             agent: input.agent,
             model: parseModel(input.model),
+            ...(input.variant ? { variant: input.variant } : {}),
             system: input.system,
             tools: input.tools,
             parts: [{ type: "text", text: input.resume.message }],
@@ -120,7 +121,7 @@ function watchActivity(session, sessionID, options) {
         polling = true;
         try {
             const messages = await session.messages({ sessionID }, { signal: AbortSignal.timeout(HARVEST_TIMEOUT_MS) });
-            const list = (messages.data ?? []);
+            const list = parseSessionMessages(messages.data);
             if (options.onUsage) {
                 const spent = sessionUsage(list);
                 if (spent.costUsd > reported.costUsd || spent.inputTokens > reported.inputTokens) {
@@ -148,7 +149,7 @@ function watchActivity(session, sessionID, options) {
     return { signal: controller.signal, stop: () => clearInterval(timer) };
 }
 // What changes while an agent works: steps, parts, streamed text, tool states.
-export function activitySignature(messages) {
+function activitySignature(messages) {
     return messages
         .map((m) => m.parts.map((p) => `${p.type}:${p.state?.status ?? ""}:${p.text?.length ?? 0}`).join(","))
         .join("|");
@@ -156,13 +157,13 @@ export function activitySignature(messages) {
 async function harvest(session, sessionID, reportTool, toolPrefix) {
     try {
         const messages = await session.messages({ sessionID }, { signal: AbortSignal.timeout(HARVEST_TIMEOUT_MS) });
-        return summarizeSession((messages.data ?? []), reportTool, toolPrefix);
+        return summarizeSession(parseSessionMessages(messages.data), reportTool, toolPrefix);
     }
     catch {
         return emptyOutcome();
     }
 }
-export function emptyOutcome() {
+function emptyOutcome() {
     return { findings: [], steps: 0, toolCalls: [], text: "", usage: emptyUsage() };
 }
 //# sourceMappingURL=session-prompt.js.map

package/dist/tool-server.js

@@ -3,7 +3,7 @@ import { createServer } from "node:http";
 import { createRequire } from "node:module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { errorMessage } from "@open-cr-agent/core/internal";
+import { errorMessage } from "@open-cr-agent/core";
 // src/ and dist/ both sit one level below the package root.
 const VERSION = createRequire(import.meta.url)("../package.json").version;
 export async function startToolServer(tools, context) {

package/dist/transport.js

@@ -8,6 +8,10 @@ import { Agent, fetch as undiciFetch } from "undici";
 export function createUntimedDispatcher() {
     return new Agent({ headersTimeout: 0, bodyTimeout: 0 });
 }
+// The adapter from undici's fetch to Node's is a deliberate copy of the one in
+// core's proxiedFetch: a runtime builds on core's public API only (ADR-0006),
+// and sharing it there would put undici's Dispatcher type in core's contract
+// and pass a dispatcher from this package's undici to core's copy.
 export function untimedFetch(dispatcher) {
     return async (input, init) => {
         const request = new Request(input, init);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-cr-agent/runtime-opencode",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "OpenCode-based agent runtime for Open-CR-Agent",
   "keywords": [
     "code-review",
@@ -34,7 +34,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.1",
-    "@open-cr-agent/core": "0.4.0",
+    "@open-cr-agent/core": "0.6.0",
     "@opencode-ai/sdk": "1.18.32",
     "opencode-ai": "1.18.32",
     "undici": "^8.11.2",