@open-cr-agent/runtime-opencode 0.1.0

package/dist/session-outcome.d.ts

@@ -0,0 +1,48 @@
+import type { Usage } from "@open-cr-agent/core";
+import { type QuotaError } from "./quota.js";
+export interface SessionMessage {
+    info: {
+        role: string;
+        cost?: number;
+        tokens?: {
+            input?: number;
+            output?: number;
+            reasoning?: number;
+            cache?: {
+                read?: number;
+            };
+        };
+        error?: {
+            name?: string;
+            data?: {
+                message?: string;
+                statusCode?: number;
+                isRetryable?: boolean;
+            };
+        };
+    };
+    parts: {
+        type: string;
+        text?: string;
+        tool?: string;
+        state?: {
+            status?: string;
+            input?: unknown;
+        };
+    }[];
+}
+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;
+//# sourceMappingURL=session-outcome.d.ts.map

package/dist/session-outcome.js

@@ -0,0 +1,47 @@
+import { parseQuotaError } from "./quota.js";
+const AUTH_STATUS = new Set([401, 403]);
+const AUTH_MESSAGE = /api key|unauthori[sz]ed|permission denied|forbidden/i;
+export function summarizeSession(messages, reportTool) {
+    const assistant = messages.filter((m) => m.info.role === "assistant");
+    const tools = assistant.flatMap((m) => m.parts.filter((p) => p.type === "tool"));
+    const outcome = {
+        findings: tools
+            .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"),
+        text: assistant
+            .flatMap((m) => m.parts.filter((p) => p.type === "text").map((p) => p.text ?? ""))
+            .join("\n")
+            .trim(),
+        usage: {
+            inputTokens: sum(assistant, (m) => m.info.tokens?.input),
+            outputTokens: sum(assistant, (m) => m.info.tokens?.output),
+            reasoningTokens: sum(assistant, (m) => m.info.tokens?.reasoning),
+            cachedTokens: sum(assistant, (m) => m.info.tokens?.cache?.read),
+            costUsd: sum(assistant, (m) => m.info.cost),
+        },
+    };
+    const errors = assistant.flatMap((m) => (m.info.error ? [m.info.error] : []));
+    const last = errors.at(-1);
+    if (last) {
+        // Overloads and model-specific request rejections (for example Gemini 3.8
+        // refusing a request that ends with a model turn) are fixed by another
+        // model; only credential problems would fail on every model.
+        const message = last.data?.message ?? last.name ?? "unknown model error";
+        outcome.error = { message, retryable: !errors.some(isAuthError) };
+        const quota = parseQuotaError(message, last.data?.statusCode);
+        if (quota)
+            outcome.error.quota = quota;
+    }
+    return outcome;
+}
+function isAuthError(error) {
+    return (error.name === "ProviderAuthError" ||
+        AUTH_STATUS.has(error.data?.statusCode ?? 0) ||
+        AUTH_MESSAGE.test(error.data?.message ?? ""));
+}
+function sum(messages, pick) {
+    return messages.reduce((total, m) => total + (pick(m) ?? 0), 0);
+}
+//# sourceMappingURL=session-outcome.js.map

package/dist/session-prompt.d.ts

