muonroi-cli 1.8.4 → 1.9.0

package/dist/src/orchestrator/error-utils.js

@@ -1,16 +1,16 @@
 import { APICallError } from "@ai-sdk/provider";
 const STATUS_MESSAGES = {
-    400: "The request was invalid. This may be caused by an unsupported parameter or model.",
-    401: "Authentication failed. Your API key may be invalid or expired.",
-    403: "Access denied. Your API key does not have permission for this request.",
-    404: "The requested model or endpoint was not found. Check your model name and base URL.",
-    408: "The request timed out. Please try again.",
-    422: "The request could not be processed. Check your message format or parameters.",
-    429: "Rate limit exceeded. Please wait a moment and try again.",
-    500: "The API server encountered an internal error. Please try again later.",
-    502: "The API server is temporarily unavailable. Please try again later.",
-    503: "The API service is temporarily overloaded. Please try again later.",
-    529: "The API service is overloaded. Please try again later.",
+    400: "The provider rejected this request as invalid — usually a parameter or model it doesn't support. Try switching models with `-m <model>`, or simplify the request and retry.",
+    401: "The provider didn't accept your API key — it may be missing, invalid, or expired. Run `keys login <provider>` to set a fresh key, then try again.",
+    403: "Your API key works, but it isn't allowed to make this request. Check your plan or key permissions on the provider's dashboard, or switch models with `-m <model>`.",
+    404: "The provider couldn't find that model or endpoint. Double-check the model name (see `models list`) and your base URL, then try again.",
+    408: "The request took too long and timed out. This is usually temporary — just try again.",
+    422: "The provider understood the request but couldn't process it. Check your message format and parameters, then retry — switching models with `-m <model>` can also help.",
+    429: "You're sending requests faster than the provider allows right now. Wait a moment and try again, or switch to another model with `-m <model>`.",
+    500: "Something went wrong on the provider's servers — not on your end. Give it a moment and try again later.",
+    502: "The provider's servers are temporarily unreachable. This usually clears up on its own — try again in a minute.",
+    503: "The provider is overloaded right now. Give it a minute and retry, or switch models with `-m <model>` in the meantime.",
+    529: "The provider is overloaded right now. Give it a minute and retry, or switch models with `-m <model>` in the meantime.",
 };
 export function isContextLimitError(error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -48,14 +48,45 @@ function routingSuffix(error, ctx) {
     if (status === undefined && /insufficient balance|out of (balance|credit)/i.test(message)) {
         status = 402;
     }
-    if (status === undefined || !ROUTING_STATUSES.has(status))
+    const rawMsg = (error instanceof Error ? error.message : String(error)).toLowerCase();
+    const isConsoleGo = rawMsg.includes("console go") || ctx?.providerId === "opencode-go";
+    const isRateLimitMsg = /rate limit|rate-limited|429|too many requests/i.test(rawMsg);
+    // If we have model context and it's a routing error (by status or by message content)
+    if (!ctx?.modelId)
+        return "";
+    if (!(status !== undefined && ROUTING_STATUSES.has(status)) && !isRateLimitMsg && !isConsoleGo)
         return "";
     const where = `routed to model "${ctx.modelId}"${ctx.providerId ? ` via provider "${ctx.providerId}"` : ""}`;
-    const hint = status === 402
-        ? "out of balance/credit — top up the provider account, or switch model with `-m <model>`."
-        : status === 401 || status === 403
-            ? "not authenticated for this provider — run `keys login <provider>` (or set its API key), or switch model with `-m <model>`."
-            : "rate-limited — wait and retry, or switch model with `-m <model>`.";
+    // A generic "invalid request" rejection — NOT a rate limit. Console Go can
+    // silently re-route (e.g. deepseek-v4-flash → a kimi coding backend) and then
+    // reject a long tool-loop payload with a bare 400 invalid_request. Retrying
+    // as-is never helps (isRetryable:false), so the hint must NOT say "wait and
+    // retry" — it must point at the real levers (switch model / shorten payload).
+    const isInvalidRequest = status === 400 || status === 422;
+    let hint;
+    if (isConsoleGo && (isRateLimitMsg || status === 429)) {
+        hint =
+            "the Console Go proxy hit its own burst rate limit — this is separate from your web 'Rolling Usage' %, so the dashboard can look fine while the proxy still throttles. Wait a moment, use native DeepSeek with `-m deepseek-v4-flash`, or switch provider.";
+    }
+    else if (status === 402) {
+        hint =
+            "this provider account is out of balance or credit. Top it up on the provider's site, or switch to another model with `-m <model>`.";
+    }
+    else if (status === 401 || status === 403) {
+        hint =
+            "you're not authenticated for this provider. Run `keys login <provider>` (or set its API key), or switch to another model with `-m <model>`.";
+    }
+    else if (isInvalidRequest) {
+        hint =
+            "the provider rejected this request as invalid — often a param or backend model it doesn't support, or a tool-loop payload the routed model can't accept (some gateways re-route to a different backend than the one you picked). Switch models with `-m <model>` or shorten/simplify the request; retrying it unchanged won't help.";
+    }
+    else if (isRateLimitMsg || status === 429) {
+        hint = "the provider is rate-limiting you. Wait a moment and retry, or switch to another model with `-m <model>`.";
+    }
+    else {
+        hint =
+            "the routed model or provider couldn't complete this request. Switch to another model with `-m <model>`, or try again.";
+    }
     return ` [${where}] — ${hint}`;
 }
 export function humanizeApiError(error, ctx) {
@@ -63,7 +94,7 @@ export function humanizeApiError(error, ctx) {
 }
 function humanizeApiErrorBase(error) {
     if (isMalformedFunctionNameError(error)) {
-        return "Model emitted a malformed tool call (function.name missing). Skipping this turn — please retry or rephrase.";
+        return "The model produced a malformed tool call (its function name was missing), so this turn was skipped. Just send your request again — rephrasing slightly often helps.";
     }
     if (APICallError.isInstance(error)) {
         const detail = extractResponseDetail(error.responseBody);
@@ -75,7 +106,8 @@ function humanizeApiErrorBase(error) {
         // For 5xx prefer the canned "retry later" message + the status code; keep a
         // body detail only when it actually adds information.
         if (status && status >= 500) {
-            const canned = STATUS_MESSAGES[status] ?? "The API server returned an error. Please try again later.";
+            const canned = STATUS_MESSAGES[status] ??
+                "The provider's servers returned an error — not something you did. Wait a bit and try again.";
             if (!detail || isOpaqueDetail(detail))
                 return `${canned} (HTTP ${status})`;
             return `${detail} (HTTP ${status})`;
@@ -93,9 +125,9 @@ function humanizeApiErrorBase(error) {
         const toolMatch = raw.match(/Tool\s+"?(\w+)"?\s+(?:is\s+)?not\s+found/i) ?? raw.match(/tool\s+(\w+)/i);
         const toolName = toolMatch?.[1] ?? "that tool";
         if (toolName === "search_web") {
-            return `"search_web" is not available. Use bash with curl for web requests, or delegate to an explore agent for research.`;
+            return `"search_web" isn't available here. For web requests, use bash with curl instead, or hand the research off to an explore agent.`;
         }
-        return `Tool "${toolName}" is not available. Check the TOOLS list in the system prompt for supported tools.`;
+        return `Tool "${toolName}" isn't available in this session. Check the TOOLS list in the system prompt to see which tools you can use.`;
     }
     return stripped;
 }
@@ -135,9 +167,50 @@ export function summarizeApiErrorForLog(error) {
     catch {
         urlHost = undefined;
     }
-    let requestParamKeys;
-    if (error.requestBodyValues && typeof error.requestBodyValues === "object") {
-        requestParamKeys = Object.keys(error.requestBodyValues).sort();
+    const bodyValues = error.requestBodyValues && typeof error.requestBodyValues === "object"
+        ? error.requestBodyValues
+        : undefined;
+    const requestParamKeys = bodyValues ? Object.keys(bodyValues).sort() : undefined;
+    // Collect the distinct field-key signature across assistant wire messages.
+    // Only key NAMES are persisted — values may contain secrets/PII.
+    let assistantFieldKeys;
+    let assistantReasoningLens;
+    let assistantToolCallCounts;
+    let totalReasoningChars = 0;
+    let toolMessageCount = 0;
+    if (bodyValues && Array.isArray(bodyValues.messages)) {
+        const signatures = new Set();
+        const rcLens = [];
+        const tcLens = [];
+        for (const m of bodyValues.messages) {
+            const msg = m;
+            if (msg?.role === "tool") {
+                toolMessageCount++;
+                continue;
+            }
+            if (msg?.role !== "assistant")
+                continue;
+            const sig = Object.keys(msg ?? {})
+                .sort()
+                .join(",");
+            signatures.add(sig);
+            const rc = msg?.reasoning_content;
+            if (typeof rc === "string") {
+                rcLens.push(rc.length);
+                totalReasoningChars += rc.length;
+            }
+            else {
+                rcLens.push(-1); // marker: reasoning_content missing/non-string on this turn
+            }
+            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls.length : 0;
+            tcLens.push(tcs);
+        }
+        if (signatures.size > 0)
+            assistantFieldKeys = [...signatures].sort();
+        if (rcLens.length > 0)
+            assistantReasoningLens = rcLens;
+        if (tcLens.length > 0)
+            assistantToolCallCounts = tcLens;
     }
     const body = typeof error.responseBody === "string" ? error.responseBody : undefined;
     const responseBodyTrunc = body && body.length > RESPONSE_BODY_CAP ? `${body.slice(0, RESPONSE_BODY_CAP)}…[truncated]` : body;
@@ -146,8 +219,43 @@ export function summarizeApiErrorForLog(error) {
         urlHost,
         responseBodyTrunc,
         requestParamKeys,
+        assistantFieldKeys,
+        assistantReasoningLens,
+        totalReasoningChars: assistantReasoningLens ? totalReasoningChars : undefined,
+        configParamValues: bodyValues ? extractConfigParamValues(bodyValues) : undefined,
+        assistantToolCallCounts,
+        toolMessageCount: bodyValues && Array.isArray(bodyValues.messages) ? toolMessageCount : undefined,
         isRetryable: error.isRetryable,
     };
 }
+/**
+ * Scalar SDK-config params whose VALUES are PII-safe (generation config, not
+ * user prompt content). See `ApiErrorForensics.configParamValues`.
+ * Includes parallel_tool_calls because Z.ai GLM coding endpoint rejects
+ * high-parallelism tool call batches (observed 8-12 in one assistant turn)
+ * with generic 1210; capturing the value helps confirm if SDK overrode it.
+ */
+const CONFIG_PARAM_KEYS = [
+    "reasoning_effort",
+    "verbosity",
+    "tool_choice",
+    "response_format",
+    "max_tokens",
+    "temperature",
+    "top_p",
+    "frequency_penalty",
+    "presence_penalty",
+    "seed",
+    "stop",
+    "parallel_tool_calls",
+];
+function extractConfigParamValues(body) {
+    const out = {};
+    for (const k of CONFIG_PARAM_KEYS) {
+        if (k in body)
+            out[k] = body[k] ?? null;
+    }
+    return out;
+}
 export { extractResponseDetail, STATUS_MESSAGES };
 //# sourceMappingURL=error-utils.js.map

package/dist/src/orchestrator/grounding-check.js

@@ -41,6 +41,30 @@ const COUNT_RE = new RegExp(`\\b(\\d{1,3}(?:,\\d{3})+|\\d{2,})\\b(?:\\s+(?:\\w+\
 const NOUN_SEP_NUM_RE = new RegExp(`\\b(?:${COUNT_NOUN})\\b[^.\\n:=]{0,40}?[:=]\\s*(\\d{1,3}(?:,\\d{3})+|\\d{2,})\\b`, "gi");
 // filename.ext:line — basename only (the char class excludes "/").
 const FILELINE_RE = /\b([\w.-]+\.[a-z]{1,5}):(\d+)\b/gi;
+// read_file emits a header `[<path>: lines A-B of TOTAL]` (src/tools/file.ts:75).
+// TOTAL is always the FULL file length (not the slice end B), so it is the
+// ground truth for "does line N exist in this file". Path may use "/" or "\";
+// the basename char class excludes both, so it captures just "planner.ts".
+const READ_HEADER_RE = /([\w.-]+\.[a-z]{1,5}):\s*lines\s+\d+-\d+\s+of\s+(\d+)/gi;
+/**
+ * Map basename → largest known full-file line count, parsed from read_file
+ * headers in the corpus. Used to catch a file:line that names a REAL (read)
+ * file but a FABRICATED line number beyond the file's length — the failure the
+ * basename-only check misses.
+ */
+function parseReadLineCounts(corpus) {
+    const totals = new Map();
+    for (const m of corpus.matchAll(READ_HEADER_RE)) {
+        const base = m[1].toLowerCase();
+        const total = Number.parseInt(m[2], 10);
+        if (!Number.isFinite(total))
+            continue;
+        const prev = totals.get(base);
+        if (prev === undefined || total > prev)
+            totals.set(base, total);
+    }
+    return totals;
+}
 // Hedge markers immediately before a number mean it is an estimate, not a fact.
 const HEDGE_RE = /(~|≈|\babout\b|\bapprox(?:imately)?\b|\broughly\b|\baround\b|\bnearly\b|\best\.?\b)\s*$/i;
 function stripCommas(s) {
@@ -56,6 +80,7 @@ export function findUnverifiedClaims(finalText, corpus) {
         return [];
     const corpusNorm = stripCommas(corpus).toLowerCase();
     const corpusLower = corpus.toLowerCase();
+    const readTotals = parseReadLineCounts(corpus);
     const out = [];
     const seen = new Set();
     const push = (claim) => {
@@ -103,8 +128,21 @@ export function findUnverifiedClaims(finalText, corpus) {
         if (idx > 0 && finalText[idx - 1] === "/")
             continue;
         const basename = m[1];
+        const lineNo = Number.parseInt(m[2], 10);
+        const knownTotal = readTotals.get(basename.toLowerCase());
+        // Provably-fabricated line: the file WAS read this turn (header parsed), but
+        // the cited line exceeds its real length. Deterministic — flag even though
+        // the basename appears in the corpus (the basename check below would pass).
+        if (knownTotal !== undefined && Number.isFinite(lineNo) && lineNo > knownTotal) {
+            push({
+                kind: "fileline",
+                value: `${basename}:${m[2]}`,
+                text: `${basename}:${m[2]} (file has ${knownTotal} lines)`,
+            });
+            continue;
+        }
         if (corpusLower.includes(basename.toLowerCase()))
-            continue; // file was read/grepped → verified
+            continue; // file was read/grepped & in-bounds → verified
         push({ kind: "fileline", value: `${basename}:${m[2]}`, text: `${basename}:${m[2]}` });
     }
     return out.slice(0, MAX_CLAIMS);

package/dist/src/orchestrator/interactive-pause.d.ts

@@ -0,0 +1,26 @@
+/**
+ * src/orchestrator/interactive-pause.ts
+ *
+ * Process-global "an interactive card is blocking the turn" gate.
+ *
+ * Some tools (`ask_user`) block inside their AI-SDK `execute()` waiting for a
+ * human to answer a card. During that wait NO stream chunks flow, so both the
+ * per-attempt stall watchdog (getProviderStallTimeoutMs, default 2 min) and the
+ * turn-idle watchdog (MUONROI_TURN_IDLE_MS, default 2 min) would fire and abort
+ * a turn that is not stalled at all — the human is just thinking.
+ *
+ * Rather than thread a keepalive timer through every call site, the blocking
+ * handler brackets its wait with {@link beginInteractivePause} /
+ * {@link endInteractivePause}, and both watchdogs consult
+ * {@link isInteractivePaused} before firing — re-arming instead of aborting
+ * while a card is open. Counter (not boolean) so nested/concurrent cards are
+ * safe.
+ */
+/** Enter an interactive pause — call before awaiting a blocking card. */
+export declare function beginInteractivePause(): void;
+/** Leave an interactive pause — call in a `finally` after the card resolves. */
+export declare function endInteractivePause(): void;
+/** True while at least one interactive card is blocking the turn. */
+export declare function isInteractivePaused(): boolean;
+/** Test-only: force the counter back to zero. */
+export declare function __resetInteractivePauseForTests(): void;

package/dist/src/orchestrator/interactive-pause.js

@@ -0,0 +1,36 @@
+/**
+ * src/orchestrator/interactive-pause.ts
+ *
+ * Process-global "an interactive card is blocking the turn" gate.
+ *
+ * Some tools (`ask_user`) block inside their AI-SDK `execute()` waiting for a
+ * human to answer a card. During that wait NO stream chunks flow, so both the
+ * per-attempt stall watchdog (getProviderStallTimeoutMs, default 2 min) and the
+ * turn-idle watchdog (MUONROI_TURN_IDLE_MS, default 2 min) would fire and abort
+ * a turn that is not stalled at all — the human is just thinking.
+ *
+ * Rather than thread a keepalive timer through every call site, the blocking
+ * handler brackets its wait with {@link beginInteractivePause} /
+ * {@link endInteractivePause}, and both watchdogs consult
+ * {@link isInteractivePaused} before firing — re-arming instead of aborting
+ * while a card is open. Counter (not boolean) so nested/concurrent cards are
+ * safe.
+ */
+let pauseDepth = 0;
+/** Enter an interactive pause — call before awaiting a blocking card. */
+export function beginInteractivePause() {
+    pauseDepth += 1;
+}
+/** Leave an interactive pause — call in a `finally` after the card resolves. */
+export function endInteractivePause() {
+    pauseDepth = Math.max(0, pauseDepth - 1);
+}
+/** True while at least one interactive card is blocking the turn. */
+export function isInteractivePaused() {
+    return pauseDepth > 0;
+}
+/** Test-only: force the counter back to zero. */
+export function __resetInteractivePauseForTests() {
+    pauseDepth = 0;
+}
+//# sourceMappingURL=interactive-pause.js.map

package/dist/src/orchestrator/message-processor.d.ts

@@ -7,6 +7,7 @@ import type { SessionInfo, StreamChunk, SubagentStatus } from "../types/index.js
 import { type PermissionMode } from "../utils/permission-mode.js";
 import type { AbortContext } from "./abort.js";
 import type { LegacyProvider, ProcessMessageObserver } from "./agent-options.js";
+import type { AskUserAskInfo } from "./ask-user.js";
 import type { CouncilManager } from "./council-manager.js";
 import type { CrossTurnDedup } from "./cross-turn-dedup.js";
 import type { PendingCallsLog } from "./pending-calls.js";
@@ -115,10 +116,13 @@ export interface MessageProcessorDeps extends TurnRunnerDepsBase {
     askToolLoopContinue?: ToolLoopCapAsk;
     /** Safety override handler — invoked when a tool call is blocked by the safety filter. */
     askSafetyOverride?: (info: SafetyOverrideAskInfo) => Promise<SafetyOverrideVerdict>;
+    /** ask_user handler — invoked when the model calls the `ask_user` tool; resolves the human's answer. */
+    askUser?: (info: AskUserAskInfo) => Promise<string>;
     runCouncilV2(userMessage: string, opts: {
         skipClarification: boolean;
         observer?: ProcessMessageObserver;
         userModelMessage: ModelMessage;
+        convenePath?: boolean;
     }): AsyncGenerator<StreamChunk, void, unknown>;
     processMessage(userMessage: string, observer?: ProcessMessageObserver, images?: Array<{
         path: string;