@1presence/bridge 0.55.0 → 0.57.0

package/dist/claude.js

@@ -163,6 +163,28 @@ function describeCliFailure(apiErrorText, authFailure) {
     }
     return 'Local Mode stopped unexpectedly. Please try again.';
 }
+// Join every non-empty error fragment the SDK might carry (a `result` string,
+// an `errors: string[]`, an error enum, a request_id, …) into one de-duplicated
+// line. A 4xx/5xx surfaces its detail unpredictably: `result` rides on the
+// success-shaped error result, `errors[]` on SDKResultError, the coarse bucket
+// on `assistant.error` — so we gather from all of them rather than trusting one.
+function joinErrorDetail(...parts) {
+    const seen = new Set();
+    const out = [];
+    for (const part of parts) {
+        for (const item of Array.isArray(part) ? part : [part]) {
+            const s = (typeof item === 'string' ? item : item == null ? '' : String(item)).trim();
+            if (s && !seen.has(s)) {
+                seen.add(s);
+                out.push(s);
+            }
+        }
+    }
+    return out.join(' | ');
+}
+// Lines the SDK/CLI writes to its own stderr that look like a failure — surfaced
+// even outside verbose mode so a turn that dies upstream leaves a trail.
+const SDK_STDERR_ERROR_RE = /\b(error|exception|fail(?:ed|ure)?|invalid|unauthor|forbidden|refus|denied|40[0-9]|429|5\d\d|overloaded|rate.?limit)\b/i;
 /**
  * Copy for an actionable rate-limit notice. The SDK emits `rate_limit_event`
  * whenever rate-limit info CHANGES — including the routine `allowed` case on
@@ -492,14 +514,31 @@ export function spawnClaude(params) {
                 const status = event['api_error_status'];
                 if (status === 401 || status === 403)
                     sawAuthFailure = true;
-                if (!apiErrorText && typeof event['result'] === 'string') {
-                    apiErrorText = event['result'].trim();
-                }
+                // Gather the reason from EVERY error-bearing field, not just `result`
+                // (empty on most 4xx/5xx). `errors[]` rides on SDKResultError. Fold into
+                // apiErrorText, keeping any coarse enum the assistant.error path set.
+                const detail = joinErrorDetail(event['result'], event['errors']);
+                apiErrorText = joinErrorDetail(apiErrorText, detail) || apiErrorText;
+                const subtype = event['subtype'] ? ` subtype=${event['subtype']}` : '';
                 // Operator visibility — a result-borne error would otherwise reach the
                 // user as a chat error with NOTHING in the bridge logs (the failure
                 // mode that made the empty-content `invalid_request` regression so hard
-                // to diagnose). Mechanical log only; no product logic.
-                process.stderr.write(paint(SECTION_COLORS.result, `[bridge] result error${status ? ` (${status})` : ''}: ${apiErrorText || 'unknown'}`) + '\n');
+                // to diagnose). Logged in ALL modes (not just verbose). Mechanical log
+                // only; no product logic.
+                process.stderr.write(paint(SECTION_COLORS.result, `[bridge] result error${status != null ? ` (${status})` : ''}${subtype}: ${apiErrorText || 'unknown'}`) + '\n');
+                // When no field carried a reason (the SDK bucketed it as bare "unknown"),
+                // dump the raw result object so nothing is silently swallowed — the only
+                // remaining place a clue could hide. Bounded so it can't flood the log.
+                if (!detail) {
+                    let raw;
+                    try {
+                        raw = JSON.stringify(event);
+                    }
+                    catch {
+                        raw = String(event);
+                    }
+                    process.stderr.write(paint(SECTION_COLORS.result, `[bridge] result raw: ${raw.slice(0, 2000)}`) + '\n');
+                }
             }
         }
         return true;
@@ -571,8 +610,15 @@ export function spawnClaude(params) {
             includePartialMessages: false, // whole messages, matching the old non-partial path
             permissionMode: 'default',
             env: safeEnv,
-            stderr: (line) => { if (verbose && line.trim())
-                process.stderr.write(`[claude] ${line.trim()}\n`); },
+            // Surface the SDK/CLI's own stderr. In verbose mode pass everything; in
+            // normal mode pass only error-looking lines so an upstream failure still
+            // leaves a trail (the SDK abstracts the raw API body into an enum, so its
+            // stderr is sometimes the only place the real reason appears).
+            stderr: (line) => {
+                const t = line.trim();
+                if (t && (verbose || SDK_STDERR_ERROR_RE.test(t)))
+                    process.stderr.write(`[claude] ${t}\n`);
+            },
             ...(pinnedModel ? { model: pinnedModel } : {}),
         };
         const promptMessages = buildPromptMessages(history);
@@ -584,12 +630,21 @@ export function spawnClaude(params) {
                     continue;
                 switch (m.type) {
                     case 'system': {
-                        if (m.subtype === 'init') {
+                        const subtype = m.subtype;
+                        if (subtype === 'init') {
                             const init = m;
                             const event = { type: 'system', subtype: 'init', model: init.model, apiKeySource: init.apiKeySource };
                             if (handleEvent(event))
                                 onEvent(event);
                         }
+                        else if (subtype === 'api_retry') {
+                            // The SDK retries retryable API failures (5xx / overloaded / some
+                            // 429s) before giving up. Log each attempt with its status + bucket
+                            // so a turn that eventually dies after retries leaves a full trail —
+                            // in all modes, not just verbose. Diagnostic only; never forwarded.
+                            const r = m;
+                            process.stderr.write(paint(SECTION_COLORS.result, `[bridge] api retry ${r.attempt ?? '?'}/${r.max_retries ?? '?'}${r.error_status != null ? ` (${r.error_status})` : ''}: ${r.error ?? 'unknown'}${r.retry_delay_ms != null ? `, next in ${r.retry_delay_ms}ms` : ''}`) + '\n');
+                        }
                         break;
                     }
                     case 'assistant': {
@@ -599,9 +654,21 @@ export function spawnClaude(params) {
                             sawApiError = true;
                             if (am.error === 'authentication_failed' || am.error === 'oauth_org_not_allowed')
                                 sawAuthFailure = true;
-                            if (!apiErrorText)
-                                apiErrorText = `API Error: ${am.error}`;
-                            process.stderr.write(paint(SECTION_COLORS.result, `[bridge] assistant error: ${am.error}`) + '\n');
+                            // Pull any extra reason off the synthetic error message + the
+                            // request_id (the handle to look the failure up upstream) so the
+                            // log/chat error isn't just the coarse `unknown` bucket.
+                            const msgText = Array.isArray(am.message?.['content'])
+                                ? am.message['content']
+                                    .filter((b) => b['type'] === 'text' && typeof b['text'] === 'string')
+                                    .map((b) => b['text'].trim())
+                                    .filter(Boolean)
+                                    .join(' ')
+                                : '';
+                            const rid = am.request_id ? `request_id=${am.request_id}` : '';
+                            const full = joinErrorDetail(`API Error: ${am.error}`, msgText, rid);
+                            if (!apiErrorText || /^API Error: \w+$/.test(apiErrorText))
+                                apiErrorText = full;
+                            process.stderr.write(paint(SECTION_COLORS.result, `[bridge] assistant error: ${joinErrorDetail(am.error, msgText, rid)}`) + '\n');
                             break;
                         }
                         const event = { type: 'assistant', message: am.message, error: am.error };
@@ -627,6 +694,7 @@ export function spawnClaude(params) {
                             is_error: rm['is_error'],
                             api_error_status: rm['api_error_status'],
                             result: rm['result'],
+                            errors: rm['errors'], // string[] on SDKResultError — the reason on a non-success result
                         };
                         if (handleEvent(event))
                             onEvent(event);
@@ -670,6 +738,12 @@ export function spawnClaude(params) {
             if (killedForViolation)
                 return;
             const message = err?.message ?? String(err);
+            // Log the raw thrown error IN FULL before onError sanitises it for chat —
+            // describeCliFailure deliberately strips provider detail from the
+            // user-facing copy, so the operator log is the only place the full reason
+            // (incl. stack) survives. All modes, not just verbose.
+            const stack = err?.stack;
+            process.stderr.write(paint(SECTION_COLORS.result, `[bridge] query() threw: ${stack || message}`) + '\n');
             if (/40[13]\b|unauthor|invalid (api key|authentication)|please run \/login/i.test(message)) {
                 sawAuthFailure = true;
             }

package/dist/config.js

@@ -76,15 +76,25 @@ function detectClaudeDefaultModel() {
 // The fixed menu — keep the option count small so the timeout default is easy
 // to glance at. Option 1's `model: null` means "let Claude Code pick" (no
 // `--model` flag passed to the subprocess).
+// NB on `[1m]` (1M-context Opus): the bridge always runs on the user's claude.ai
+// subscription (it strips ANTHROPIC_API_KEY — see claude.ts), and it is UNCONFIRMED
+// whether the 1M context window (a tier-gated API beta) is servable on subscription
+// auth. It is offered but is NOT the default — auto-selecting a maybe-unsupported
+// variant is the risk we avoid; deliberately picking it to test is fine. (An earlier
+// every-turn `400 / "unknown"` was first blamed on this but was actually a tool-schema
+// bug that hit every model — see vault/Bugs.md.) `num` must stay contiguous 1..N in
+// array order — the jump-key handler maps a typed digit `n` to `idx = n - 1`.
 const MODEL_OPTIONS = [
     { num: 1, model: null, label: 'Use Claude Code default' },
-    { num: 2, model: 'claude-opus-4-8[1m]', label: 'claude-opus-4-8[1m]  (1M context)' },
-    { num: 3, model: 'claude-opus-4-8', label: 'claude-opus-4-8' },
+    { num: 2, model: 'claude-opus-4-8', label: 'claude-opus-4-8' },
+    { num: 3, model: 'claude-opus-4-8[1m]', label: 'claude-opus-4-8[1m]  (1M context — experimental on subscription)' },
     { num: 4, model: 'claude-opus-4-7', label: 'claude-opus-4-7' },
     { num: 5, model: 'claude-sonnet-4-6', label: 'claude-sonnet-4-6' },
     { num: 6, model: 'claude-haiku-4-5', label: 'claude-haiku-4-5' },
 ];
 const PROMPT_TIMEOUT_MS = 10_000;
+// Default to plain claude-opus-4-8 (definitely servable on a subscription), not
+// the experimental `[1m]` variant.
 const DEFAULT_OPTION_NUM = 2;
 function promptForModel(defaultModel) {
     return new Promise((resolve) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1presence/bridge",
-  "version": "0.55.0",
+  "version": "0.57.0",
   "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
   "type": "module",
   "bin": {