@open-cr-agent/runtime-opencode 0.1.2 → 0.3.0

package/dist/binary.d.ts

@@ -1,10 +1,11 @@
-import type { Env } from "@open-cr-agent/core";
+import { type Env } from "@open-cr-agent/core";
 export interface Host {
     platform: string;
     arch: string;
     musl: boolean;
     baseline: boolean;
 }
-export declare function resolveOpencodeBinary(env: Env): string;
+export declare function resolveOpencodeBinary(env: Env, opencodePackage?: string): string;
+export declare function isNativeExecutable(path: string): boolean;
 export declare function binaryVariants(host: Host): string[];
 //# sourceMappingURL=binary.d.ts.map

package/dist/binary.js

@@ -1,11 +1,14 @@
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync, readSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
+import { OcraError } from "@open-cr-agent/core";
 const PLATFORMS = { darwin: "darwin", linux: "linux", win32: "windows" };
 // Resolved from opencode-ai's platform packages directly, because newer npm
-// versions block the postinstall script that would otherwise place it.
-export function resolveOpencodeBinary(env) {
+// versions block the postinstall script that would otherwise place it. An
+// install without optional dependencies has no platform package, but where
+// that script ran, it downloaded the binary into opencode-ai's own bin/.
+export function resolveOpencodeBinary(env, opencodePackage = createRequire(import.meta.url).resolve("opencode-ai/package.json")) {
     const override = env.OCRA_OPENCODE_BIN;
     // OpenCode runs in a directory of its own, where a relative path would
     // not resolve; a bare name is still looked up in PATH.
@@ -13,7 +16,7 @@ export function resolveOpencodeBinary(env) {
         return /[\\/]/.test(override) ? resolve(override) : override;
     const platform = PLATFORMS[process.platform] ?? process.platform;
     const executable = platform === "windows" ? "opencode.exe" : "opencode";
-    const fromOpencode = createRequire(createRequire(import.meta.url).resolve("opencode-ai/package.json"));
+    const fromOpencode = createRequire(opencodePackage);
     for (const variant of binaryVariants(currentHost(platform))) {
         try {
             const pkg = fromOpencode.resolve(`opencode-${platform}-${process.arch}${variant}/package.json`);
@@ -23,7 +26,34 @@ export function resolveOpencodeBinary(env) {
         }
         catch { }
     }
-    throw new Error(`No OpenCode binary for ${platform}-${process.arch}; set OCRA_OPENCODE_BIN`);
+    // The script names the binary opencode.exe on every platform.
+    const placed = join(dirname(opencodePackage), "bin", "opencode.exe");
+    if (isNativeExecutable(placed))
+        return placed;
+    throw new OcraError("RUNTIME_START_FAILED", `No OpenCode binary for ${platform}-${process.arch}: install without --omit=optional, or set OCRA_OPENCODE_BIN`);
+}
+// Until the install script replaces it, opencode-ai's bin/opencode.exe is a
+// shell script that only prints an error, so the file must be a real
+// executable: ELF, Mach-O (either byte order, or universal) or Windows PE.
+export function isNativeExecutable(path) {
+    let fd;
+    try {
+        fd = openSync(path, "r");
+        const head = Buffer.alloc(4);
+        if (readSync(fd, head, 0, 4, 0) < 4)
+            return false;
+        const magic = head.readUInt32BE(0);
+        return (magic === 0x7f454c46 ||
+            [0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe, 0xcafebabe].includes(magic) ||
+            head.subarray(0, 2).toString("latin1") === "MZ");
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
 }
 // The builds to try, best first. npm installs every build whose os and cpu
 // match, and the glibc builds declare no libc, so musl Linux has both kinds;

package/dist/index.d.ts

@@ -1,4 +1,2 @@
-export * from "./models.js";
-export * from "./plugin.js";
-export * from "./runtime.js";
+export { opencodeRuntimePlugin } from "./plugin.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,2 @@
-export * from "./models.js";
-export * from "./plugin.js";
-export * from "./runtime.js";
+export { opencodeRuntimePlugin } from "./plugin.js";
 //# sourceMappingURL=index.js.map

package/dist/opencode-server.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:net";
+import { OcraError } from "@open-cr-agent/core";
 const LISTENING = /opencode server listening on (https?:\/\/\S+)/;
 export async function startOpencodeServer(options) {
     const port = await freePort();
@@ -32,7 +33,7 @@ function waitForListening(child, timeoutMs) {
         const fail = (message) => {
             clearTimeout(timer);
             void stop(child);
-            reject(new Error(`${message}${output.trim() ? `\n${output.trim()}` : ""}`));
+            reject(new OcraError("RUNTIME_START_FAILED", `${message}${output.trim() ? `\n${output.trim()}` : ""}`));
         };
         const timer = setTimeout(() => fail(`OpenCode did not start within ${timeoutMs}ms`), timeoutMs);
         // Only the tail matters for a startup error message.

package/dist/runtime.d.ts

@@ -1,10 +1,9 @@
-import { type AgentEvent, type AgentRuntime, type AgentTaskSpec, type CompletionRequest, type CompletionResult, type RuntimeOptions } from "@open-cr-agent/core";
+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 MAX_AGENT_STEPS = 30;
 export declare const HELPER_AGENT_STEPS = 2;
 export declare const REVIEW_RESUME: {
-    doneTool: string;
+    doneTool: "task_done";
     maxSteps: number;
     message: string;
 };
@@ -15,6 +14,7 @@ export interface OpenCodeRuntimeOptions extends RuntimeOptions {
 export declare class OpenCodeRuntime implements AgentRuntime {
     private readonly options;
     readonly name = "opencode";
+    readonly sampling: AppliedSampling;
     private infra;
     private context;
     private readonly health;
@@ -27,9 +27,30 @@ export declare class OpenCodeRuntime implements AgentRuntime {
     private start;
     private launch;
 }
-export declare function openCodeConfig(tools: Pick<ToolServer, "url" | "headers">, helperTools: Record<string, boolean>): {
+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;
@@ -41,6 +62,21 @@ export declare function openCodeConfig(tools: Pick<ToolServer, "url" | "headers"
     };
     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;
@@ -55,6 +91,19 @@ export declare function openCodeConfig(tools: Pick<ToolServer, "url" | "headers"
             };
         };
         "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;

package/dist/runtime.js

@@ -2,15 +2,12 @@ import { rmSync } from "node:fs";
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { addUsage, CompletionError, emptyUsage, REVIEW_TOOLS, } from "@open-cr-agent/core";
+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 { createOpencodeClient } from "@opencode-ai/sdk/v2";
 import { resolveOpencodeBinary } from "./binary.js";
-import { withFailback } from "./failback.js";
-import { ModelHealth, parseModel } from "./models.js";
 import { startOpencodeServer } from "./opencode-server.js";
-import { sleep } from "./quota.js";
-import { reviewTools } from "./review-tools.js";
-import { missingCredentials, serverEnv } from "./server-env.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";
@@ -20,21 +17,15 @@ 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.";
-// Each step resends the whole conversation, so an unbounded loop is the
-// largest cost risk. At 20 steps a quarter of the review tasks on Vertex
-// ended at the cap and one golden bug was never found; at 30 it was found in
-// both runs, for about a third more cost on average (2026-09-28). Most tasks
-// finish in about 15 steps and never reach it.
-export const MAX_AGENT_STEPS = 30;
 // 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 = {
-    doneTool: `${MCP_SERVER}_${REVIEW_TOOLS.taskDone}`,
+    doneTool: REVIEW_TOOLS.taskDone,
     maxSteps: MAX_AGENT_STEPS,
-    message: `You stopped before finishing the review. Continue with the files in <ocra_review_files> you have not reviewed yet, report each confirmed issue with ${REVIEW_TOOLS.reportFinding}, and call ${REVIEW_TOOLS.taskDone} when every file is done.`,
+    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.
@@ -58,6 +49,7 @@ const DISABLED_BUILTINS = Object.fromEntries(OPENCODE_BUILTIN_TOOLS.map((t) => [
 export class OpenCodeRuntime {
     options;
     name = "opencode";
+    sampling;
     infra;
     context;
     health = new ModelHealth();
@@ -69,10 +61,11 @@ export class OpenCodeRuntime {
             false,
         ]);
         this.helperTools = { ...DISABLED_BUILTINS, ...Object.fromEntries(mcpTools) };
+        this.sampling = openCodeSampling(options.sampling);
     }
     async *runTask(spec, signal) {
         if (this.context && this.context !== spec.context) {
-            throw new Error("An OpenCodeRuntime instance serves a single review run");
+            throw new OcraError("INTERNAL", "An OpenCodeRuntime instance serves a single review run");
         }
         this.context = spec.context;
         const chain = this.options.models[spec.modelTier] ?? [];
@@ -99,6 +92,7 @@ export class OpenCodeRuntime {
                 system: spec.systemPrompt,
                 user: spec.userPrompt,
                 tools: DISABLED_BUILTINS,
+                toolPrefix: `${MCP_SERVER}_`,
                 resume: REVIEW_RESUME,
             }, signal, onUsage),
         });
@@ -106,44 +100,23 @@ export class OpenCodeRuntime {
     async complete(request, signal) {
         const chain = this.options.models[request.tier] ?? [];
         if (chain.length === 0)
-            throw new Error(noModel(request.tier));
+            throw new OcraError("CONFIG_INVALID", noModel(request.tier));
         const infra = await this.start();
-        let usage = emptyUsage();
-        let lastError = "";
-        for (const model of this.health.order(chain)) {
-            for (;;) {
-                await sleep(this.health.pausedFor(model), signal);
-                if (signal.aborted)
-                    throw new CompletionError("cancelled", usage);
-                const outcome = await this.prompt(infra, {
-                    title: "ocra helper",
-                    agent: HELPER_AGENT,
-                    model,
-                    system: request.system,
-                    user: request.user,
-                    tools: this.helperTools,
-                }, signal);
-                usage = addUsage(usage, outcome.usage);
-                if (!outcome.error) {
-                    this.health.recordSuccess(model);
-                    return { text: outcome.text, usage };
-                }
-                if (!outcome.error.retryable) {
-                    throw new CompletionError(`${model}: ${outcome.error.message}`, usage);
-                }
-                if (outcome.error.quota && this.health.recordQuota(model, outcome.error.quota) === "wait") {
-                    continue;
-                }
-                if (!outcome.error.quota)
-                    this.health.recordFailure(model);
-                lastError = `${model}: ${outcome.error.message}`;
-                break;
-            }
-        }
-        if (!lastError) {
-            throw new CompletionError(`every ${request.tier} model is out of quota for this run`, usage);
-        }
-        throw new CompletionError(`every ${request.tier} model failed (${lastError})`, usage);
+        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),
+        });
     }
     async dispose() {
         const infra = await this.infra?.catch(() => undefined);
@@ -155,16 +128,25 @@ export class OpenCodeRuntime {
         await rm(infra.root, { recursive: true, force: true });
     }
     prompt(infra, input, signal, onUsage) {
-        return promptSession(infra.client.session, input, `${MCP_SERVER}_${REVIEW_TOOLS.reportFinding}`, signal, onUsage ? { onUsage } : {});
+        return promptSession(infra.client.session, input, `${MCP_SERVER}_${REVIEW_TOOLS.reportFinding}`, signal, onUsage ? { onUsage } : {}).then((outcome) => outcome.error
+            ? {
+                ...outcome,
+                error: {
+                    ...outcome.error,
+                    message: withoutSecrets(outcome.error.message, infra.secrets),
+                },
+            }
+            : outcome);
     }
     start() {
         this.infra ??= this.launch();
         return this.infra;
     }
     async launch() {
-        const missing = missingCredentials(this.options.env, providersOf(this.options.models));
+        const custom = this.options.providers ?? {};
+        const missing = missingCredentials(this.options.env, providersOf(this.options.models), custom);
         if (missing.length > 0)
-            throw new Error(missing.join("; "));
+            throw new OcraError("CONFIG_CREDENTIALS_MISSING", missing.join("; "));
         const root = await mkdtemp(join(tmpdir(), "ocra-opencode-"));
         const dirs = {
             config: join(root, "config"),
@@ -179,8 +161,8 @@ export class OpenCodeRuntime {
             const server = await startOpencodeServer({
                 binary: this.options.binary ?? resolveOpencodeBinary(this.options.env),
                 cwd: workspace,
-                env: serverEnv(this.options.env, dirs, providersOf(this.options.models)),
-                config: openCodeConfig(tools, this.helperTools),
+                env: serverEnv(this.options.env, dirs, providersOf(this.options.models), custom),
+                config: openCodeConfig(tools, this.helperTools, custom, this.options.sampling),
             });
             started = server;
             const dispatcher = createUntimedDispatcher();
@@ -197,7 +179,8 @@ export class OpenCodeRuntime {
                 rmSync(root, { recursive: true, force: true });
             };
             process.on("exit", onExit);
-            return { root, tools, server, client, dispatcher, onExit };
+            const secrets = credentialValues(this.options.env, providersOf(this.options.models), custom);
+            return { root, tools, server, client, dispatcher, onExit, secrets };
         }
         catch (error) {
             await Promise.allSettled([tools.close(), started?.close()]);
@@ -206,11 +189,26 @@ export class OpenCodeRuntime {
         }
     }
 }
-export function openCodeConfig(tools, helperTools) {
+// 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",
@@ -227,6 +225,7 @@ export function openCodeConfig(tools, helperTools) {
                 steps: MAX_AGENT_STEPS,
                 tools: DISABLED_BUILTINS,
                 permission,
+                ...agentSampling,
             },
             [HELPER_AGENT]: {
                 mode: "primary",
@@ -234,10 +233,43 @@ export function openCodeConfig(tools, helperTools) {
                 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));
 }

package/dist/server-env.d.ts

@@ -1,10 +1,14 @@
-import type { Env } from "@open-cr-agent/core";
+import type { CustomProvider, Env } from "@open-cr-agent/core";
 export interface IsolatedDirs {
     config: string;
     data: string;
     state: string;
 }
-export declare function missingCredentials(base: Env, providers: readonly string[]): string[];
+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 serverEnv(base: Env, dirs: IsolatedDirs, providers: readonly string[]): Record<string, string>;
+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 {};
 //# sourceMappingURL=server-env.d.ts.map

package/dist/server-env.js

@@ -73,8 +73,13 @@ const REQUIRED_KEYS = {
     xai: ["XAI_API_KEY"],
     azure: ["AZURE_API_KEY"],
 };
-export function missingCredentials(base, providers) {
+export function missingCredentials(base, providers, custom = {}) {
     return [...new Set(providers)].flatMap((provider) => {
+        const declared = custom[provider];
+        if (declared) {
+            const name = declared.apiKeyEnv;
+            return name && !base[name] ? [`No API key for provider "${provider}": set ${name}`] : [];
+        }
         const names = REQUIRED_KEYS[provider];
         if (!names || names.some((name) => base[name]))
             return [];
@@ -84,24 +89,77 @@ export function missingCredentials(base, providers) {
 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";
-// A model chain naming a provider such as "github" or "aws" must not carry
-// the CI's or the cloud's credentials across by prefix; name them in
+// 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
+// supports only bundled providers, so both installs get the discard port on
+// this machine as their registry, and no retries: they fail at once, no code
+// is fetched at review time and no .npmrc token is sent (docs/spikes/0002).
+const NPM_SETTINGS = {
+    npm_config_registry: "http://127.0.0.1:9/",
+    NPM_CONFIG_REGISTRY: "http://127.0.0.1:9/",
+    npm_config_fetch_retries: "0",
+};
+// A model chain naming a provider such as "github", "gitlab" or "aws" must
+// not carry the CI's or the cloud's credentials across by prefix (GitLab CI
+// puts CI_JOB_TOKEN and CI_REGISTRY_PASSWORD in every job); name them in
 // OCRA_RUNTIME_ENV when they are really meant for a provider.
 const NEVER_BY_PREFIX = [
     "GITHUB_",
     "GH_",
     "ACTIONS_",
     "RUNNER_",
+    "GITLAB_",
+    "CI_",
     "AWS_",
     "AZURE_",
     "NPM_",
     "SSH_",
     "OCRA_",
 ];
+// The variables that carry the credentials of the configured providers: for
+// 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 = {}) {
+    const names = [];
+    for (const provider of new Set(providers)) {
+        const declared = custom[provider];
+        if (declared) {
+            if (declared.apiKeyEnv)
+                names.push(declared.apiKeyEnv);
+            continue;
+        }
+        const known = PROVIDER_VARIABLES[provider];
+        if (known) {
+            names.push(...known);
+        }
+        else {
+            const prefix = `${provider.toUpperCase().replaceAll("-", "_")}_`;
+            for (const name of Object.keys(base)) {
+                if (name.startsWith(prefix) && !NEVER_BY_PREFIX.some((p) => name.startsWith(p))) {
+                    names.push(name);
+                }
+            }
+        }
+    }
+    return names;
+}
+// The credential values themselves, to redact from what a provider says.
+// Values shorter than a key could be ordinary words and are left alone.
+export function credentialValues(base, providers, custom = {}) {
+    const names = credentialNames(base, providers, custom);
+    if (providers.includes("google") && !custom.google)
+        names.push(...GOOGLE_KEY_ALIASES);
+    return names
+        .map((name) => base[name])
+        .filter((value) => value !== undefined && value.length >= 8);
+}
 // The child sees only what it needs: system basics, the credentials of the
-// providers in the configured model chains, and names listed in
+// providers in the configured model chains (for a provider declared in
+// configuration, only the variable it names), and names listed in
 // OCRA_RUNTIME_ENV. Other secrets in the user's shell never reach it.
-export function serverEnv(base, dirs, providers) {
+export function serverEnv(base, dirs, providers, custom = {}) {
     const env = {};
     const copy = (name) => {
         const value = base[name];
@@ -113,32 +171,20 @@ export function serverEnv(base, dirs, providers) {
     for (const name of Object.keys(base))
         if (name.startsWith("LC_"))
             copy(name);
-    for (const provider of new Set(providers)) {
-        const known = PROVIDER_VARIABLES[provider];
-        if (known) {
-            for (const name of known)
-                copy(name);
-        }
-        else {
-            const prefix = `${provider.toUpperCase().replaceAll("-", "_")}_`;
-            for (const name of Object.keys(base)) {
-                if (name.startsWith(prefix) && !NEVER_BY_PREFIX.some((p) => name.startsWith(p))) {
-                    copy(name);
-                }
-            }
-        }
-    }
+    for (const name of credentialNames(base, providers, custom))
+        copy(name);
     for (const name of (base[EXTRA_ENV_VARIABLE] ?? "").split(",")) {
         if (name.trim() !== "")
             copy(name.trim());
     }
-    if (providers.includes("google") && !env[GOOGLE_KEY]) {
+    if (providers.includes("google") && !custom.google && !env[GOOGLE_KEY]) {
         const alias = GOOGLE_KEY_ALIASES.map((name) => base[name]).find((value) => value);
         if (alias)
             env[GOOGLE_KEY] = alias;
     }
     for (const flag of ISOLATION_FLAGS)
         env[flag] = "1";
+    Object.assign(env, NPM_SETTINGS);
     env.OPENCODE_CONFIG_DIR = dirs.config;
     env.XDG_CONFIG_HOME = dirs.config;
     env.XDG_DATA_HOME = dirs.data;

package/dist/session-outcome.d.ts

@@ -1,5 +1,5 @@
 import type { Usage } from "@open-cr-agent/core";
-import { type QuotaError } from "./quota.js";
+import { type AttemptOutcome } from "@open-cr-agent/core/internal";
 export interface SessionMessage {
     info: {
         role: string;
@@ -31,19 +31,6 @@ export interface SessionMessage {
         };
     }[];
 }
-export interface SessionOutcome {
-    findings: unknown[];
-    steps: number;
-    toolCalls: string[];
-    text: string;
-    resumed?: true;
-    usage: Usage;
-    error?: {
-        message: string;
-        retryable: boolean;
-        quota?: QuotaError;
-    };
-}
-export declare function summarizeSession(messages: readonly SessionMessage[], reportTool: string): SessionOutcome;
+export declare function summarizeSession(messages: readonly SessionMessage[], reportTool: string, toolPrefix?: string): AttemptOutcome;
 export declare function sessionUsage(messages: readonly SessionMessage[]): Usage;
 //# sourceMappingURL=session-outcome.d.ts.map

package/dist/session-outcome.js

@@ -1,7 +1,9 @@
-import { parseQuotaError } from "./quota.js";
+import { parseQuotaError } from "@open-cr-agent/core/internal";
 const AUTH_STATUS = new Set([401, 403]);
 const AUTH_MESSAGE = /api key|unauthori[sz]ed|permission denied|forbidden/i;
-export function summarizeSession(messages, reportTool) {
+// Tool names come back with the MCP server's prefix (MCP_SERVER in
+// runtime.ts), which the shared outcome does without.
+export function summarizeSession(messages, reportTool, toolPrefix = "") {
     const assistant = messages.filter((m) => m.info.role === "assistant");
     const tools = assistant.flatMap((m) => m.parts.filter((p) => p.type === "tool"));
     const outcome = {
@@ -9,7 +11,7 @@ export function summarizeSession(messages, reportTool) {
             .filter((p) => p.tool === reportTool && p.state?.status === "completed")
             .map((p) => p.state?.input),
         steps: assistant.reduce((n, m) => n + m.parts.filter((p) => p.type === "step-start").length, 0),
-        toolCalls: tools.map((p) => p.tool ?? "unknown"),
+        toolCalls: tools.map((p) => (p.tool ?? "unknown").replace(toolPrefix, "")),
         text: assistant
             .flatMap((m) => m.parts.filter((p) => p.type === "text").map((p) => p.text ?? ""))
             .join("\n")

package/dist/session-prompt.d.ts

@@ -1,6 +1,7 @@
 import { type Usage } from "@open-cr-agent/core";
+import { type AttemptOutcome } from "@open-cr-agent/core/internal";
 import type { OpencodeClient } from "@opencode-ai/sdk/v2";
-import { type SessionMessage, type SessionOutcome } from "./session-outcome.js";
+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;
@@ -16,6 +17,7 @@ export interface PromptInput {
     system: string;
     user: string;
     tools: Record<string, boolean>;
+    toolPrefix?: string;
     resume?: ResumeOptions;
 }
 export interface ResumeOptions {
@@ -23,10 +25,10 @@ export interface ResumeOptions {
     maxSteps: number;
     message: string;
 }
-export declare function stoppedEarly(outcome: SessionOutcome, resume: ResumeOptions): boolean;
+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<SessionOutcome>;
+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(): SessionOutcome;
+export declare function emptyOutcome(): AttemptOutcome;
 export {};
 //# sourceMappingURL=session-prompt.d.ts.map

package/dist/session-prompt.js

@@ -1,6 +1,6 @@
-import { emptyUsage, errorMessage } from "@open-cr-agent/core";
-import { parseModel } from "./models.js";
-import { sessionUsage, summarizeSession, } from "./session-outcome.js";
+import { OcraError } from "@open-cr-agent/core";
+import { emptyUsage, errorMessage, parseModel, } from "@open-cr-agent/core/internal";
+import { 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;
@@ -26,7 +26,7 @@ export function stoppedEarly(outcome, resume) {
 export async function promptSession(session, input, reportTool, signal, activity = {}) {
     const created = await session.create({ title: input.title }, { signal });
     if (!created.data) {
-        throw new Error(`OpenCode could not create a session: ${JSON.stringify(created.error)}`);
+        throw new OcraError("RUNTIME_FAILED", `OpenCode could not create a session: ${JSON.stringify(created.error)}`);
     }
     const sessionID = created.data.id;
     const stop = () => void session.abort({ sessionID }).catch(() => { });
@@ -46,20 +46,20 @@ export async function promptSession(session, input, reportTool, signal, activity
         // spent tokens and reported findings: keep them.
         if (response.error) {
             return {
-                ...(await harvest(session, sessionID, reportTool)),
+                ...(await harvest(session, sessionID, reportTool, input.toolPrefix)),
                 error: { message: JSON.stringify(response.error), retryable: false },
             };
         }
         let outcome;
         try {
             const messages = await session.messages({ sessionID }, { signal: attempt });
-            outcome = summarizeSession((messages.data ?? []), reportTool);
+            outcome = summarizeSession((messages.data ?? []), reportTool, input.toolPrefix);
         }
         catch (error) {
             // The session finished; running it again on the next model would pay
             // twice. Keep what one more read gets, and do not retry.
             return {
-                ...(await harvest(session, sessionID, reportTool)),
+                ...(await harvest(session, sessionID, reportTool, input.toolPrefix)),
                 error: {
                     message: `could not read the finished session: ${errorMessage(error)}`,
                     retryable: false,
@@ -78,7 +78,7 @@ export async function promptSession(session, input, reportTool, signal, activity
         }, { signal: attempt });
         // Both turns are in the session: their findings and their spend.
         const resumed = {
-            ...(await harvest(session, sessionID, reportTool)),
+            ...(await harvest(session, sessionID, reportTool, input.toolPrefix)),
             resumed: true,
         };
         if (again.error)
@@ -89,7 +89,7 @@ export async function promptSession(session, input, reportTool, signal, activity
         // Aborted or cut off by the transport: OpenCode may still be running the
         // session, spending tokens, so stop it and keep what it already did.
         stop();
-        const partial = await harvest(session, sessionID, reportTool);
+        const partial = await harvest(session, sessionID, reportTool, input.toolPrefix);
         const seconds = Math.round((activity.inactivityMs ?? INACTIVITY_MS) / 1000);
         return {
             ...partial,
@@ -153,10 +153,10 @@ export function activitySignature(messages) {
         .map((m) => m.parts.map((p) => `${p.type}:${p.state?.status ?? ""}:${p.text?.length ?? 0}`).join(","))
         .join("|");
 }
-async function harvest(session, sessionID, reportTool) {
+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);
+        return summarizeSession((messages.data ?? []), reportTool, toolPrefix);
     }
     catch {
         return emptyOutcome();

package/dist/tool-server.d.ts

@@ -1,4 +1,4 @@
-import { type ReviewContext, type ToolDefinition } from "@open-cr-agent/core";
+import type { ReviewContext, ToolDefinition } from "@open-cr-agent/core";
 export interface ToolServer {
     url: string;
     headers: Record<string, string>;

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";
+import { errorMessage } from "@open-cr-agent/core/internal";
 // 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-cr-agent/runtime-opencode",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "OpenCode-based agent runtime for Open-CR-Agent",
   "keywords": [
     "code-review",
@@ -19,11 +19,14 @@
     "node": ">=22.19"
   },
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
+      "@open-cr-agent/source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -31,7 +34,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.1",
-    "@open-cr-agent/core": "0.1.2",
+    "@open-cr-agent/core": "0.3.0",
     "@opencode-ai/sdk": "1.18.32",
     "opencode-ai": "1.18.32",
     "undici": "^8.11.2",

package/dist/failback.d.ts

@@ -1,23 +0,0 @@
-import { type AgentEvent, type ModelTier, type Usage } from "@open-cr-agent/core";
-import type { ModelHealth } from "./models.js";
-import type { SessionOutcome } from "./session-outcome.js";
-export interface FailbackOptions {
-    taskId: string;
-    tier: ModelTier;
-    chain: readonly string[];
-    health: ModelHealth;
-    signal: AbortSignal;
-    attempt(model: string, onUsage: (spent: Usage) => void): Promise<SessionOutcome>;
-}
-export declare function withFailback(options: FailbackOptions): AsyncGenerator<AgentEvent>;
-export declare class LiveUsage {
-    private seen;
-    private given;
-    private wake;
-    observe(spent: Usage): void;
-    changed(): Promise<void>;
-    take(): Usage;
-    rest(total: Usage): Usage;
-}
-export declare function toolSummary(toolCalls: readonly string[]): string;
-//# sourceMappingURL=failback.d.ts.map

package/dist/failback.js

@@ -1,139 +0,0 @@
-import { emptyUsage, REVIEW_TOOLS, } from "@open-cr-agent/core";
-import { sleep } from "./quota.js";
-// Findings from a failed attempt are still emitted: the pipeline deduplicates
-// by fingerprint, so a retry on the next model cannot double-report them.
-export async function* withFailback(options) {
-    const { taskId, health, signal } = options;
-    let lastError = "";
-    for (const model of health.order(options.chain)) {
-        for (;;) {
-            if (signal.aborted)
-                return;
-            const pause = health.pausedFor(model);
-            if (pause > 0) {
-                yield {
-                    type: "progress",
-                    taskId,
-                    message: `${model} is rate limited; waiting ${Math.ceil(pause / 1000)}s`,
-                };
-                await sleep(pause, signal);
-                if (signal.aborted)
-                    return;
-            }
-            yield { type: "progress", taskId, message: `reviewing with ${model}` };
-            // Spend is reported while the attempt runs, so a run's spend limit
-            // can stop it; the finished attempt's total settles the rest.
-            const live = new LiveUsage();
-            const running = options.attempt(model, (spent) => live.observe(spent));
-            const finished = running.then(() => false, () => false);
-            while (await Promise.race([finished, live.changed().then(() => true)])) {
-                yield { type: "usage", taskId, ...live.take() };
-            }
-            const outcome = await running;
-            yield { type: "usage", taskId, ...live.rest(outcome.usage) };
-            yield { type: "progress", taskId, message: attemptSummary(model, outcome) };
-            for (const finding of outcome.findings)
-                yield { type: "finding", taskId, finding };
-            if (!outcome.error) {
-                health.recordSuccess(model);
-                yield { type: "done", taskId };
-                return;
-            }
-            if (!outcome.error.retryable) {
-                yield {
-                    type: "error",
-                    taskId,
-                    error: `${model}: ${outcome.error.message}`,
-                    retryable: false,
-                };
-                return;
-            }
-            if (outcome.error.quota && health.recordQuota(model, outcome.error.quota) === "wait") {
-                continue;
-            }
-            if (!outcome.error.quota)
-                health.recordFailure(model);
-            lastError = `${model}: ${outcome.error.message}`;
-            yield { type: "progress", taskId, message: `${lastError}; trying the next model` };
-            break;
-        }
-    }
-    yield {
-        type: "error",
-        taskId,
-        error: lastError
-            ? `every ${options.tier} model failed (${lastError})`
-            : `every ${options.tier} model is out of quota for this run`,
-        retryable: true,
-    };
-}
-// Hands out what an attempt has spent in increments, each what grew since the
-// last one; `rest` settles the finished attempt's total, so the increments
-// add up to it and nothing is counted twice.
-export class LiveUsage {
-    seen = emptyUsage();
-    given = emptyUsage();
-    wake;
-    observe(spent) {
-        this.seen = larger(this.seen, spent);
-        if (ahead(this.seen, this.given)) {
-            this.wake?.();
-            this.wake = undefined;
-        }
-    }
-    // Resolves once more has been seen than handed out.
-    changed() {
-        if (ahead(this.seen, this.given))
-            return Promise.resolve();
-        return new Promise((resolve) => {
-            this.wake = resolve;
-        });
-    }
-    take() {
-        const increment = beyond(this.seen, this.given);
-        this.given = this.seen;
-        return increment;
-    }
-    rest(total) {
-        const settled = larger(total, this.given);
-        const increment = beyond(settled, this.given);
-        this.given = settled;
-        return increment;
-    }
-}
-const FIELDS = [
-    "inputTokens",
-    "outputTokens",
-    "reasoningTokens",
-    "cachedTokens",
-    "costUsd",
-];
-function larger(a, b) {
-    return Object.fromEntries(FIELDS.map((f) => [f, Math.max(a[f], b[f])]));
-}
-function beyond(a, b) {
-    return Object.fromEntries(FIELDS.map((f) => [f, Math.max(0, a[f] - b[f])]));
-}
-function ahead(a, b) {
-    return FIELDS.some((f) => a[f] > b[f]);
-}
-// Which tools an attempt spent its steps on, and whether it finished: a
-// review that never called task_done was cut off, usually by the step cap.
-function attemptSummary(model, outcome) {
-    const { inputTokens, outputTokens, reasoningTokens, costUsd } = outcome.usage;
-    const resumed = outcome.resumed ? ", resumed after stopping early" : "";
-    return `${model}: ${outcome.steps} step(s), ${toolSummary(outcome.toolCalls)}${resumed}, ${inputTokens} in / ${outputTokens} out / ${reasoningTokens} reasoning tokens, $${costUsd.toFixed(4)}`;
-}
-export function toolSummary(toolCalls) {
-    if (toolCalls.length === 0)
-        return "no tool calls";
-    // MCP tools carry the server's name as a prefix (MCP_SERVER in runtime.ts).
-    const names = toolCalls.map((t) => t.replace(/^ocra_/, ""));
-    const counts = new Map();
-    for (const name of names)
-        counts.set(name, (counts.get(name) ?? 0) + 1);
-    const byUse = [...counts].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
-    const finished = names.includes(REVIEW_TOOLS.taskDone) ? "" : "; no task_done";
-    return `${toolCalls.length} tool call(s) (${byUse.map(([n, c]) => `${n} ${c}`).join(", ")}${finished})`;
-}
-//# sourceMappingURL=failback.js.map

package/dist/models.d.ts

@@ -1,30 +0,0 @@
-import { type QuotaError } from "./quota.js";
-export interface ModelRef {
-    providerID: string;
-    modelID: string;
-}
-export declare function parseModel(model: string): ModelRef;
-export interface CircuitOptions {
-    threshold?: number;
-    cooldownMs?: number;
-    maxCooldownMs?: number;
-    now?: () => number;
-}
-export declare class ModelHealth {
-    private readonly circuits;
-    private readonly quotas;
-    private readonly outOfQuota;
-    private readonly threshold;
-    private readonly cooldownMs;
-    private readonly maxCooldownMs;
-    private readonly now;
-    constructor(options?: CircuitOptions);
-    order(chain: readonly string[]): string[];
-    state(model: string): "closed" | "open" | "half-open";
-    recordFailure(model: string): void;
-    recordSuccess(model: string): void;
-    pausedFor(model: string): number;
-    isOutOfQuota(model: string): boolean;
-    recordQuota(model: string, quota: QuotaError): "wait" | "out_of_quota";
-}
-//# sourceMappingURL=models.d.ts.map

package/dist/models.js

@@ -1,88 +0,0 @@
-import { MAX_QUOTA_WAIT_MS, QUOTA_RETRIES } from "./quota.js";
-export function parseModel(model) {
-    const slash = model.indexOf("/");
-    if (slash <= 0 || slash === model.length - 1) {
-        throw new Error(`Model "${model}" must be written as provider/model, for example google/gemini-flash-lite-latest`);
-    }
-    return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
-}
-// A circuit breaker per model: after `threshold` consecutive failures the
-// model is skipped (open) for a cooldown, then one attempt is let through
-// (half-open). Success closes the circuit; failure reopens it for twice as
-// long, up to a limit. Tasks go straight to the fallback instead of paying
-// for a model that is down.
-export class ModelHealth {
-    circuits = new Map();
-    quotas = new Map();
-    outOfQuota = new Set();
-    threshold;
-    cooldownMs;
-    maxCooldownMs;
-    now;
-    constructor(options = {}) {
-        this.threshold = options.threshold ?? 2;
-        this.cooldownMs = options.cooldownMs ?? 60_000;
-        this.maxCooldownMs = options.maxCooldownMs ?? 10 * 60_000;
-        this.now = options.now ?? Date.now;
-    }
-    // Models whose circuit is closed or half-open, in chain order. When every
-    // circuit is open, all models in the order they reopen: a review should
-    // still try rather than fail without a request.
-    // Models out of quota are left out entirely: another request would only be
-    // refused again.
-    order(chain) {
-        const now = this.now();
-        const usable = chain.filter((m) => !this.outOfQuota.has(m));
-        const available = usable.filter((m) => (this.circuits.get(m)?.openUntil ?? 0) <= now);
-        if (available.length > 0)
-            return available;
-        return [...usable].sort((a, b) => (this.circuits.get(a)?.openUntil ?? 0) - (this.circuits.get(b)?.openUntil ?? 0));
-    }
-    state(model) {
-        const circuit = this.circuits.get(model);
-        if (circuit?.openUntil === undefined)
-            return "closed";
-        return circuit.openUntil > this.now() ? "open" : "half-open";
-    }
-    recordFailure(model) {
-        const circuit = this.circuits.get(model) ?? { failures: 0, cooldownMs: this.cooldownMs };
-        const probing = this.state(model) === "half-open";
-        circuit.failures += 1;
-        if (probing || circuit.failures >= this.threshold) {
-            circuit.openUntil = this.now() + circuit.cooldownMs;
-            circuit.cooldownMs = Math.min(circuit.cooldownMs * 2, this.maxCooldownMs);
-            circuit.failures = 0;
-        }
-        this.circuits.set(model, circuit);
-    }
-    recordSuccess(model) {
-        this.circuits.delete(model);
-        this.quotas.delete(model);
-    }
-    // How long every task should hold off this model (a shared rate-limit pause).
-    pausedFor(model) {
-        return Math.max(0, (this.quotas.get(model)?.pausedUntil ?? 0) - this.now());
-    }
-    isOutOfQuota(model) {
-        return this.outOfQuota.has(model);
-    }
-    // A rate limit with a short, stated wait pauses the model for every task;
-    // a daily limit, no stated wait, a long one, or too many waits in a row
-    // mean the model is out of quota for the rest of the run.
-    recordQuota(model, quota) {
-        const state = this.quotas.get(model) ?? { waits: 0, pausedUntil: 0 };
-        const wait = quota.retryAfterMs;
-        if (quota.daily ||
-            wait === undefined ||
-            wait > MAX_QUOTA_WAIT_MS ||
-            state.waits >= QUOTA_RETRIES) {
-            this.outOfQuota.add(model);
-            return "out_of_quota";
-        }
-        state.waits += 1;
-        state.pausedUntil = Math.max(state.pausedUntil, this.now() + wait);
-        this.quotas.set(model, state);
-        return "wait";
-    }
-}
-//# sourceMappingURL=models.js.map

package/dist/quota.d.ts

@@ -1,9 +0,0 @@
-export interface QuotaError {
-    retryAfterMs?: number;
-    daily: boolean;
-}
-export declare const MAX_QUOTA_WAIT_MS = 90000;
-export declare const QUOTA_RETRIES = 3;
-export declare function parseQuotaError(message: string, statusCode?: number): QuotaError | undefined;
-export declare function sleep(ms: number, signal: AbortSignal): Promise<void>;
-//# sourceMappingURL=quota.d.ts.map

package/dist/quota.js

@@ -1,38 +0,0 @@
-// Longest wait for a rate limit inside a run; per-minute limits ask for less.
-export const MAX_QUOTA_WAIT_MS = 90_000;
-// Waits per model before it counts as out of quota for the rest of the run.
-export const QUOTA_RETRIES = 3;
-const QUOTA_MESSAGE = /exceeded your current quota|quota exceeded|resource[_ ]exhausted|rate limit/i;
-const RETRY_IN = /retry in ([\d.]+)\s*(ms|s)\b/i;
-const RETRY_DELAY = /"retryDelay"\s*:\s*"([\d.]+)s"/i;
-const DAILY = /per ?day|daily/i;
-export function parseQuotaError(message, statusCode) {
-    if (statusCode !== 429 && !QUOTA_MESSAGE.test(message))
-        return undefined;
-    const quota = { daily: DAILY.test(message) };
-    const retryIn = RETRY_IN.exec(message);
-    const delay = RETRY_DELAY.exec(message);
-    if (retryIn) {
-        const value = Number(retryIn[1]);
-        quota.retryAfterMs = Math.ceil(retryIn[2]?.toLowerCase() === "ms" ? value : value * 1000);
-    }
-    else if (delay) {
-        quota.retryAfterMs = Math.ceil(Number(delay[1]) * 1000);
-    }
-    return quota;
-}
-// Resolves after `ms`, or at once when the signal aborts.
-export function sleep(ms, signal) {
-    if (signal.aborted || ms <= 0)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        const done = () => {
-            clearTimeout(timer);
-            signal.removeEventListener("abort", done);
-            resolve();
-        };
-        const timer = setTimeout(done, ms);
-        signal.addEventListener("abort", done, { once: true });
-    });
-}
-//# sourceMappingURL=quota.js.map

package/dist/review-tools.d.ts

@@ -1,21 +0,0 @@
-import { type ToolDefinition } from "@open-cr-agent/core";
-import { z } from "zod";
-export declare const MAX_READ_LINES = 400;
-export declare const MAX_SEARCH_RESULTS = 50;
-export declare const MAX_LINE_CHARS = 2000;
-export declare const MAX_RESULT_CHARS = 50000;
-export declare const reportFindingInput: z.ZodObject<{
-    file: z.ZodString;
-    existingCode: z.ZodString;
-    severity: z.ZodEnum<{
-        critical: "critical";
-        suggestion: "suggestion";
-        warning: "warning";
-    }>;
-    title: z.ZodString;
-    body: z.ZodString;
-    suggestion: z.ZodOptional<z.ZodString>;
-    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const reviewTools: readonly ToolDefinition[];
-//# sourceMappingURL=review-tools.d.ts.map

package/dist/review-tools.js

@@ -1,111 +0,0 @@
-import { promptData, REVIEW_TOOLS, severitySchema } from "@open-cr-agent/core";
-import { z } from "zod";
-export const MAX_READ_LINES = 400;
-export const MAX_SEARCH_RESULTS = 50;
-// Lines and results are also capped in characters: one line of a minified
-// bundle or a JSON fixture can be megabytes, and every step resends it.
-export const MAX_LINE_CHARS = 2_000;
-export const MAX_RESULT_CHARS = 50_000;
-function clip(line, max = MAX_LINE_CHARS) {
-    return line.length > max ? `${line.slice(0, max)}…[${line.length - max} more characters]` : line;
-}
-// The whole lines that fit in the result cap.
-function fitting(lines) {
-    const kept = [];
-    let size = 0;
-    for (const line of lines) {
-        size += line.length + 1;
-        if (size > MAX_RESULT_CHARS)
-            break;
-        kept.push(line);
-    }
-    return kept;
-}
-export const reportFindingInput = z.object({
-    file: z.string().min(1).describe("Path of a file in <ocra_review_files>"),
-    existingCode: z
-        .string()
-        .min(1)
-        .describe("1-5 lines copied verbatim from the new version of the file"),
-    severity: severitySchema,
-    title: z.string().min(1),
-    body: z.string().min(1),
-    suggestion: z.string().optional(),
-    evidence: z.array(z.string()).optional(),
-});
-// Tool results carry repository text back to the model, so they are data
-// like every prompt section: they cannot form one of ocra's tags.
-const readFile = {
-    name: REVIEW_TOOLS.readFile,
-    description: `Read a file at the revision under review, with line numbers. Returns at most ${MAX_READ_LINES} lines; use startLine to page.`,
-    inputSchema: z.object({
-        path: z.string().min(1),
-        startLine: z.number().int().positive().optional(),
-    }),
-    async execute(args, context) {
-        const { path, startLine = 1 } = args;
-        const content = await context.readFile(path);
-        if (content === undefined)
-            return promptData(`File not found: ${path}`);
-        const lines = content.split("\n");
-        const end = Math.min(lines.length, startLine + MAX_READ_LINES - 1);
-        const body = fitting(lines.slice(startLine - 1, end).map((line, i) => `${startLine + i}: ${clip(line)}`));
-        const next = startLine + body.length;
-        if (next <= lines.length) {
-            body.push(`[truncated: ${lines.length - next + 1} more lines; call again with startLine=${next}]`);
-        }
-        return promptData(body.join("\n"));
-    },
-};
-const readDiff = {
-    name: REVIEW_TOOLS.readDiff,
-    description: "Read the diff of any changed file in this change, including files outside your bundle.",
-    inputSchema: z.object({ path: z.string().min(1) }),
-    async execute(args, context) {
-        const { path } = args;
-        const diff = context.readDiff(path);
-        if (diff === undefined)
-            return promptData(`No changes to ${path} in this change.`);
-        const lines = diff.split("\n").map((line) => clip(line));
-        const kept = fitting(lines);
-        if (kept.length < lines.length)
-            kept.push(`[diff truncated after ${kept.length} lines]`);
-        return promptData(kept.join("\n"));
-    },
-};
-const codeSearch = {
-    name: REVIEW_TOOLS.codeSearch,
-    description: `Search the revision under review for a literal string (not a regex). Returns up to ${MAX_SEARCH_RESULTS} matches as path:line: text.`,
-    inputSchema: z.object({ literal: z.string().min(2) }),
-    async execute(args, context) {
-        const { literal } = args;
-        const matches = await context.searchCode(literal);
-        if (matches.length === 0)
-            return "No matches.";
-        const shown = fitting(matches.slice(0, MAX_SEARCH_RESULTS).map((m) => `${m.path}:${m.line}: ${clip(m.text, 300)}`));
-        if (shown.length < matches.length) {
-            shown.push(`[${matches.length - shown.length} more matches omitted]`);
-        }
-        return promptData(shown.join("\n"));
-    },
-};
-const reportFinding = {
-    name: REVIEW_TOOLS.reportFinding,
-    description: "Report one confirmed defect. Call once per issue.",
-    inputSchema: reportFindingInput,
-    execute: async () => "Recorded.",
-};
-const taskDone = {
-    name: REVIEW_TOOLS.taskDone,
-    description: "Call once every file in <ocra_review_files> has been reviewed.",
-    inputSchema: z.object({}),
-    execute: async () => "Done.",
-};
-export const reviewTools = [
-    readFile,
-    readDiff,
-    codeSearch,
-    reportFinding,
-    taskDone,
-];
-//# sourceMappingURL=review-tools.js.map