@sagentlab/navarch-runtime 0.1.122 → 0.1.123

package/dist/agent-model.cjs

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAgentModelUnavailable = detectAgentModelUnavailable;
+/**
+ * OpenCode's words for "no configured provider serves this model": its JSON
+ * error event (`{"type":"error","error":{"type":"provider.no-route",
+ * "message":"Model unavailable: opencode-go/deepseek-v4.1-flash"}}`) and the
+ * matching ERROR log line (`"Failed to drain Session" cause
+ * "SessionRunnerModel.ModelUnavailableError: Model unavailable: ..."`).
+ * Verified against OpenCode 2.0.29 on flotilla-agent-1435 (2026-10-19).
+ */
+const NO_ROUTE_PATTERN = /\bprovider\.no-route\b|\bModelUnavailableError\b|\bModel unavailable:/i;
+const MODEL_NAME_PATTERN = /\bModel unavailable:\s*([^\s"'\\,;)]+)/i;
+function clip(text) {
+    const trimmed = text.trim().replace(/\s+/g, " ");
+    return trimmed.length > 300 ? `${trimmed.slice(0, 299)}…` : trimmed;
+}
+function failure(detail) {
+    const model = detail.match(MODEL_NAME_PATTERN)?.[1]?.replace(/[.:]+$/, "") ?? null;
+    return { model, detail: clip(detail) };
+}
+/** Messages of the CLI's own error events on stdout; never assistant text events. */
+function errorEventMessages(stdout) {
+    const messages = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        if (!line.trim().startsWith("{"))
+            continue;
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (event.type !== "error" && event.type !== "session.error")
+            continue;
+        const properties = event.properties;
+        const error = (event.error ?? properties?.error);
+        if (typeof error === "string") {
+            messages.push(error);
+            continue;
+        }
+        const message = error?.data?.message ?? error?.message;
+        const kind = [error?.type, error?.name].filter((value) => typeof value === "string").join(" ");
+        const text = [kind, typeof message === "string" ? message : ""].filter(Boolean).join(": ");
+        if (text)
+            messages.push(text);
+    }
+    return messages;
+}
+/**
+ * Detects a turn the coding agent CLI could not start because the model it
+ * was told to use has no route on this machine (OpenCode `provider.no-route`).
+ * Like a dead login (agent-auth.cts), every task the machine claims then fails
+ * the same way within seconds, so the control plane requeues the task without
+ * spending a retry and pauses the machine until the model is fixed.
+ *
+ * Matched only against CLI-authored channels — OpenCode's error events and
+ * ERROR log lines — and only for a turn that failed or produced no report, so
+ * an agent writing about this very error cannot pause its own machine.
+ */
+function detectAgentModelUnavailable(result) {
+    if (result.killedByLeaseLoss || result.timedOut || result.capacityError || result.authError)
+        return null;
+    if (result.exitCode === 0 && result.reportText)
+        return null;
+    for (const message of errorEventMessages(result.stdout)) {
+        if (NO_ROUTE_PATTERN.test(message))
+            return failure(message);
+    }
+    if (result.exitCode === 0)
+        return null;
+    for (const line of result.stderr.split(/\r?\n/)) {
+        if (/ERROR/.test(line) && NO_ROUTE_PATTERN.test(line)) {
+            const cause = line.match(/Model unavailable:[^"\n]*/i)?.[0];
+            return failure(cause ?? line);
+        }
+    }
+    return null;
+}

package/dist/exit-conditions.cjs

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AGENT_AUTH_FAILURE_PREFIX = void 0;
+exports.AGENT_MODEL_UNAVAILABLE_PREFIX = exports.AGENT_AUTH_FAILURE_PREFIX = void 0;
 exports.agentAuthFailureReport = agentAuthFailureReport;
+exports.agentModelUnavailableReport = agentModelUnavailableReport;
 exports.parseClaudeJsonResult = parseClaudeJsonResult;
 exports.extractUsageFromClaudeJson = extractUsageFromClaudeJson;
 exports.parseCodexJsonEvents = parseCodexJsonEvents;
@@ -10,6 +11,7 @@ exports.extractFinalMessageFromCodexEvents = extractFinalMessageFromCodexEvents;
 exports.leadingVerificationVerdict = leadingVerificationVerdict;
 exports.leadWithReviewFixMarker = leadWithReviewFixMarker;
 exports.leadWithReviewAttestation = leadWithReviewAttestation;
+exports.failureOutputText = failureOutputText;
 exports.mapExitCondition = mapExitCondition;
 /**
  * Leading text of every report for a turn the coding agent CLI refused because
@@ -24,6 +26,19 @@ function agentAuthFailureReport(detail) {
     return `${exports.AGENT_AUTH_FAILURE_PREFIX}: ${detail} ` +
         "Log the coding agent in again on this machine (`claude /login`, `codex login`, an interactive `agy` session, or open `muse` and run `/login`), then resume the agent.";
 }
+/**
+ * Leading text of every report for a turn the coding agent CLI could not start
+ * because the model it was given has no route on this machine (agent-model.cts,
+ * OpenCode `provider.no-route`). The control plane recognizes it and, as for a
+ * dead login, requeues the task without spending a retry while pausing this
+ * machine's claims (lib/navarch/failure-attribution.ts
+ * `provider.model_unavailable`).
+ */
+exports.AGENT_MODEL_UNAVAILABLE_PREFIX = "Coding agent model unavailable";
+function agentModelUnavailableReport(detail) {
+    return `${exports.AGENT_MODEL_UNAVAILABLE_PREFIX}: ${detail} ` +
+        "Make that model reachable from the coding agent on this machine (log in to its provider, e.g. `opencode auth login`, or update the CLI), or connect the agent with a model it can reach, then resume the agent.";
+}
 /**
  * Best-effort parse of `claude -p --output-format json` (or `stream-json`,
  * whose last result record has the same shape) stdout into the assumed
@@ -298,6 +313,47 @@ function declaresBuildFailure(report) {
     const firstLine = report.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
     return /^(?:Build|Task) outcome:[*_`~]*\s*[*_`~]*(?:FAILED|BLOCKED)(?![a-z0-9_])/i.test(firstLine.replace(/^(?:#{1,6}\s+|>\s*|[*_`~]+\s*)+/, ""));
 }
+/**
+ * A CLI-authored error line: a JSON error event (OpenCode/Codex `error`,
+ * `session.error`, `turn.failed`), an ERROR/FATAL log line, or a leading
+ * `error:`/`fatal:`. Case-sensitive on the log levels so prose saying "error"
+ * stays where it was.
+ */
+function isFailureLine(line) {
+    return /(?:^|[^A-Za-z])(?:ERROR|FATAL)(?:[^A-Za-z]|$)/.test(line) ||
+        /"type"\s*:\s*"(?:error|session\.error|turn\.failed)"|^\s*(?:error|fatal)\b\s*[:\[]/i.test(line);
+}
+/** A JSON error event on stdout; text and tool events never qualify, whatever they say. */
+function isErrorEventLine(line) {
+    if (!line.startsWith("{"))
+        return false;
+    try {
+        const type = JSON.parse(line)?.type;
+        return type === "error" || type === "session.error" || type === "turn.failed";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The failure output of a CLI that exited badly, error lines first. OpenCode
+ * prints its INFO startup log ("cli starting ... serve --stdio") ahead of the
+ * real error and puts its JSON error event on stdout, so summarizing stderr
+ * from the top showed only the INFO lines on the board (2026-10-19). The JSON
+ * error events on stdout are CLI-authored, unlike its text events, so they are
+ * safe to lift into the summary.
+ */
+function failureOutputText(stdout, stderr) {
+    const stdoutErrors = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(isErrorEventLine);
+    const lines = [...stdoutErrors, ...stderr.split(/\r?\n/)].map((line) => line.trim()).filter(Boolean);
+    const errors = lines.filter(isFailureLine);
+    if (errors.length === 0)
+        return stderr;
+    return [...errors, ...lines.filter((line) => !isFailureLine(line))].join("\n");
+}
 function summarize(text, maxLen = 500) {
     const trimmed = text.trim();
     if (!trimmed)
@@ -344,6 +400,14 @@ function mapExitCondition(result) {
             evidenceUrls,
         };
     }
+    if (result.modelUnavailableError) {
+        return {
+            leaseOutcome: "failed",
+            exitStatus: "failed",
+            reportSummary: summarize(agentModelUnavailableReport(result.modelUnavailableError)),
+            evidenceUrls,
+        };
+    }
     if (result.timedOut) {
         return {
             leaseOutcome: "failed",
@@ -362,7 +426,7 @@ function mapExitCondition(result) {
         return {
             leaseOutcome: "failed",
             exitStatus: "crashed",
-            reportSummary: summarize(result.stderr) || "Adapter process crashed before exiting.",
+            reportSummary: summarize(failureOutputText(result.stdout, result.stderr)) || "Adapter process crashed before exiting.",
             evidenceUrls,
         };
     }
@@ -373,7 +437,7 @@ function mapExitCondition(result) {
         return {
             leaseOutcome: "failed",
             exitStatus: "failed",
-            reportSummary: summarize(parsedJson?.result || result.stderr || result.stdout) ||
+            reportSummary: summarize(parsedJson?.result || failureOutputText(result.stdout, result.stderr) || result.stdout) ||
                 `Adapter exited with code ${result.exitCode}.`,
             evidenceUrls,
         };

package/dist/session.cjs

@@ -31,6 +31,7 @@ const lease_heartbeat_cjs_1 = require("./lease-heartbeat.cjs");
 const completion_retry_cjs_1 = require("./completion-retry.cjs");
 const adapter_capacity_cjs_1 = require("./adapter-capacity.cjs");
 const agent_auth_cjs_1 = require("./agent-auth.cjs");
+const agent_model_cjs_1 = require("./agent-model.cjs");
 const browser_evidence_cjs_1 = require("./browser-evidence.cjs");
 /** Filename the generated platform MCP config is written under inside the session metadata directory. */
 const MCP_CONFIG_FILENAME = "mcp-config.json";
@@ -691,6 +692,13 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 turnResult.authError = authFailure.detail;
                 log.warn(`session ${leaseId}: coding agent authentication failed: ${authFailure.detail}`);
             }
+            // A model the CLI has no route to (OpenCode `provider.no-route`) fails
+            // every task the same way, so it gets the same treatment as a dead login.
+            const modelUnavailable = capacityLimit || authFailure ? null : (0, agent_model_cjs_1.detectAgentModelUnavailable)(turnResult);
+            if (modelUnavailable) {
+                turnResult.modelUnavailableError = modelUnavailable.detail;
+                log.warn(`session ${leaseId}: coding agent model unavailable: ${modelUnavailable.detail}`);
+            }
             // Close the small race between a naturally completed turn and the next
             // scheduled heartbeat. If guidance landed, run another turn before the
             // lease can be completed. A terminal heartbeat response means the
@@ -703,7 +711,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 log.warn(`session ${leaseId} stopped without completion because its lease is no longer active.`);
                 return sessionOutcome;
             }
-            if (!capacityLimit && !authFailure && !leaseLost && !turnResult.timedOut && pendingGuidance.length > 0) {
+            if (!capacityLimit && !authFailure && !modelUnavailable && !leaseLost && !turnResult.timedOut && pendingGuidance.length > 0) {
                 // Muse cancellation kills the whole task-owned container. Guidance
                 // still holds the lease, so restart that SAME container and restore
                 // its tmpfs environment before the next turn; never launch into a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.122",
+  "version": "0.1.123",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",