@cspeach/cli 1.1.25 → 1.1.26

package/dist/router/routing-failure.js

@@ -1,17 +1,69 @@
+/**
+ * Skill-routing failure: what happened, in true words (live fix 2026-09-26).
+ *
+ * Fix 9: the REPL used to print "Skill routing is offline · CSPeach service
+ * unreachable: This operation was aborted" when the classify call merely
+ * timed out (the proxy was healthy). The wording now comes from the
+ * classifier's machine-readable kind — never "offline"/"unreachable" for a
+ * timeout. Used by the Ink REPL, the classic REPL and one-shot.
+ */
+import { localRulesResult } from './classifier.js';
 /** The failure behind an offline (fallback) classify result, or null when routing worked. */
 export function routingFailureFromResult(c) {
     if (!c.offline)
         return null;
-    return c.transport_kind === 'timeout' ? { kind: 'timeout' } : { kind: 'network' };
+    if (c.transport_kind === 'timeout')
+        return { kind: 'timeout' };
+    if (c.transport_kind === 'http' && typeof c.http_status === 'number')
+        return { kind: 'http', status: c.http_status };
+    if (c.transport_kind === 'failed')
+        return { kind: 'failed' };
+    return { kind: 'network' };
 }
-/** The failure behind a thrown classify error (HTTP), or null for any other error. */
+/** The failure behind a thrown classify error (HTTP / unreadable body), or null for any other error. */
 export function routingFailureFromError(err) {
     // Duck-typed (not instanceof) so a re-loaded module instance still matches.
     const e = err;
-    if (e && e.transport_kind === 'http' && typeof e.status === 'number')
+    if (e && e.transport_kind === 'http' && typeof e.status === 'number') {
         return { kind: 'http', status: e.status };
+    }
+    if (e && e.transport_kind === 'failed')
+        return { kind: 'failed' };
     return null;
 }
+/**
+ * Live fix 2026-10-02 — a classify failure (the proxy answered HTTP 500 for a
+ * prompt its router answered in prose; an unreadable body; anything else
+ * classifyPrompt throws) no longer ends the turn or escapes one-shot as
+ * "unhandled error". Every routing path (Ink REPL, classic REPL, one-shot)
+ * takes this result instead: the bundled local-rules pick at low confidence,
+ * marked offline with the failure kind, so the existing offline handling
+ * runs — the low-confidence path (picker / one-shot top-1), one notice, and
+ * fix 10's "stay in the active skill" mid-skill.
+ *
+ * Returns null (caller keeps its own handling) for a missing API key, a user
+ * cancel (AbortError), and the slash-guard CLI bug, which must stay loud.
+ */
+export function routingFallbackFromError(err, prompt) {
+    const e = err;
+    if (e?.message === 'no_api_key')
+        return null;
+    if (e?.name === 'AbortError')
+        return null;
+    if (typeof e?.message === 'string' && e.message.startsWith('slash command reached the classifier'))
+        return null;
+    const f = routingFailureFromError(err) ?? { kind: 'failed' };
+    return {
+        ...localRulesResult(prompt),
+        offline: true,
+        transport_kind: f.kind === 'http' ? 'http' : 'failed',
+        ...(f.kind === 'http' ? { http_status: f.status } : {}),
+    };
+}
+/** "Couldn't pick a skill automatically (HTTP 500)" — the 2026-10-02 fallback headline. */
+function couldNotPick(f) {
+    return `Couldn't pick a skill automatically${f.kind === 'http' ? ` (HTTP ${f.status})` : ''}`;
+}
 /** Headline for the notice: "Skill routing timed out" etc. */
 export function routingFailureText(f) {
     switch (f.kind) {
@@ -20,15 +72,24 @@ export function routingFailureText(f) {
         case 'timeout': return 'Skill routing timed out';
         case 'network': return "Skill routing couldn't reach the CSPeach service";
         case 'http': return `Skill routing failed (HTTP ${f.status})`;
+        case 'failed': return 'Skill routing failed';
     }
 }
 /** The attention notice: headline, plus the real cause for network failures. */
 export function routingFailureNotice(f, transportError) {
+    // 2026-10-02: an HTTP / other classify failure now continues on local
+    // rules (routingFallbackFromError) — say so, and how to choose.
+    if (f.kind === 'http' || f.kind === 'failed') {
+        return { text: couldNotPick(f), fact: 'routed by local rules — start with /skill to choose' };
+    }
     const text = routingFailureText(f);
     return f.kind === 'network' && transportError ? { text, fact: transportError } : { text };
 }
 /** One-shot's dim stderr line (the turn continues on the bundled local rules). */
 export function routingFailureOneShotLine(f, transportError) {
+    if (f.kind === 'http' || f.kind === 'failed') {
+        return `[${couldNotPick(f)} — routed by local rules. Start with /skill to choose.]`;
+    }
     const n = routingFailureNotice(f, transportError);
     return `[${n.text}${n.fact ? `: ${n.fact}` : ''} — routed by local rules]`;
 }
@@ -38,6 +99,7 @@ function routingFailureShort(f) {
         case 'timeout': return 'Routing timed out';
         case 'network': return "Routing couldn't reach the CSPeach service";
         case 'http': return `Routing failed (HTTP ${f.status})`;
+        case 'failed': return 'Routing failed';
     }
 }
 /**