@reasoning-router/opencode 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert N
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,81 @@
-# Temporary Holding Version
+# @reasoning-router/opencode
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An [OpenCode](https://opencode.ai) V2 plugin that asks a classifier how much
+reasoning each step needs, then applies that effort to the outgoing model
+request without breaking the prompt cache. Every classifier in
+[`@reasoning-router/classifiers`](../classifiers) (Jev, Cloudflare Clef,
+and Laya) is available.
+
+> **Alpha.** This package is not published to npm yet, and OpenCode installs
+> plugins by package name from a registry. The configuration below works
+> after the first release. Until then, `npm run smoke:plugin:v2` installs the
+> packed plugin into OpenCode 2.0.18 from a local test registry.
+
+Ported from
+[`opencode-jev-router`](https://github.com/robertn702/opencode-jev-router).
+
+## Requirements
+
+- OpenCode V2 2.0.4 or newer (smoke-tested with 2.0.18).
+- A classifier key. For Jev: a [TypeSafe](https://typesafe.ai/) key, or a
+  [Vercel AI Gateway](https://vercel.com/docs/ai-gateway/sdks-and-apis/typesafe)
+  key used with `baseUrl: "https://ai-gateway.vercel.sh/typesafe"`. For Clef:
+  a Cloudflare Workers AI API token and account ID. For Laya: a Laya server
+  you run (see [`docs/environment.md`](../../docs/environment.md)).
+- A Responses API endpoint serving GPT-6 Astra, Luna, or Sol, or an Anthropic
+  Messages endpoint with the mid-conversation output-config beta.
+
+## Usage
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": [{ "package": "@reasoning-router/opencode", "options": {
+    "classifier": { "provider": "jev", "apiKey": "{env:REASONING_ROUTER_CLASSIFIER_API_KEY}" },
+    "wrap": { "openai": ["openai/gpt-6-astra"] },
+    "decisionsLogPath": "/tmp/reasoning-decisions.jsonl"
+  }}],
+  "model": "reasoning-router/gpt-6-astra"
+}
+```
+
+The plugin registers `reasoning-router/<profile>` aliases only for the source
+models listed in `wrap` (`openai` and/or `anthropic` arrays of
+`provider/model` refs). Source models are left untouched. Each primary request
+to an alias gets one classification; if the classifier fails, the request
+continues at the fallback effort (`high` by default). With
+`decisionsLogPath`, each routed request appends a metadata-only
+`ReasoningDecision` event that records the deciding `classifier`.
+
+See [`examples/opencode.jsonc`](../../examples/opencode.jsonc) for a full
+example.
+
+## Options
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `classifier.provider` | `REASONING_ROUTER_CLASSIFIER` env, then `jev` | Classifier provider: `jev`, `clef`, or `laya`. |
+| `classifier.apiKey` | `REASONING_ROUTER_CLASSIFIER_API_KEY` env | Classifier key. Required for `jev` and `clef` unless `fixedEffort` is set; optional for `laya`. |
+| `classifier.baseUrl` | `REASONING_ROUTER_CLASSIFIER_BASE_URL` env, then the provider default | Jev endpoint, or the Laya server (default `http://127.0.0.1:8000`). |
+| `classifier.accountId` | `REASONING_ROUTER_CLASSIFIER_ACCOUNT_ID` env | Clef: Cloudflare account ID. |
+| `classifier.model` | `REASONING_ROUTER_CLASSIFIER_MODEL` env | Clef: `clef` or `clef-flash` (required). |
+| `classifier.timeoutMs` | `4000` | Total classification budget, including retries. |
+| `wrap` | none | Required nonempty object of `openai`/`anthropic` source refs. |
+| `decisionsLogPath` | off | Absolute path for `ReasoningDecision` JSONL. |
+| `baseEffort` | profile default | Request-level effort reported by responses. |
+| `fixedEffort` | none | Skip the classifier and always use this effort. |
+| `maxRetries` | `1` | Extra attempts after transient classifier errors. |
+| `fallbackMode` | `fixed` | `fixed`, `previous`, or `error`. |
+| `fallbackEffort` | `high` | Effort used when classification fails. |
+| `maxRequestBytes` | `1048576` | Largest request body. |
+| `maxInFlight` | `32` | Concurrent requests. |
+| `upstreamHeaderTimeoutMs` | `10000` | Wait for endpoint response headers. |
+| `upstreamIdleTimeoutMs` | `60000` | Longest gap between streamed chunks. |
+
+Wire behavior, logging, and limits are documented in
+[`docs/behavior.md`](../../docs/behavior.md) and
+[`docs/classification-policy.md`](../../docs/classification-policy.md).
+
+## License
+
+[MIT](LICENSE)

