@open-cr-agent/runtime-direct 0.5.0 → 0.6.0

package/dist/effort.d.ts

@@ -2,9 +2,9 @@ import type { AppliedSettings, Effort, Sampling } from "@open-cr-agent/core";
 import type { CallParams } from "./openai.js";
 export type EffortStyle = "openai" | "openrouter";
 export declare class EffortLedger {
-    private readonly sampling;
     private readonly refused;
     private readonly applied;
+    private readonly sampling;
     constructor(sampling: Sampling);
     params(agent: string, effort: Effort | undefined, model: string, style?: EffortStyle): CallParams;
     refuse(agent: string, model: string): void;

package/dist/effort.js

@@ -4,11 +4,11 @@
 // "none" sends no sampling settings, even after its endpoint refused the
 // effort: the agent's calls stay alike within a run.
 export class EffortLedger {
-    sampling;
     // Models whose endpoint refused the effort parameter: later calls go
     // without it instead of paying for another refusal.
     refused = new Set();
     applied = new Map();
+    sampling;
     constructor(sampling) {
         this.sampling = sampling;
     }

package/dist/loop.d.ts

@@ -1,5 +1,4 @@
-import type { ModelPrice, ReviewContext, ToolDefinition, Usage } from "@open-cr-agent/core";
-import { type AttemptOutcome } from "@open-cr-agent/core/internal";
+import { type AttemptOutcome, type ModelPrice, type ReviewContext, type ToolDefinition, type Usage } from "@open-cr-agent/core";
 import { type CallParams, type Endpoint } from "./openai.js";
 export interface LoopInput {
     endpoint: Endpoint;

package/dist/loop.js

@@ -1,4 +1,4 @@
-import { addUsage, emptyUsage, errorMessage, REVIEW_TOOLS, } from "@open-cr-agent/core/internal";
+import { addUsage, emptyUsage, errorMessage, REVIEW_TOOLS, } from "@open-cr-agent/core";
 import { chat, toolSpec, withoutEffort, } from "./openai.js";
 // The agent loop: ask the model, run the tools it calls against the review
 // context, hand the results back, until it calls task_done, answers without

package/dist/openai.d.ts

@@ -1,5 +1,4 @@
-import type { Effort, ModelPrice, ToolDefinition, Usage } from "@open-cr-agent/core";
-import { type QuotaError } from "@open-cr-agent/core/internal";
+import { type Effort, type ModelPrice, type QuotaError, type ToolDefinition, type Usage } from "@open-cr-agent/core";
 import { z } from "zod";
 declare const toolCallSchema: z.ZodObject<{
     id: z.ZodString;
@@ -46,7 +45,7 @@ export interface ChatRequest {
     };
 }
 export type CallParams = Pick<ChatRequest, "temperature" | "seed" | "reasoning_effort" | "reasoning">;
-export interface ChatError {
+interface ChatError {
     message: string;
     retryable: boolean;
     quota?: QuotaError;
@@ -64,7 +63,6 @@ export type ChatResponse = ({
 }) & {
     effortDropped?: true;
 };
-export declare const TRANSIENT_RETRY_MS = 1000;
 export declare function toolSpec(tool: ToolDefinition): ToolSpec;
 export declare function chat(endpoint: Endpoint, request: ChatRequest, price: ModelPrice, signal: AbortSignal): Promise<ChatResponse>;
 export declare function withoutEffort<T extends CallParams>(params: T): T;

package/dist/openai.js

@@ -1,4 +1,5 @@
-import { errorMessage, parseQuotaError, sleep, withoutSecrets, } from "@open-cr-agent/core/internal";
+import { setTimeout } from "node:timers/promises";
+import { errorMessage, parseQuotaError, withoutSecrets, } from "@open-cr-agent/core";
 import { z } from "zod";
 // The subset of the OpenAI chat completions protocol the loop needs: one
 // choice, its text and tool calls, and the token counts. Anything else an
@@ -7,15 +8,15 @@ const toolCallSchema = z.object({
     id: z.string(),
     function: z.object({ name: z.string(), arguments: z.string() }),
 });
+const choiceSchema = z.object({
+    message: z.object({
+        content: z.string().nullable().optional(),
+        tool_calls: z.array(toolCallSchema).optional(),
+    }),
+});
 const completionSchema = z.object({
-    choices: z
-        .array(z.object({
-        message: z.object({
-            content: z.string().nullable().optional(),
-            tool_calls: z.array(toolCallSchema).optional(),
-        }),
-    }))
-        .min(1),
+    // At least one: the first is the answer.
+    choices: z.tuple([choiceSchema], choiceSchema),
     usage: z
         .object({
         prompt_tokens: z.number().optional(),
@@ -37,7 +38,7 @@ const EFFORT_PARAMETER = /\breasoning(?:_effort)?\b/i;
 const BODY_EXCERPT = 300;
 // A transient failure is sent once more after this pause; a second failure
 // goes to the failback, which decides what it means for the model.
-export const TRANSIENT_RETRY_MS = 1_000;
+const TRANSIENT_RETRY_MS = 1_000;
 export function toolSpec(tool) {
     const { $schema: _, ...parameters } = z.toJSONSchema(tool.inputSchema);
     return {
@@ -70,7 +71,7 @@ async function sendRetrying(endpoint, request, price, signal) {
     const first = await send(endpoint, request, price, signal);
     if (first.ok || !first.error.transient)
         return first;
-    await sleep(TRANSIENT_RETRY_MS, signal);
+    await setTimeout(TRANSIENT_RETRY_MS, undefined, { signal }).catch(() => undefined);
     if (signal.aborted)
         return first;
     return send(endpoint, request, price, signal);
@@ -92,7 +93,14 @@ async function send(endpoint, request, price, signal) {
     catch (error) {
         if (signal.aborted)
             return { ok: false, error: { message: "cancelled", retryable: false } };
-        return { ok: false, error: { message: errorMessage(error), retryable: true, transient: true } };
+        return {
+            ok: false,
+            error: {
+                message: errorMessage(error),
+                retryable: true,
+                transient: true,
+            },
+        };
     }
     const body = await response.text().catch(() => "");
     if (!response.ok)
@@ -112,7 +120,7 @@ async function send(endpoint, request, price, signal) {
     if (!parsed.success) {
         return { ok: false, error: malformed("answered without a chat completion", body, secrets) };
     }
-    const choice = parsed.data.choices[0];
+    const [choice] = parsed.data.choices;
     return {
         ok: true,
         content: choice.message.content ?? "",

package/dist/runtime.d.ts

@@ -3,19 +3,22 @@ export interface DirectRuntimeOptions extends RuntimeOptions {
     fetch?: typeof fetch;
 }
 export declare class DirectRuntime implements AgentRuntime {
-    private readonly options;
     readonly name = "direct";
     readonly sampling: AppliedSampling;
-    private readonly health;
+    private readonly chains;
     private readonly tools;
     private readonly fetch;
     private readonly efforts;
+    private readonly options;
     constructor(options: DirectRuntimeOptions);
     appliedTo(agent: string): AppliedSettings | undefined;
     runTask(spec: AgentTaskSpec, signal: AbortSignal): AsyncIterable<AgentEvent>;
     complete(request: CompletionRequest, signal: AbortSignal): Promise<CompletionResult>;
+    private attemptTask;
+    private attemptCompletion;
     private unreachable;
     private call;
+    private declared;
     private target;
 }
 //# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.js

@@ -1,5 +1,4 @@
-import { OcraError, } from "@open-cr-agent/core";
-import { callChain, completeWithFailback, MAX_AGENT_STEPS, ModelHealth, parseModel, proxiedFetch, RESUME_MESSAGE, reviewTools, withFailback, } from "@open-cr-agent/core/internal";
+import { ChainRunner, MAX_AGENT_STEPS, OcraError, parseModel, proxiedFetch, RESUME_MESSAGE, reviewTools, } from "@open-cr-agent/core";
 import { EffortLedger } from "./effort.js";
 import { runLoop } from "./loop.js";
 // Talks to the declared OpenAI-compatible endpoints itself: no OpenCode
@@ -7,14 +6,14 @@ import { runLoop } from "./loop.js";
 // a provider that is not declared in configuration is refused, since the
 // runtime knows no other address to send code to.
 export class DirectRuntime {
-    options;
     name = "direct";
     // The chat completions protocol takes both settings.
     sampling;
-    health = new ModelHealth();
+    chains;
     tools;
     fetch;
     efforts;
+    options;
     constructor(options) {
         this.options = options;
         this.tools = [...reviewTools, ...options.tools];
@@ -25,61 +24,47 @@ export class DirectRuntime {
             ...(seed === undefined ? {} : { seed }),
         };
         this.efforts = new EffortLedger(this.sampling);
+        this.chains = new ChainRunner(options.models, {
+            refuse: (chain) => this.unreachable(chain),
+            task: (model, spec, signal, onUsage) => this.attemptTask(model, spec, signal, onUsage),
+            complete: (model, request, signal) => this.attemptCompletion(model, request, signal),
+        });
     }
     appliedTo(agent) {
         return this.efforts.appliedTo(agent);
     }
-    async *runTask(spec, signal) {
-        const chain = callChain(this.options.models, spec.modelTier, spec.models);
-        const refused = chain.length === 0 ? noModel(spec.modelTier) : this.unreachable(chain);
-        if (refused) {
-            yield { type: "error", taskId: spec.taskId, error: refused.message, retryable: false };
-            return;
-        }
-        yield* withFailback({
-            taskId: spec.taskId,
-            tier: spec.modelTier,
-            ...(spec.models?.length ? { agent: spec.reviewer } : {}),
-            chain,
-            health: this.health,
+    runTask(spec, signal) {
+        return this.chains.runTask(spec, signal);
+    }
+    complete(request, signal) {
+        return this.chains.complete(request, signal);
+    }
+    attemptTask(model, spec, signal, onUsage) {
+        return runLoop({
+            ...this.target(model),
+            ...this.call({ agent: spec.reviewer, effort: spec.effort, model }),
+            system: spec.systemPrompt,
+            user: spec.userPrompt,
+            tools: this.tools,
+            context: spec.context,
+            maxSteps: MAX_AGENT_STEPS,
+            resume: RESUME_MESSAGE,
+            timeoutMs: spec.timeoutMs,
             signal,
-            attempt: (model, onUsage) => runLoop({
-                ...this.target(model),
-                ...this.call({ agent: spec.reviewer, effort: spec.effort, model }),
-                system: spec.systemPrompt,
-                user: spec.userPrompt,
-                tools: this.tools,
-                context: spec.context,
-                maxSteps: MAX_AGENT_STEPS,
-                resume: RESUME_MESSAGE,
-                timeoutMs: spec.timeoutMs,
-                signal,
-                onUsage,
-            }),
+            onUsage,
         });
     }
-    async complete(request, signal) {
-        const chain = callChain(this.options.models, request.tier, request.models);
-        const refused = chain.length === 0 ? noModel(request.tier) : this.unreachable(chain);
-        if (refused)
-            throw refused;
-        return completeWithFailback({
-            tier: request.tier,
-            ...(request.models?.length ? { agent: request.agent ?? request.tier } : {}),
-            chain,
-            health: this.health,
+    attemptCompletion(model, request, signal) {
+        return runLoop({
+            ...this.target(model),
+            ...this.call({ agent: request.agent ?? request.tier, effort: request.effort, model }),
+            system: request.system,
+            user: request.user,
+            tools: [],
+            context: NO_CONTEXT,
+            maxSteps: 1,
+            timeoutMs: request.timeoutMs,
             signal,
-            attempt: (model) => runLoop({
-                ...this.target(model),
-                ...this.call({ agent: request.agent ?? request.tier, effort: request.effort, model }),
-                system: request.system,
-                user: request.user,
-                tools: [],
-                context: NO_CONTEXT,
-                maxSteps: 1,
-                timeoutMs: request.timeoutMs,
-                signal,
-            }),
         });
     }
     // Why a chain cannot be served, before any request: a provider the
@@ -87,16 +72,12 @@ export class DirectRuntime {
     // variable that is not set.
     unreachable(chain) {
         for (const model of chain) {
-            const { providerID, modelID } = parseModel(model);
-            const provider = this.options.providers?.[providerID];
-            if (!provider) {
-                return new OcraError("CONFIG_INVALID", `"${model}" names no provider declared in configuration; the direct runtime reaches only declared OpenAI-compatible endpoints (use the opencode runtime for ${providerID})`);
-            }
-            if (!provider.models[modelID]) {
-                return new OcraError("CONFIG_INVALID", `"${model}" has no price in the declaration of provider "${providerID}"`);
-            }
-            if (provider.apiKeyEnv && !this.options.env[provider.apiKeyEnv]) {
-                return new OcraError("CONFIG_CREDENTIALS_MISSING", `No API key for provider "${providerID}": set ${provider.apiKeyEnv}`);
+            const declared = this.declared(model);
+            if (declared instanceof OcraError)
+                return declared;
+            const { apiKeyEnv } = declared.provider;
+            if (apiKeyEnv && !this.options.env[apiKeyEnv]) {
+                return new OcraError("CONFIG_CREDENTIALS_MISSING", `No API key for provider "${parseModel(model).providerID}": set ${apiKeyEnv}`);
             }
         }
         return undefined;
@@ -111,9 +92,25 @@ export class DirectRuntime {
             onEffortRefused: () => this.efforts.refuse(agent, model),
         };
     }
-    target(model) {
+    // A model's provider and price, from the configuration's declaration.
+    declared(model) {
         const { providerID, modelID } = parseModel(model);
         const provider = this.options.providers?.[providerID];
+        if (!provider) {
+            return new OcraError("CONFIG_INVALID", `"${model}" names no provider declared in configuration; the direct runtime reaches only declared OpenAI-compatible endpoints (use the opencode runtime for ${providerID})`);
+        }
+        const price = provider.models[modelID];
+        if (!price) {
+            return new OcraError("CONFIG_INVALID", `"${model}" has no price in the declaration of provider "${providerID}"`);
+        }
+        return { provider, modelID, price };
+    }
+    // Only for a model unreachable() let through, so declared() cannot fail.
+    target(model) {
+        const declared = this.declared(model);
+        if (declared instanceof OcraError)
+            throw declared;
+        const { provider, modelID, price } = declared;
         const key = provider.apiKeyEnv ? this.options.env[provider.apiKeyEnv] : undefined;
         return {
             endpoint: {
@@ -122,7 +119,7 @@ export class DirectRuntime {
                 fetch: this.fetch,
             },
             model: modelID,
-            price: provider.models[modelID],
+            price,
         };
     }
 }
@@ -132,7 +129,4 @@ const NO_CONTEXT = {
     readDiff: () => undefined,
     searchCode: async () => [],
 };
-function noModel(tier) {
-    return new OcraError("CONFIG_INVALID", `No ${tier} model configured (set OCRA_MODEL_${tier.toUpperCase()} or models.${tier})`);
-}
 //# sourceMappingURL=runtime.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-cr-agent/runtime-direct",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Agent runtime for Open-CR-Agent that calls OpenAI-compatible endpoints directly",
   "keywords": [
     "code-review",
@@ -33,7 +33,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@open-cr-agent/core": "0.5.0",
+    "@open-cr-agent/core": "0.6.0",
     "zod": "^4.6.5"
   },
   "publishConfig": {