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

package/README.md

@@ -1,3 +1,3 @@
 # @open-cr-agent/runtime-direct
 
-The agent runtime of [Open-CR-Agent](https://github.com/jma49/Open-CR-Agent), the multi-agent code reviewer, that calls the OpenAI-compatible model endpoints declared in its configuration itself, with nothing else on the network. Most users want [`@open-cr-agent/cli`](https://www.npmjs.com/package/@open-cr-agent/cli), which provides the `ocra` command and installs this package; see the [manual](https://ocra.majincheng.com). All `@open-cr-agent` packages are released together at one version. Apache-2.0.
+The agent runtime of [Open-CR-Agent](https://github.com/jma49/Open-CR-Agent), the multi-agent code reviewer, that calls the OpenAI-compatible model endpoints declared in its configuration itself, with nothing else on the network. Most users want [`@open-cr-agent/cli`](https://www.npmjs.com/package/@open-cr-agent/cli), which provides the `ocra` command and installs this package; see the [manual](https://ocracloud.com). All `@open-cr-agent` packages are released together at one version. Apache-2.0.

package/dist/effort.d.ts

@@ -0,0 +1,14 @@
+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;
+    constructor(sampling: Sampling);
+    params(agent: string, effort: Effort | undefined, model: string, style?: EffortStyle): CallParams;
+    refuse(agent: string, model: string): void;
+    appliedTo(agent: string): AppliedSettings | undefined;
+    private record;
+}
+//# sourceMappingURL=effort.d.ts.map

package/dist/effort.js

@@ -0,0 +1,49 @@
+// What each call sends besides the conversation, and what the run applied
+// per agent (ADR-0025). Reasoning models refuse a temperature (OpenAI) or
+// need their own (Anthropic), so a call that asks for an effort other than
+// "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();
+    constructor(sampling) {
+        this.sampling = sampling;
+    }
+    params(agent, effort, model, style = "openai") {
+        if (effort === undefined)
+            return { ...this.sampling };
+        const keepsSampling = effort === "none";
+        const sends = !this.refused.has(model);
+        this.record(agent, sends, keepsSampling ? [] : requested(this.sampling));
+        return {
+            ...(keepsSampling ? this.sampling : {}),
+            ...(sends ? effortParam(effort, style) : {}),
+        };
+    }
+    refuse(agent, model) {
+        this.refused.add(model);
+        this.record(agent, false, []);
+    }
+    appliedTo(agent) {
+        const applied = this.applied.get(agent);
+        return applied && { ...applied };
+    }
+    record(agent, sent, notApplied) {
+        const before = this.applied.get(agent);
+        const left = [...new Set([...(before?.notApplied ?? []), ...notApplied])];
+        this.applied.set(agent, {
+            effort: (before?.effort ?? true) && sent,
+            ...(left.length > 0 ? { notApplied: left } : {}),
+        });
+    }
+}
+function effortParam(effort, style) {
+    return style === "openrouter" ? { reasoning: { effort } } : { reasoning_effort: effort };
+}
+function requested(sampling) {
+    return ["temperature", "seed"].filter((key) => sampling[key] !== undefined);
+}
+//# sourceMappingURL=effort.js.map

package/dist/loop.d.ts

@@ -1,6 +1,6 @@
-import type { ModelPrice, ReviewContext, Sampling, ToolDefinition, Usage } from "@open-cr-agent/core";
+import type { ModelPrice, ReviewContext, ToolDefinition, Usage } from "@open-cr-agent/core";
 import { type AttemptOutcome } from "@open-cr-agent/core/internal";