package/dist/plugin-runtime.d.ts

@@ -0,0 +1,88 @@
+import { type Provider } from "@reasoning-router/core";
+import { z } from "zod";
+declare const pluginOptionsSchema: z.ZodObject<{
+    maxRetries: z.ZodDefault<z.ZodInt>;
+    fallbackMode: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        fixed: "fixed";
+        previous: "previous";
+    }>>;
+    fallbackEffort: z.ZodDefault<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        none: "none";
+        xhigh: "xhigh";
+    }>>;
+    classifier: z.ZodPrefault<z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodInt>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        accountId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    baseEffort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        none: "none";
+        xhigh: "xhigh";
+    }>>;
+    fixedEffort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        none: "none";
+        xhigh: "xhigh";
+    }>>;
+    maxRequestBytes: z.ZodDefault<z.ZodInt>;
+    maxInFlight: z.ZodDefault<z.ZodInt>;
+    upstreamHeaderTimeoutMs: z.ZodDefault<z.ZodInt>;
+    upstreamIdleTimeoutMs: z.ZodDefault<z.ZodInt>;
+    decisionsLogPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Options for the OpenCode V2 plugin runtime. */
+export type PluginOptions = z.input<typeof pluginOptionsSchema>;
+/** A local rejection with an HTTP status for the plugin request hook. */
+export declare class PluginRequestError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export interface Correlation {
+    session: string | null;
+    turnId: string | null;
+}
+/**
+ * One routed Responses exchange. After `start` resolves the caller owns it and
+ * must settle it with `respond`, `fail`, or `cancel`; the header timeout also
+ * settles it when no response ever arrives.
+ */
+export interface Exchange {
+    readonly url: string;
+    readonly headers: Headers;
+    readonly body: string;
+    /** Aborts on caller cancellation, disposal, header timeout, or idle timeout. */
+    readonly signal: AbortSignal;
+    /** Wrap upstream response bytes for usage observation without buffering. */
+    respond(upstream: Response): Response;
+    /** Settle a transport failure before response headers. */
+    fail(cause: unknown): PluginRequestError;
+    /** Settle a caller cancellation before response headers. */
+    cancel(): void;
+}
+export interface PluginRuntime {
+    start(request: Request, correlation: Correlation, group?: Provider): Promise<Exchange>;
+    dispose(): void;
+}
+export declare const SESSION: RegExp;
+export declare const TURN: RegExp;
+export declare const valid: (value: string | null | undefined, pattern: RegExp) => string | null;
+export declare const requiredString: (value: unknown, name: string) => string;
+/** Per-plugin-instance state, validation, classifier selection, rewrite, and usage observation. */
+export declare function createPluginRuntime(options: unknown): PluginRuntime;
+export {};

package/dist/plugin-runtime.js

