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

package/dist/binary.d.ts

@@ -1,4 +1,4 @@
-import type { Env } from "@open-cr-agent/core";
+import { type Env } from "@open-cr-agent/core";
 export interface Host {
     platform: string;
     arch: string;

package/dist/binary.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 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. An
@@ -29,7 +30,7 @@ export function resolveOpencodeBinary(env, opencodePackage = createRequire(impor
     const placed = join(dirname(opencodePackage), "bin", "opencode.exe");
     if (isNativeExecutable(placed))
         return placed;
-    throw new Error(`No OpenCode binary for ${platform}-${process.arch}: install without --omit=optional, or set OCRA_OPENCODE_BIN`);
+    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

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 CustomProvider, 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,7 +27,7 @@ export declare class OpenCodeRuntime implements AgentRuntime {
     private start;
     private launch;
 }
-export declare function openCodeConfig(tools: Pick<ToolServer, "url" | "headers">, helperTools: Record<string, boolean>, custom?: Readonly<Record<string, CustomProvider>>): {
+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?: {
@@ -41,6 +41,7 @@ export declare function openCodeConfig(tools: Pick<ToolServer, "url" | "headers"
             models: {
                 [k: string]: {
                     name: string;
+                    temperature?: boolean;
                     cost: {
                         input: number;
                         output: number;
@@ -61,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;
@@ -75,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,7 +128,15 @@ 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();
@@ -165,7 +146,7 @@ export class OpenCodeRuntime {
         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"),
@@ -181,7 +162,7 @@ export class OpenCodeRuntime {
                 binary: this.options.binary ?? resolveOpencodeBinary(this.options.env),
                 cwd: workspace,
                 env: serverEnv(this.options.env, dirs, providersOf(this.options.models), custom),
-                config: openCodeConfig(tools, this.helperTools, custom),
+                config: openCodeConfig(tools, this.helperTools, custom, this.options.sampling),
             });
             started = server;
             const dispatcher = createUntimedDispatcher();
@@ -198,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()]);
@@ -207,12 +189,26 @@ export class OpenCodeRuntime {
         }
     }
 }
-export function openCodeConfig(tools, helperTools, custom = {}) {
+// 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) } : {}),
+        ...(Object.keys(custom).length > 0
+            ? { provider: providerConfig(custom, temperature !== undefined) }
+            : {}),
         mcp: {
             [MCP_SERVER]: {
                 type: "remote",
@@ -229,6 +225,7 @@ export function openCodeConfig(tools, helperTools, custom = {}) {
                 steps: MAX_AGENT_STEPS,
                 tools: DISABLED_BUILTINS,
                 permission,
+                ...agentSampling,
             },
             [HELPER_AGENT]: {
                 mode: "primary",
@@ -236,6 +233,7 @@ export function openCodeConfig(tools, helperTools, custom = {}) {
                 steps: HELPER_AGENT_STEPS,
                 tools: helperTools,
                 permission,
+                ...agentSampling,
             },
         },
     };
@@ -245,7 +243,9 @@ export function openCodeConfig(tools, helperTools, custom = {}) {
 // (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.
-function providerConfig(custom) {
+// 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,
         {
@@ -259,6 +259,7 @@ function providerConfig(custom) {
                 model,
                 {
                     name: model,
+                    ...(temperature ? { temperature: true } : {}),
                     cost: {
                         input: price.input,
                         output: price.output,

package/dist/server-env.d.ts

@@ -7,6 +7,8 @@ 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 {};
 //# sourceMappingURL=server-env.d.ts.map

package/dist/server-env.js

@@ -117,43 +117,62 @@ const NEVER_BY_PREFIX = [
     "SSH_",
     "OCRA_",
 ];
-// The child sees only what it needs: system basics, the credentials of the
-// 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, custom = {}) {
-    const env = {};
-    const copy = (name) => {
-        const value = base[name];
-        if (value !== undefined)
-            env[name] = value;
-    };
-    for (const name of SYSTEM_VARIABLES)
-        copy(name);
-    for (const name of Object.keys(base))
-        if (name.startsWith("LC_"))
-            copy(name);
+// 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)
-                copy(declared.apiKeyEnv);
+                names.push(declared.apiKeyEnv);
             continue;
         }
         const known = PROVIDER_VARIABLES[provider];
         if (known) {
-            for (const name of known)
-                copy(name);
+            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))) {
-                    copy(name);
+                    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 (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, custom = {}) {
+    const env = {};
+    const copy = (name) => {
+        const value = base[name];
+        if (value !== undefined)
+            env[name] = value;
+    };
+    for (const name of SYSTEM_VARIABLES)
+        copy(name);
+    for (const name of Object.keys(base))
+        if (name.startsWith("LC_"))
+            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());

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.2.0",
+  "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.2.0",
+    "@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