@@ -0,0 +1,30 @@
+import type { OpencodeClient } from "@opencode-ai/sdk/v2";
+import { type SessionMessage, type SessionOutcome } from "./session-outcome.js";
+export declare const HARVEST_TIMEOUT_MS = 5000;
+export declare const INACTIVITY_MS: number;
+export declare const ACTIVITY_POLL_MS = 30000;
+export interface ActivityOptions {
+    inactivityMs?: number;
+    pollMs?: number;
+}
+export interface PromptInput {
+    title: string;
+    agent: string;
+    model: string;
+    system: string;
+    user: string;
+    tools: Record<string, boolean>;
+    resume?: ResumeOptions;
+}
+export interface ResumeOptions {
+    doneTool: string;
+    maxSteps: number;
+    message: string;
+}
+export declare function stoppedEarly(outcome: SessionOutcome, 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 activitySignature(messages: readonly SessionMessage[]): string;
+export declare function emptyOutcome(): SessionOutcome;
+export {};
+//# sourceMappingURL=session-prompt.d.ts.map

package/dist/session-prompt.js

@@ -0,0 +1,156 @@
+import { emptyUsage, errorMessage } from "@open-cr-agent/core";
+import { parseModel } from "./models.js";
+import { 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;
+// A prompt returns only when the agent is done, so silence on the request is
+// normal; silence in the session is not. A session whose messages have not
+// changed for this long (no new step, no streamed text, no tool progress) is
+// stopped and the task moves to the next model instead of waiting for its
+// full timeout. Generous, so a slow step that is still writing survives.
+export const INACTIVITY_MS = 5 * 60_000;
+export const ACTIVITY_POLL_MS = 30_000;
+// About one review attempt in twelve on Gemini ended after a step or two
+// with no text, no done tool and steps to spare (2026-09-28), and the task
+// counted as completed with its files unread. Continuing the same session
+// keeps what it read and is cheaper than starting over.
+export function stoppedEarly(outcome, resume) {
+    return (!outcome.toolCalls.includes(resume.doneTool) &&
+        outcome.steps < resume.maxSteps &&
+        outcome.text.trim() === "");
+}
+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)}`);
+    }
+    const sessionID = created.data.id;
+    const stop = () => void session.abort({ sessionID }).catch(() => { });
+    signal.addEventListener("abort", stop, { once: true });
+    const silence = watchActivity(session, sessionID, activity);
+    const attempt = AbortSignal.any([signal, silence.signal]);
+    try {
+        const response = await session.prompt({
+            sessionID,
+            agent: input.agent,
+            model: parseModel(input.model),
+            system: input.system,
+            tools: input.tools,
+            parts: [{ type: "text", text: input.user }],
+        }, { signal: attempt });
+        // The session ran even when the answer is an error, and it may have
+        // spent tokens and reported findings: keep them.
+        if (response.error) {
+            return {
+                ...(await harvest(session, sessionID, reportTool)),
+                error: { message: JSON.stringify(response.error), retryable: false },
+            };
+        }
+        let outcome;
+        try {
+            const messages = await session.messages({ sessionID }, { signal: attempt });
+            outcome = summarizeSession((messages.data ?? []), reportTool);
+        }
+        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)),
+                error: {
+                    message: `could not read the finished session: ${errorMessage(error)}`,
+                    retryable: false,
+                },
+            };
+        }
+        if (!input.resume || !stoppedEarly(outcome, input.resume))
+            return outcome;
+        const again = await session.prompt({
+            sessionID,
+            agent: input.agent,
+            model: parseModel(input.model),
+            system: input.system,
+            tools: input.tools,
+            parts: [{ type: "text", text: input.resume.message }],
+        }, { signal: attempt });
+        // Both turns are in the session: their findings and their spend.
+        const resumed = {
+            ...(await harvest(session, sessionID, reportTool)),
+            resumed: true,
+        };
+        if (again.error)
+            resumed.error = { message: JSON.stringify(again.error), retryable: false };
+        return resumed;
+    }
+    catch (error) {
+        // 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 seconds = Math.round((activity.inactivityMs ?? INACTIVITY_MS) / 1000);
+        return {
+            ...partial,
+            error: signal.aborted
+                ? { message: "cancelled", retryable: false }
+                : silence.signal.aborted
+                    ? { message: `no activity for ${seconds}s`, retryable: true }
+                    : { message: errorMessage(error), retryable: true },
+        };
+    }
+    finally {
+        silence.stop();
+        signal.removeEventListener("abort", stop);
+    }
+}
+// Aborts when the session's messages stop changing. A failed poll counts as
+// no news, not as silence, so a slow server alone cannot end a task.
+function watchActivity(session, sessionID, options) {
+    const controller = new AbortController();
+    const inactivityMs = options.inactivityMs ?? INACTIVITY_MS;
+    let last = "";
+    let changedAt = Date.now();
+    let polling = false;
+    const timer = setInterval(async () => {
+        if (polling)
+            return;
+        polling = true;
+        try {
+            const messages = await session.messages({ sessionID }, { signal: AbortSignal.timeout(HARVEST_TIMEOUT_MS) });
+            const now = activitySignature((messages.data ?? []));
+            if (now !== last) {
+                last = now;
+                changedAt = Date.now();
+            }
+            else if (Date.now() - changedAt >= inactivityMs) {
+                controller.abort();
+            }
+        }
+        catch {
+            // no news
+        }
+        finally {
+            polling = false;
+        }
+    }, options.pollMs ?? ACTIVITY_POLL_MS);
+    timer.unref?.();
+    return { signal: controller.signal, stop: () => clearInterval(timer) };
+}
+// What changes while an agent works: steps, parts, streamed text, tool states.
+export function activitySignature(messages) {
+    return messages
+        .map((m) => m.parts.map((p) => `${p.type}:${p.state?.status ?? ""}:${p.text?.length ?? 0}`).join(","))
+        .join("|");
+}
+async function harvest(session, sessionID, reportTool) {
+    try {
+        const messages = await session.messages({ sessionID }, { signal: AbortSignal.timeout(HARVEST_TIMEOUT_MS) });
+        return summarizeSession((messages.data ?? []), reportTool);
+    }
+    catch {
+        return emptyOutcome();
+    }
+}
+export function emptyOutcome() {
+    return { findings: [], steps: 0, toolCalls: [], text: "", usage: emptyUsage() };
+}
+//# sourceMappingURL=session-prompt.js.map

package/dist/tool-server.d.ts

@@ -0,0 +1,8 @@
+import { type ReviewContext, type ToolDefinition } from "@open-cr-agent/core";
+export interface ToolServer {
+    url: string;
+    headers: Record<string, string>;
+    close(): Promise<void>;
+}
+export declare function startToolServer(tools: readonly ToolDefinition[], context: () => ReviewContext | undefined): Promise<ToolServer>;
+//# sourceMappingURL=tool-server.d.ts.map

package/dist/tool-server.js

@@ -0,0 +1,63 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+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";
+// 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) {
+    const token = randomBytes(32).toString("hex");
+    const expected = Buffer.from(`Bearer ${token}`);
+    const http = createServer(async (req, res) => {
+        if (!authorized(req, expected)) {
+            res.writeHead(401).end();
+            return;
+        }
+        const mcp = buildMcpServer(tools, context);
+        const transport = new StreamableHTTPServerTransport({});
+        res.on("close", () => {
+            void transport.close();
+            void mcp.close();
+        });
+        // The SDK's transport types are not written for exactOptionalPropertyTypes.
+        await mcp.connect(transport);
+        await transport.handleRequest(req, res);
+    });
+    await new Promise((resolve) => http.listen(0, "127.0.0.1", resolve));
+    const address = http.address();
+    const port = typeof address === "object" && address ? address.port : 0;
+    return {
+        url: `http://127.0.0.1:${port}/mcp`,
+        headers: { Authorization: `Bearer ${token}` },
+        close: () => new Promise((resolve) => {
+            http.closeAllConnections();
+            http.close(() => resolve());
+        }),
+    };
+}
+function buildMcpServer(tools, context) {
+    const mcp = new McpServer({ name: "ocra", version: VERSION });
+    for (const tool of tools) {
+        mcp.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema.shape }, async (args) => {
+            const ctx = context();
+            if (!ctx)
+                return failure("No review is running.");
+            try {
+                return { content: [{ type: "text", text: await tool.execute(args, ctx) }] };
+            }
+            catch (error) {
+                return failure(errorMessage(error));
+            }
+        });
+    }
+    return mcp;
+}
+function failure(message) {
+    return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+}
+function authorized(req, expected) {
+    const actual = Buffer.from(req.headers.authorization ?? "");
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+//# sourceMappingURL=tool-server.js.map

package/dist/transport.d.ts

@@ -0,0 +1,4 @@
+import { Agent, type Dispatcher } from "undici";
+export declare function createUntimedDispatcher(): Agent;
+export declare function untimedFetch(dispatcher: Dispatcher): typeof fetch;
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.js

@@ -0,0 +1,25 @@
+import { Agent, fetch as undiciFetch } from "undici";
+// OpenCode answers a prompt only when the agent has finished, which can take
+// longer than fetch's default 300 s header and body timeouts; on Node those
+// end the request as an error that is not an abort (the SDK's
+// `timeout = false` only works on Bun). The task's own timeout and abort
+// signal bound each request instead. undici's fetch and Agent are used
+// together so no object crosses between it and Node's bundled copy.
+export function createUntimedDispatcher() {
+    return new Agent({ headersTimeout: 0, bodyTimeout: 0 });
+}
+export function untimedFetch(dispatcher) {
+    return async (input, init) => {
+        const request = new Request(input, init);
+        const body = request.body === null ? undefined : await request.arrayBuffer();
+        const response = await undiciFetch(request.url, {
+            method: request.method,
+            headers: [...request.headers],
+            ...(body === undefined ? {} : { body }),
+            signal: request.signal,
+            dispatcher,
+        });
+        return response;
+    };
+}
+//# sourceMappingURL=transport.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@open-cr-agent/runtime-opencode",
+  "version": "0.1.0",
+  "description": "OpenCode-based agent runtime for Open-CR-Agent",
+  "keywords": [
+    "code-review",
+    "opencode",
+    "agents"
+  ],
+  "license": "Apache-2.0",
+  "homepage": "https://ocra.majincheng.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jma49/Open-CR-Agent.git",
+    "directory": "packages/runtime-opencode"
+  },
+  "bugs": "https://github.com/jma49/Open-CR-Agent/issues",
+  "engines": {
+    "node": ">=22.19"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.1",
+    "@open-cr-agent/core": "0.1.0",
+    "@opencode-ai/sdk": "1.18.32",
+    "opencode-ai": "1.18.32",
+    "undici": "^8.11.2",
+    "zod": "^4.6.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}