-import { type Endpoint } from "./openai.js";
+import { type CallParams, type Endpoint } from "./openai.js";
 export interface LoopInput {
     endpoint: Endpoint;
     model: string;
@@ -12,7 +12,8 @@ export interface LoopInput {
     maxSteps: number;
     resume?: string;
     timeoutMs: number;
-    sampling?: Sampling;
+    params?: CallParams;
+    onEffortRefused?: () => void;
     signal: AbortSignal;
     onUsage?: (spent: Usage) => void;
 }

package/dist/loop.js

@@ -1,5 +1,5 @@
 import { addUsage, emptyUsage, errorMessage, REVIEW_TOOLS, } from "@open-cr-agent/core/internal";
-import { chat, toolSpec } from "./openai.js";
+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
 // tools, or runs out of steps. The model reaches nothing but these tools and
@@ -23,14 +23,19 @@ export async function runLoop(input) {
     };
     const texts = [];
     let done = false;
+    let params = input.params ?? {};
     while (outcome.steps < input.maxSteps) {
         const response = await chat(input.endpoint, {
             model: input.model,
             messages,
             ...(specs.length > 0 ? { tools: specs } : {}),
-            ...input.sampling,
+            ...params,
         }, input.price, signal);
         outcome.steps += 1;
+        if (response.effortDropped) {
+            params = withoutEffort(params);
+            input.onEffortRefused?.();
+        }
         if (!response.ok) {
             outcome.error = timeout.aborted
                 ? { message: `timed out after ${Math.round(input.timeoutMs / 1000)}s`, retryable: true }

package/dist/openai.d.ts

@@ -1,4 +1,4 @@
-import type { ModelPrice, ToolDefinition, Usage } from "@open-cr-agent/core";
+import type { Effort, ModelPrice, ToolDefinition, Usage } from "@open-cr-agent/core";
 import { type QuotaError } from "@open-cr-agent/core/internal";
 import { z } from "zod";
 declare const toolCallSchema: z.ZodObject<{
@@ -40,14 +40,20 @@ export interface ChatRequest {
     tools?: readonly ToolSpec[];
     temperature?: number;
     seed?: number;
+    reasoning_effort?: Effort;
+    reasoning?: {
+        effort: Effort;
+    };
 }
+export type CallParams = Pick<ChatRequest, "temperature" | "seed" | "reasoning_effort" | "reasoning">;
 export interface ChatError {
     message: string;
     retryable: boolean;
     quota?: QuotaError;
     transient?: boolean;
+    effortRefused?: boolean;
 }
-export type ChatResponse = {
+export type ChatResponse = ({
     ok: true;
     content: string;
     toolCalls: ToolCall[];
@@ -55,9 +61,12 @@ export type ChatResponse = {
 } | {
     ok: false;
     error: ChatError;
+}) & {
+    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;
 export {};
 //# sourceMappingURL=openai.d.ts.map

package/dist/openai.js

@@ -30,6 +30,8 @@ const errorBodySchema = z.object({
     error: z.object({ message: z.string(), code: z.number().optional() }),
 });
 const AUTH_STATUS = new Set([401, 403]);
+// How an endpoint names the effort parameters in a 400 that refuses them.
+const EFFORT_PARAMETER = /\breasoning(?:_effort)?\b/i;
 // How much of an error body an error message keeps: enough to diagnose, not
 // a page of HTML.
 const BODY_EXCERPT = 300;
@@ -43,10 +45,28 @@ export function toolSpec(tool) {
         function: { name: tool.name, description: tool.description, parameters },
     };
 }
-// One request to the endpoint, sent a second time when the first failed in
-// a way a moment may cure. Only the key named for this provider goes out,
-// and only to its base URL.
+// One request to the endpoint. A refused effort parameter is not the model's
+// failure: the request goes once more without it, so the review still runs
+// and the failback chain does not move.
 export async function chat(endpoint, request, price, signal) {
+    const first = await sendRetrying(endpoint, request, price, signal);
+    if (first.ok || !first.error.effortRefused || !hasEffort(request))
+        return first;
+    return {
+        ...(await sendRetrying(endpoint, withoutEffort(request), price, signal)),
+        effortDropped: true,
+    };
+}
+function hasEffort(params) {
+    return params.reasoning_effort !== undefined || params.reasoning !== undefined;
+}
+export function withoutEffort(params) {
+    const { reasoning_effort: _effort, reasoning: _reasoning, ...rest } = params;
+    return rest;
+}
+// Sent a second time when the first failed in a way a moment may cure. Only
+// the key named for this provider goes out, and only to its base URL.
+async function sendRetrying(endpoint, request, price, signal) {
     const first = await send(endpoint, request, price, signal);
     if (first.ok || !first.error.transient)
         return first;
@@ -121,6 +141,7 @@ function failure(response, body, secrets, reportedCode) {
     return {
         message,
         retryable: !AUTH_STATUS.has(status),
+        ...(status === 400 && EFFORT_PARAMETER.test(body) ? { effortRefused: true } : {}),
         ...(quota ? { quota } : {}),
         ...(!quota && (status >= 500 || status === 408) ? { transient: true } : {}),
     };

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import { type AgentEvent, type AgentRuntime, type AgentTaskSpec, type AppliedSampling, type CompletionRequest, type CompletionResult, type RuntimeOptions } from "@open-cr-agent/core";
+import { type AgentEvent, type AgentRuntime, type AgentTaskSpec, type AppliedSampling, type AppliedSettings, type CompletionRequest, type CompletionResult, type RuntimeOptions } from "@open-cr-agent/core";
 export interface DirectRuntimeOptions extends RuntimeOptions {
     fetch?: typeof fetch;
 }
@@ -9,10 +9,13 @@ export declare class DirectRuntime implements AgentRuntime {
     private readonly health;
     private readonly tools;
     private readonly fetch;
+    private readonly efforts;
     constructor(options: DirectRuntimeOptions);
+    appliedTo(agent: string): AppliedSettings | undefined;
     runTask(spec: AgentTaskSpec, signal: AbortSignal): AsyncIterable<AgentEvent>;
     complete(request: CompletionRequest, signal: AbortSignal): Promise<CompletionResult>;
     private unreachable;
+    private call;
     private target;
 }
 //# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.js

@@ -1,5 +1,6 @@
 import { OcraError, } from "@open-cr-agent/core";
-import { completeWithFailback, MAX_AGENT_STEPS, ModelHealth, parseModel, proxiedFetch, RESUME_MESSAGE, reviewTools, withFailback, } from "@open-cr-agent/core/internal";
+import { callChain, completeWithFailback, MAX_AGENT_STEPS, ModelHealth, parseModel, proxiedFetch, RESUME_MESSAGE, reviewTools, withFailback, } from "@open-cr-agent/core/internal";
+import { EffortLedger } from "./effort.js";
 import { runLoop } from "./loop.js";
 // Talks to the declared OpenAI-compatible endpoints itself: no OpenCode
 // process, no catalog fetch, no package install, nothing on disk. A model of
@@ -13,6 +14,7 @@ export class DirectRuntime {
     health = new ModelHealth();
     tools;
     fetch;
+    efforts;
     constructor(options) {
         this.options = options;
         this.tools = [...reviewTools, ...options.tools];
@@ -22,9 +24,13 @@ export class DirectRuntime {
             ...(temperature === undefined ? {} : { temperature }),
             ...(seed === undefined ? {} : { seed }),
         };
+        this.efforts = new EffortLedger(this.sampling);
+    }
+    appliedTo(agent) {
+        return this.efforts.appliedTo(agent);
     }
     async *runTask(spec, signal) {
-        const chain = this.options.models[spec.modelTier] ?? [];
+        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 };
@@ -33,11 +39,13 @@ export class DirectRuntime {
         yield* withFailback({
             taskId: spec.taskId,
             tier: spec.modelTier,
+            ...(spec.models?.length ? { agent: spec.reviewer } : {}),
             chain,
             health: this.health,
             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,
@@ -45,31 +53,31 @@ export class DirectRuntime {
                 maxSteps: MAX_AGENT_STEPS,
                 resume: RESUME_MESSAGE,
                 timeoutMs: spec.timeoutMs,
-                sampling: this.sampling,
                 signal,
                 onUsage,
             }),
         });
     }
     async complete(request, signal) {
-        const chain = this.options.models[request.tier] ?? [];
+        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,
             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,
-                sampling: this.sampling,
                 signal,
             }),
         });
@@ -93,6 +101,16 @@ export class DirectRuntime {
         }
         return undefined;
     }
+    // What one attempt sends besides the conversation, and where a refused
+    // effort is recorded.
+    call({ agent, effort, model }) {
+        const { providerID } = parseModel(model);
+        const style = this.options.providers?.[providerID]?.effort;
+        return {
+            params: this.efforts.params(agent, effort, model, style),
+            onEffortRefused: () => this.efforts.refuse(agent, model),
+        };
+    }
     target(model) {
         const { providerID, modelID } = parseModel(model);
         const provider = this.options.providers?.[providerID];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-cr-agent/runtime-direct",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Agent runtime for Open-CR-Agent that calls OpenAI-compatible endpoints directly",
   "keywords": [
     "code-review",
@@ -8,7 +8,7 @@
     "agents"
   ],
   "license": "Apache-2.0",
-  "homepage": "https://ocra.majincheng.com",
+  "homepage": "https://ocracloud.com",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jma49/Open-CR-Agent.git",
@@ -33,7 +33,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@open-cr-agent/core": "0.3.0",
+    "@open-cr-agent/core": "0.5.0",
     "zod": "^4.6.5"
   },
   "publishConfig": {