@@ -0,0 +1,389 @@
+import { createHash } from "node:crypto";
+import { classifierProviders } from "@reasoning-router/classifiers";
+import { anthropicVersion, buildPluginUpstreamRequestHeaders, classificationPolicySchema, createConfiguredSelector, createDecisionLogger, mergeAnthropicBeta, parseConfig, pickFetchResponseHeaders, ResponsesRouter, resolveModel, UnsupportedInputError, UsageObserver, universalEffort, upstreamHostname, validateRequest, wireFor, } from "@reasoning-router/core";
+import { z } from "zod";
+const positiveInteger = (name, fallback) => {
+    const message = `${name} must be a positive integer`;
+    return z.int(message).min(1, message).default(fallback);
+};
+const optionalString = (name) => z.string(`${name} must be a string`).optional();
+const TIMEOUT = "timeoutMs must be a positive integer";
+const pluginOptionsSchema = z.object({
+    ...classificationPolicySchema.shape,
+    /** `provider` (default `REASONING_ROUTER_CLASSIFIER`, then `jev`) plus that provider's settings. */
+    classifier: z
+        .looseObject({
+        provider: optionalString("classifier.provider"),
+        timeoutMs: z.int(TIMEOUT).min(1, TIMEOUT).optional(),
+        apiKey: optionalString("classifier.apiKey"),
+        baseUrl: optionalString("classifier.baseUrl"),
+        accountId: optionalString("classifier.accountId"),
+        model: optionalString("classifier.model"),
+    }, "classifier must be an object")
+        .prefault({}),
+    baseEffort: universalEffort("baseEffort is unsupported").optional(),
+    fixedEffort: universalEffort("fixedEffort must be supported by every model").optional(),
+    maxRequestBytes: positiveInteger("maxRequestBytes", 1_048_576),
+    maxInFlight: positiveInteger("maxInFlight", 32),
+    upstreamHeaderTimeoutMs: positiveInteger("upstreamHeaderTimeoutMs", 10_000),
+    upstreamIdleTimeoutMs: positiveInteger("upstreamIdleTimeoutMs", 60_000),
+    decisionsLogPath: z
+        .string("decisionsLogPath must be an absolute path")
+        .optional(),
+});
+/** A local rejection with an HTTP status for the plugin request hook. */
+export class PluginRequestError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "PluginRequestError";
+    }
+}
+export const SESSION = /^ses_[A-Za-z0-9]{1,128}$/;
+export const TURN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export const valid = (value, pattern) => (value && pattern.test(value) ? value : null);
+const hash = (value) => createHash("sha256")
+    .update(value ?? "")
+    .digest("hex");
+export const requiredString = (value, name) => {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${name} is required`);
+    return value;
+};
+const HTTP_URL = "must be an HTTP(S) URL without credentials, query, or fragment";
+const checkUpstreamURL = (url, name) => {
+    if (!/^https?:$/.test(url.protocol) ||
+        !url.hostname ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash)
+        throw new Error(`${name} ${HTTP_URL}`);
+    const loopback = ["127.0.0.1", "localhost", "::1"].includes(upstreamHostname(url));
+    if (url.protocol !== "https:" && !loopback)
+        throw new Error(`${name} requires HTTPS except for loopback endpoints`);
+};
+async function boundedBody(request, maxBytes, signal) {
+    const declared = request.headers.get("content-length");
+    if (declared !== null &&
+        (!/^\d+$/.test(declared) || Number(declared) > maxBytes))
+        throw new RangeError("request_too_large");
+    if (request.body === null)
+        return new Uint8Array();
+    const reader = request.body.getReader();
+    const chunks = [];
+    let size = 0;
+    const aborted = new Promise((_, reject) => signal.addEventListener("abort", () => reject(new DOMException("aborted", "AbortError")), { once: true }));
+    try {
+        for (;;) {
+            const next = await Promise.race([reader.read(), aborted]);
+            if (next.done)
+                break;
+            size += next.value.byteLength;
+            if (size > maxBytes)
+                throw new RangeError("request_too_large");
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        if (signal.aborted || size > maxBytes)
+            await reader.cancel().catch(() => undefined);
+    }
+    const output = new Uint8Array(size);
+    let at = 0;
+    for (const chunk of chunks) {
+        output.set(chunk, at);
+        at += chunk.byteLength;
+    }
+    return output;
+}
+function classifierSelector({ classifier, maxRetries, fallbackMode, fallbackEffort, }) {
+    const env = process.env;
+    return createConfiguredSelector({
+        ...classifier,
+        provider: classifier.provider ?? (env.REASONING_ROUTER_CLASSIFIER || "jev"),
+        apiKey: classifier.apiKey ?? env.REASONING_ROUTER_CLASSIFIER_API_KEY,
+        baseUrl: classifier.baseUrl ?? env.REASONING_ROUTER_CLASSIFIER_BASE_URL,
+        accountId: classifier.accountId ??
+            (env.REASONING_ROUTER_CLASSIFIER_ACCOUNT_ID || undefined),
+        model: classifier.model ??
+            (env.REASONING_ROUTER_CLASSIFIER_MODEL || undefined),
+    }, classifierProviders, { maxRetries, fallbackMode, fallbackEffort });
+}
+/** Per-plugin-instance state, validation, classifier selection, rewrite, and usage observation. */
+export function createPluginRuntime(options) {
+    const config = parseConfig(pluginOptionsSchema, options);
+    const { baseEffort, fixedEffort, decisionsLogPath, maxRequestBytes: maxBytes, maxInFlight, upstreamHeaderTimeoutMs: headerTimeoutMs, upstreamIdleTimeoutMs: idleTimeoutMs, } = config;
+    const selectEffort = fixedEffort === undefined
+        ? classifierSelector(config)
+        : async () => ({
+            effort: fixedEffort,
+            classifierLatencyMs: 0,
+            fallback: null,
+        });
+    const onEvidence = decisionsLogPath === undefined
+        ? undefined
+        : createDecisionLogger(decisionsLogPath);
+    const router = new ResponsesRouter({
+        baseEffort,
+        selectEffort,
+        onEvidence,
+    });
+    // Each open exchange's controller maps to its incoming request. Undici follows a
+    // Request's init signal through a weak reference, and the host drops the original
+    // request once the hook replaces it, so holding it here keeps session
+    // cancellation reaching `request.signal` until the exchange settles.
+    const controllers = new Map();
+    // Disposal settles every open exchange: V2 never sees a response for an aborted fetch.
+    const abandons = new Set();
+    let inFlight = 0;
+    let disposed = false;
+    async function start(request, correlation, group) {
+        if (disposed)
+            throw new PluginRequestError(503, "unavailable", "reasoning-router plugin is disposed");
+        const url = new URL(request.url);
+        const provider = url.pathname.endsWith("/responses")
+            ? "openai"
+            : url.pathname.endsWith("/messages")
+                ? "anthropic"
+                : null;
+        if (provider === null || request.method !== "POST")
+            throw new PluginRequestError(400, "invalid_request", "reasoning-router supports POST /v1/responses or /v1/messages only");
+        if (group !== undefined && provider !== group)
+            throw new PluginRequestError(400, "invalid_request", `alias requires ${group === "openai" ? "/responses" : "/messages"}`);
+        try {
+            checkUpstreamURL(new URL(url.origin), "upstream URL");
+        }
+        catch (cause) {
+            throw new PluginRequestError(400, "invalid_request", cause instanceof Error ? cause.message : String(cause));
+        }
+        if (inFlight >= maxInFlight)
+            throw new PluginRequestError(503, "overloaded", "router overloaded");
+        inFlight += 1;
+        const controller = new AbortController();
+        controllers.set(controller, request);
+        const signal = AbortSignal.any([request.signal, controller.signal]);
+        let releaseDone = false;
+        let prepared = null;
+        let handedOff = false;
+        let timedOut = false;
+        let responded = false;
+        let timer;
+        const release = () => {
+            if (!releaseDone) {
+                releaseDone = true;
+                clearTimeout(timer);
+                controllers.delete(controller);
+                abandons.delete(abandon);
+                inFlight -= 1;
+            }
+        };
+        const discard = (outcome) => prepared?.finish(outcome, 0, false);
+        const abandon = () => {
+            discard("failed");
+            release();
+        };
+        abandons.add(abandon);
+        const settle = (outcome) => {
+            if (!responded) {
+                discard(outcome);
+                release();
+            }
+        };
+        try {
+            let body;
+            try {
+                body = JSON.parse(new TextDecoder().decode(await boundedBody(request, maxBytes, signal)));
+            }
+            catch (cause) {
+                if (cause instanceof RangeError)
+                    throw new PluginRequestError(413, "request_too_large", "request_too_large");
+                if (signal.aborted)
+                    throw new PluginRequestError(499, "cancelled", "request cancelled");
+                throw new PluginRequestError(400, "invalid_request", "request body must be valid JSON");
+            }
+            // Validate before reading optional fields or calling the classifier.
+            const model = resolveModel(body);
+            const record = validateRequest(body, model, provider);
+            const credential = provider === "anthropic"
+                ? (request.headers.get("x-api-key") ??
+                    request.headers.get("authorization"))
+                : request.headers.get("authorization");
+            const wire = wireFor(provider);
+            const headers = buildPluginUpstreamRequestHeaders(request.headers, "");
+            // OpenAI headers stay as before; only Anthropic requests drop OpenAI-only headers.
+            if (provider === "anthropic") {
+                for (const name of [...headers.keys()])
+                    if (name.startsWith("openai-"))
+                        headers.delete(name);
+                headers.set("anthropic-version", anthropicVersion(headers.get("anthropic-version")));
+                headers.set("anthropic-beta", mergeAnthropicBeta(headers.get("anthropic-beta")));
+            }
+            const lineageKey = wire.lineageKey(record);
+            const { session, turnId } = correlation;
+            prepared = await router.prepare(body, {
+                provider,
+                signal,
+                session,
+                turnId,
+                cacheScope: hash(credential),
+                scope: session || lineageKey
+                    ? [
+                        `${url.origin}${url.pathname.replace(/\/(responses|messages)$/, "")}`,
+                        model.id,
+                        baseEffort ?? model.defaultBaseEffort,
+                        hash(credential),
+                        session ?? "",
+                        lineageKey ?? "",
+                        ...wire.scopeParts(record),
+                        ...(provider === "anthropic"
+                            ? [
+                                headers.get("anthropic-beta"),
+                                headers.get("anthropic-version"),
+                            ]
+                            : []),
+                    ]
+                    : null,
+            });
+            if (prepared === null)
+                throw new PluginRequestError(499, "cancelled", "request cancelled");
+            const encoded = JSON.stringify(prepared.body);
+            headers.set("content-length", String(Buffer.byteLength(encoded)));
+            timer = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+                settle("failed");
+            }, headerTimeoutMs);
+            const exchange = {
+                url: request.url,
+                headers,
+                body: encoded,
+                signal,
+                respond(upstream) {
+                    clearTimeout(timer);
+                    if (responded)
+                        throw new Error("exchange already responded");
+                    if (releaseDone) {
+                        // Headers arrived after the deadline or disposal already settled this exchange.
+                        void upstream.body?.cancel().catch(() => undefined);
+                        throw timedOut
+                            ? new PluginRequestError(504, "upstream_timeout", "upstream_timeout")
+                            : disposed
+                                ? new PluginRequestError(503, "unavailable", "reasoning-router plugin is disposed")
+                                : new PluginRequestError(499, "cancelled", "request cancelled");
+                    }
+                    responded = true;
+                    const current = prepared;
+                    const observer = new UsageObserver((upstream.headers.get("content-type") ?? "").includes("text/event-stream"), provider);
+                    if (upstream.body === null) {
+                        current.finish("completed", upstream.status, false);
+                        release();
+                        return new Response(null, {
+                            status: upstream.status,
+                            headers: pickFetchResponseHeaders(upstream.headers),
+                        });
+                    }
+                    const reader = upstream.body.getReader();
+                    // A read pending at cancellation settles (done or aborted) after it; cancel() records the outcome.
+                    let cancelled = false;
+                    const stream = new ReadableStream({
+                        async pull(output) {
+                            const idle = setTimeout(() => controller.abort(), idleTimeoutMs);
+                            try {
+                                const next = await reader.read();
+                                if (cancelled)
+                                    return;
+                                if (next.done) {
+                                    observer.finish();
+                                    current.finish("completed", upstream.status, observer.completed, observer.usage);
+                                    output.close();
+                                    release();
+                                }
+                                else {
+                                    observer.push(next.value);
+                                    output.enqueue(next.value);
+                                }
+                            }
+                            catch (cause) {
+                                if (cancelled)
+                                    return;
+                                current.finish("failed", 0, false);
+                                output.error(cause);
+                                release();
+                            }
+                            finally {
+                                clearTimeout(idle);
+                            }
+                        },
+                        // OpenCode V2 cancels the body once it parses `response.completed`,
+                        // before EOF. A terminal event already forwarded still completes.
+                        async cancel() {
+                            cancelled = true;
+                            controller.abort();
+                            try {
+                                await reader.cancel();
+                            }
+                            finally {
+                                if (observer.completed)
+                                    current.finish("completed", upstream.status, true, observer.usage);
+                                else
+                                    current.finish("cancelled", 0, false);
+                                release();
+                            }
+                        },
+                    });
+                    return new Response(stream, {
+                        status: upstream.status,
+                        statusText: upstream.statusText,
+                        headers: pickFetchResponseHeaders(upstream.headers),
+                    });
+                },
+                fail() {
+                    settle("failed");
+                    if (timedOut)
+                        return new PluginRequestError(504, "upstream_timeout", "upstream_timeout");
+                    if (signal.aborted)
+                        return new PluginRequestError(499, "cancelled", "request cancelled");
+                    return new PluginRequestError(502, "upstream_unavailable", "upstream_unavailable");
+                },
+                cancel() {
+                    settle("cancelled");
+                },
+            };
+            handedOff = true;
+            return exchange;
+        }
+        catch (cause) {
+            discard("failed");
+            if (cause instanceof PluginRequestError)
+                throw cause;
+            if (cause instanceof Error && cause.message === "classification_failed")
+                throw new PluginRequestError(502, "classification_failed", "classification_failed");
+            if (cause instanceof UnsupportedInputError)
+                throw new PluginRequestError(400, "invalid_request", cause.message);
+            if (signal.aborted)
+                throw new PluginRequestError(499, "cancelled", "request cancelled");
+            throw new PluginRequestError(502, "upstream_unavailable", "upstream_unavailable");
+        }
+        finally {
+            if (!handedOff) {
+                discard("failed");
+                release();
+            }
+        }
+    }
+    return {
+        start,
+        dispose() {
+            disposed = true;
+            for (const controller of controllers.keys())
+                controller.abort();
+            for (const abandon of [...abandons])
+                abandon();
+            router.reset();
+        },
+    };
+}

package/dist/plugin-v2.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from "@opencode/plugin";
+/** The part of the plugin context the router uses. */
+export type Host = Pick<Plugin.Context, "options"> & {
+    readonly provider: Pick<Plugin.Context["provider"], "transform">;
+    readonly model: Pick<Plugin.Context["model"], "transform">;
+    readonly integration: Pick<Plugin.Context["integration"], "connection">;
+    readonly session: Pick<Plugin.Context["session"], "hook">;
+};
+export declare const PROVIDER_ID = "reasoning-router";
+export declare const PROVIDER_PACKAGE = "@opencode/ai/providers/openai/responses";
+export declare function setupV2(ctx: Host): Promise<() => void>;

package/dist/plugin-v2.js

@@ -0,0 +1,237 @@
+import { randomUUID } from "node:crypto";
+import { MODELS, modelsFor, parseConfig, } from "@reasoning-router/core";
+import { z } from "zod";
+import { createPluginRuntime, PluginRequestError, SESSION, valid, } from "./plugin-runtime.js";
+/**
+ * OpenCode's model and provider IDs are `Schema.String` brands with no other
+ * checks, so this is the check `ID.make` performs, without importing the SDK
+ * at runtime.
+ */
+const isID = (value) => typeof value === "string";
+const toID = (value) => {
+    if (isID(value))
+        return value;
+    throw new TypeError(`reasoning-router: invalid OpenCode ID ${value}`);
+};
+export const PROVIDER_ID = "reasoning-router";
+export const PROVIDER_PACKAGE = "@opencode/ai/providers/openai/responses";
+const PACKAGES = {
+    openai: PROVIDER_PACKAGE,
+    anthropic: "@opencode/ai/providers/anthropic",
+};
+const rejection = (cause) => cause instanceof PluginRequestError
+    ? new Error(`reasoning-router ${cause.code} (${cause.status}): ${cause.message}`)
+    : new Error("reasoning-router upstream_unavailable (502): upstream_unavailable");
+const removed = (key) => z
+    .never(`reasoning-router: ${key} was removed; configure wrap instead`)
+    .optional();
+const wrapRefs = (group) => {
+    const array = `reasoning-router: wrap.${group} must be a nonempty array of provider/model refs`;
+    const ref = `reasoning-router: wrap.${group} requires provider/model refs from another provider`;
+    return z
+        .array(z
+        .string(ref)
+        .regex(/^[^/\s]+\/[^/\s]+$/, ref)
+        .refine((value) => !value.startsWith(`${PROVIDER_ID}/`), ref), array)
+        .min(1, array)
+        .optional();
+};
+const WRAP = "reasoning-router: wrap must be a nonempty object of openai/anthropic model refs";
+const wrapOptionsSchema = z.object({
+    upstreamBaseURL: removed("upstreamBaseURL"),
+    upstreamApiKey: removed("upstreamApiKey"),
+    anthropicUpstreamBaseURL: removed("anthropicUpstreamBaseURL"),
+    anthropicUpstreamApiKey: removed("anthropicUpstreamApiKey"),
+    wrap: z
+        .strictObject({ openai: wrapRefs("openai"), anthropic: wrapRefs("anthropic") }, {
+        error: (issue) => issue.code === "unrecognized_keys"
+            ? `reasoning-router: unknown wrap group ${issue.keys.join(", ")}`
+            : WRAP,
+    })
+        .refine((wrap) => wrap.openai || wrap.anthropic, WRAP),
+});
+function parseWrap(options) {
+    const { wrap } = parseConfig(wrapOptionsSchema, options);
+    return ["openai", "anthropic"].flatMap((group) => (wrap[group] ?? []).map((ref) => {
+        const slash = ref.indexOf("/");
+        return {
+            group,
+            providerID: ref.slice(0, slash),
+            modelID: ref.slice(slash + 1),
+            ref,
+        };
+    }));
+}
+export async function setupV2(ctx) {
+    const refs = parseWrap(ctx.options);
+    const runtime = createPluginRuntime(ctx.options);
+    const exchanges = new WeakMap();
+    let aliases = new Map();
+    let validationError;
+    await ctx.provider.transform((editor) => {
+        const models = [...new Set(refs.map((ref) => ref.group))].flatMap((group) => modelsFor(group).map((profile) => ({
+            id: toID(profile.id),
+            modelID: toID(profile.id),
+            providerID: toID(PROVIDER_ID),
+            name: profile.name,
+            package: PACKAGES[group],
+            settings: { baseURL: "http://127.0.0.1:1/v1" },
+            capabilities: {
+                tools: true,
+                input: ["text", "image"],
+                output: ["text"],
+            },
+            variants: [],
+            time: { released: 0 },
+            cost: [],
+            status: "active",
+            enabled: true,
+            limit: { context: 200_000, output: 32_000 },
+        })));
+        editor.add({
+            info: {
+                id: toID(PROVIDER_ID),
+                name: "Reasoning Router",
+                activation: "enabled",
+                package: PROVIDER_PACKAGE,
+                settings: { transport: "http" },
+            },
+            models,
+        });
+    });
+    await ctx.model.transform((editor) => {
+        const next = new Map();
+        const errors = [];
+        for (const { group, providerID, modelID, ref } of refs) {
+            const source = editor.get(providerID, modelID);
+            const provider = editor.provider.get(providerID)?.provider;
+            const apiID = source?.modelID ?? source?.id ?? modelID;
+            const profile = MODELS.find((model) => model.id === apiID && model.provider === group);
+            const sourcePackage = source?.package ?? provider?.package;
+            const supported = group === "openai"
+                ? sourcePackage === PROVIDER_PACKAGE ||
+                    sourcePackage === "@opencode/ai/providers/openai"
+                : sourcePackage === PACKAGES[group];
+            const error = !source || !provider
+                ? `reasoning-router: source model ${ref} not found; check wrap`
+                : !profile
+                    ? `reasoning-router: ${ref} API model ${apiID} is not a registered ${group} profile`
+                    : !supported
+                        ? `reasoning-router: ${ref} requires package ${PACKAGES[group]}${group === "openai" ? " or @opencode/ai/providers/openai" : ""}`
+                        : next.has(profile.id)
+                            ? `reasoning-router: duplicate wrap profile ${profile.id}`
+                            : undefined;
+            if (error)
+                errors.push(error);
+            if (!profile)
+                continue;
+            const id = profile.id;
+            if (next.has(id))
+                continue;
+            next.set(id, {
+                group,
+                providerID,
+                integrationID: provider?.integrationID ?? providerID,
+                authHeader: group === "openai" ? "authorization" : "x-api-key",
+            });
+            if (error)
+                continue;
+            const resolved = provider;
+            const settings = { ...resolved.settings, ...source.settings };
+            delete settings.transport;
+            editor.update(PROVIDER_ID, id, (alias) => Object.assign(alias, {
+                ...source,
+                id,
+                modelID: apiID,
+                providerID: PROVIDER_ID,
+                package: source.package ?? resolved.package,
+                name: profile.name,
+                transport: "http",
+                settings,
+                headers: { ...resolved.headers, ...source.headers },
+                body: { ...resolved.body, ...source.body },
+                variants: [],
+            }));
+        }
+        if (!errors.length)
+            for (const profile of MODELS)
+                if (!next.has(profile.id))
+                    editor.remove(PROVIDER_ID, profile.id);
+        aliases = next;
+        validationError = errors.length ? errors.join("; ") : undefined;
+    });
+    const onRequest = async (event) => {
+        if (validationError)
+            throw new Error(validationError);
+        const alias = aliases.get(event.model.id);
+        if (!alias)
+            throw new Error(`reasoning-router: alias ${event.model.id} is not configured in wrap`);
+        const incoming = event.request;
+        const authHeader = alias.authHeader;
+        if (!incoming.headers.get(authHeader)) {
+            const connection = await ctx.integration.connection.active(alias.integrationID);
+            const credential = connection && (await ctx.integration.connection.resolve(connection));
+            if (credential?.type === "oauth")
+                throw new Error(`reasoning-router: ${alias.providerID} uses OAuth, which wrap does not support yet; use an API key`);
+            if (credential?.type === "key")
+                incoming.headers.set(authHeader, alias.group === "openai"
+                    ? `Bearer ${credential.key}`
+                    : credential.key);
+        }
+        if (!incoming.headers.get(authHeader))
+            throw new Error(`reasoning-router: ${alias.providerID} has no API key; configure a source provider API key`);
+        if (event.kind !== "primary")
+            return;
+        const pathname = new URL(incoming.url).pathname;
+        if (!pathname.endsWith(alias.group === "openai" ? "/responses" : "/messages"))
+            throw new Error(`reasoning-router invalid_request (400): alias requires ${alias.group === "openai" ? "/responses" : "/messages"}`);
+        let exchange;
+        try {
+            exchange = await runtime.start(incoming, { session: valid(event.sessionID, SESSION), turnId: randomUUID() }, alias.group);
+        }
+        catch (cause) {
+            throw rejection(cause);
+        }
+        const outgoing = new Headers(exchange.headers);
+        outgoing.delete("content-length");
+        const request = new Request(exchange.url, {
+            method: "POST",
+            headers: outgoing,
+            body: exchange.body,
+            signal: exchange.signal,
+            ...(alias.group === "anthropic" ? { redirect: "manual" } : {}),
+        });
+        incoming.signal.addEventListener("abort", () => exchange.cancel(), {
+            once: true,
+        });
+        exchanges.set(request, exchange);
+        event.request = request;
+    };
+    const onResponse = (event) => {
+        const exchange = exchanges.get(event.request);
+        if (exchange === undefined)
+            return;
+        exchanges.delete(event.request);
+        try {
+            event.response = exchange.respond(event.response);
+        }
+        catch (cause) {
+            throw rejection(cause);
+        }
+    };
+    await ctx.session.hook("http.request", onRequest, {
+        providerID: PROVIDER_ID,
+    });
+    await ctx.session.hook("http.response", onResponse, {
+        providerID: PROVIDER_ID,
+    });
+    try {
+        await ctx.session.hook("experimental.ws.handshake", () => {
+            throw new Error('reasoning-router requires transport: http; remove providers["reasoning-router"].settings.transport');
+        }, { providerID: PROVIDER_ID });
+    }
+    catch {
+        /* Older hosts may not expose the experimental hook. */
+    }
+    return () => runtime.dispose();
+}

package/dist/plugin.d.ts

@@ -0,0 +1,7 @@
+import { setupV2 } from "./plugin-v2.js";
+export type { PluginOptions } from "./plugin-runtime.js";
+declare const plugin: {
+    id: string;
+    setup: typeof setupV2;
+};
+export default plugin;

package/dist/plugin.js

@@ -0,0 +1,6 @@
+import { setupV2 } from "./plugin-v2.js";
+const plugin = {
+    id: "reasoning-router",
+    setup: setupV2,
+};
+export default plugin;

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@reasoning-router/opencode",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Adaptive per-step reasoning effort for OpenCode V2",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=24.0.0 <25"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/robertn702/reasoning-router.git",
+    "directory": "packages/opencode"
+  },
+  "keywords": [
+    "opencode-plugin",
+    "opencode",
+    "reasoning-effort"
+  ],
+  "exports": {
+    ".": {
+      "@reasoning-router/source": "./src/plugin.ts",
+      "types": "./dist/plugin.d.ts",
+      "default": "./dist/plugin.js"
+    },
+    "./plugin": {
+      "@reasoning-router/source": "./src/plugin.ts",
+      "types": "./dist/plugin.d.ts",
+      "default": "./dist/plugin.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@reasoning-router/classifiers": "^0.1.0",
+    "@reasoning-router/core": "^0.1.0",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@opencode/plugin": "2.0.18",
+    "@opencode/schema": "2.0.18"
+  }
+}