@ouro.bot/cli 0.1.0-alpha.240 → 0.1.0-alpha.242

package/changelog.json

@@ -2,16 +2,19 @@
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
     {
-      "version": "0.1.0-alpha.240",
+      "version": "0.1.0-alpha.241",
       "changes": [
-        "fix(cli): process exits immediately after chat session ends \u2014 lingering Ink timers and MCP connections were keeping the event loop alive, requiring an extra Ctrl+C after \"bye\"."
+        "feat: commerce bootstrap \u2014 bw CLI lazy-install, vault auto-config, resolver coverage"
       ]
     },
     {
-      "version": "0.1.0-alpha.239",
+      "version": "0.1.0-alpha.242",
       "changes": [
         "fix(friends): stable local CLI identity \u2014 dropped hostname from external ID (was `username@hostname`, now just `username`). macOS hostname instability (`Mac` vs `Aris-MacBook-Pro.local`) was creating duplicate friend records with separate sessions and trust levels.",
-        "feat(friends): migration fallback \u2014 FriendResolver now searches for old `username@*` format IDs when exact match fails, linking new stable ID to existing friend record."
+        "feat(friends): migration fallback \u2014 FriendResolver now searches for old `username@*` format IDs when exact match fails, linking new stable ID to existing friend record.",
+        "fix(heart): retry-everything-except-blocklist policy \u2014 the SDK 'Request timed out.' error from MiniMax (and other providers) was reaching slugger as a terminal failure because neither the generic isTransientError detector nor the per-provider classifier recognized it. Replaced the two-layer transient detection with a small blocklist (HTTP 400/401/403/404/422 + classifications auth-failure/usage-limit). Default policy now retries every other error.",
+        "fix(heart/providers): drop the 30s OpenAI/Anthropic SDK timeout from all five providers (anthropic, azure, github-copilot, minimax, openai-codex). The SDK timeout caps the entire stream lifetime, so 30s killed any reasoning model mid-generation. SDK defaults (\u224810min) are sane.",
+        "refactor(heart/providers): consolidate duplicated isNetworkError + classifyXxxError scaffolding into a shared `error-classification.ts` module. Each provider now delegates via `classifyHttpError(err, overrides)` and only carries its own provider-specific quirks (Anthropic 529, Codex usage-limit message detection)."
       ]
     },
     {

package/dist/heart/core.js

@@ -10,8 +10,7 @@ exports.isExternalStateQuery = isExternalStateQuery;
 exports.getSettleRetryError = getSettleRetryError;
 exports.stripLastToolCalls = stripLastToolCalls;
 exports.repairOrphanedToolCalls = repairOrphanedToolCalls;
-exports.isTransientError = isTransientError;
-exports.classifyTransientError = classifyTransientError;
+exports.isRetryBlocked = isRetryBlocked;
 exports.runAgent = runAgent;
 const config_1 = require("./config");
 const identity_1 = require("./identity");
@@ -353,48 +352,39 @@ function isContextOverflow(err) {
         return true;
     return false;
 }
-// Detect transient network errors worth retrying
-function isTransientError(err) {
-    if (!(err instanceof Error))
-        return false;
-    const msg = err.message || "";
-    const code = err.code || "";
-    // Node.js network error codes
-    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
-        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
-        return true;
-    // OpenAI SDK / fetch errors
-    if (msg.includes("fetch failed"))
-        return true;
-    if (msg.includes("network") && !msg.includes("context"))
+// HTTP statuses that will never become retryable on their own — the request is
+// semantically wrong (malformed, unauthorized, missing route, etc.) and the
+// caller has to do something different before it can succeed.
+const NON_RETRYABLE_HTTP_STATUSES = new Set([
+    400, // Bad Request — malformed payload
+    401, // Unauthorized — credentials invalid/expired
+    403, // Forbidden — credentials lack permission
+    404, // Not Found — model/route doesn't exist
+    422, // Unprocessable Entity — semantic validation failure
+]);
+// Provider-classified error categories that we never retry. usage-limit is
+// distinct from rate-limit: rate limits clear in seconds (retryable), usage
+// limits are billing quotas that take hours/days to reset.
+const NON_RETRYABLE_CLASSIFICATIONS = new Set([
+    "auth-failure",
+    "usage-limit",
+]);
+// Default policy: retry every error from the provider, EXCEPT the small set
+// above. The user explicitly requested this — past behavior was to retry only
+// on a known-transient list, which silently dropped real harness/SDK timeouts
+// (e.g. OpenAI SDK's "Request timed out." has no err.code and no status, so
+// the substring matchers missed it).
+function isRetryBlocked(error, classification) {
+    const status = error.status;
+    if (status !== undefined && NON_RETRYABLE_HTTP_STATUSES.has(status))
         return true;
-    if (msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT"))
-        return true;
-    if (msg.includes("socket hang up"))
-        return true;
-    if (msg.includes("getaddrinfo"))
-        return true;
-    // HTTP 429 / 500 / 502 / 503 / 504
-    const status = err.status;
-    if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504)
+    if (NON_RETRYABLE_CLASSIFICATIONS.has(classification))
         return true;
     return false;
 }
-function classifyTransientError(err) {
-    if (!(err instanceof Error))
-        return "unknown error";
-    const status = err.status;
-    if (status === 429)
-        return "rate limited";
-    if (status === 401 || status === 403)
-        return "auth error";
-    if (status && status >= 500)
-        return "server error";
-    return "network error";
-}
 const MAX_RETRIES = 3;
 const RETRY_BASE_MS = 2000;
-const TRANSIENT_RETRY_LABELS = {
+const RETRY_LABELS = {
     "auth-failure": "auth error",
     "usage-limit": "usage limit",
     "rate-limit": "rate limited",
@@ -942,10 +932,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 callbacks.onError(new Error("context trimmed, retrying..."), "transient");
                 continue;
             }
-            // Transient errors: retry with exponential backoff.
-            // Two-layer detection: generic isTransientError (HTTP codes, network patterns)
-            // PLUS provider-specific classifyError (catches SDK-wrapped errors that
-            // generic detection might miss).
+            // Retry policy: retry every error EXCEPT those on the blocklist
+            // (NON_RETRYABLE_HTTP_STATUSES / NON_RETRYABLE_CLASSIFICATIONS).
+            // The classification still drives the user-facing label and the
+            // auth-failure guidance message below — it just no longer gates retries.
             const errorForClassification = e instanceof Error ? e : /* v8 ignore next -- defensive @preserve */ new Error(String(e));
             let providerClassification;
             try {
@@ -955,25 +945,23 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 /* v8 ignore next -- defensive: classifyError should not throw @preserve */
                 providerClassification = "unknown";
             }
-            const retryableByClassification = providerClassification === "rate-limit"
-                || providerClassification === "server-error"
-                || providerClassification === "network-error";
-            const retryableByGeneric = isTransientError(e);
-            const shouldRetry = (retryableByGeneric || retryableByClassification) && retryCount < MAX_RETRIES;
+            const blocked = isRetryBlocked(errorForClassification, providerClassification);
+            const shouldRetry = !blocked && retryCount < MAX_RETRIES;
             (0, runtime_1.emitNervesEvent)({
                 level: shouldRetry ? "info" : "warn",
                 event: shouldRetry ? "engine.provider_retry" : "engine.provider_retry_skip",
                 component: "engine",
                 message: shouldRetry
                     ? `provider error is retryable (attempt ${retryCount + 1}/${MAX_RETRIES})`
-                    : `provider error is not retryable or retries exhausted`,
+                    : blocked
+                        ? `provider error is on retry blocklist`
+                        : `provider error retries exhausted`,
                 meta: {
                     provider: providerRuntime.id,
                     model: providerRuntime.model,
                     retryCount,
                     maxRetries: MAX_RETRIES,
-                    retryableByGeneric,
-                    retryableByClassification,
+                    blocked,
                     providerClassification,
                     errorMessage: errorForClassification.message.slice(0, 200),
                     httpStatus: e.status ?? null,
@@ -982,8 +970,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             if (shouldRetry) {
                 retryCount++;
                 const delay = RETRY_BASE_MS * Math.pow(2, retryCount - 1);
-                /* v8 ignore next -- defensive: all classifications have labels @preserve */
-                const cause = TRANSIENT_RETRY_LABELS[providerClassification] ?? providerClassification;
+                const cause = RETRY_LABELS[providerClassification];
                 callbacks.onError(new Error(`${cause}, retrying in ${delay / 1000}s (${retryCount}/${MAX_RETRIES})...`), "transient");
                 // Wait with abort support
                 const aborted = await new Promise((resolve) => {

package/dist/heart/providers/anthropic.js

@@ -45,6 +45,7 @@ const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
 const model_capabilities_1 = require("../model-capabilities");
+const error_classification_1 = require("./error-classification");
 const ANTHROPIC_SETUP_TOKEN_PREFIX = "sk-ant-oat01-";
 const ANTHROPIC_SETUP_TOKEN_MIN_LENGTH = 80;
 const ANTHROPIC_OAUTH_BETA_HEADER = "claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14";
@@ -221,42 +222,19 @@ function mergeAnthropicToolArguments(current, partial) {
     }
     return current + partial;
 }
-/* v8 ignore start -- shared network error utility, tested via classification tests @preserve */
-function isNetworkError(error) {
-    const code = error.code || "";
-    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
-        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
-        return true;
-    const msg = error.message || "";
-    return msg.includes("fetch failed") || msg.includes("socket hang up") || msg.includes("getaddrinfo");
-}
-/* v8 ignore stop */
 function classifyAnthropicError(error) {
-    const status = error.status;
-    if (status === 401 || status === 403 || isAnthropicAuthFailure(error))
-        return "auth-failure";
-    if (status === 429)
-        return "rate-limit";
-    if (status === 529 || (status && status >= 500))
-        return "server-error";
-    if (isNetworkError(error))
-        return "network-error";
-    return "unknown";
+    return (0, error_classification_1.classifyHttpError)(error, {
+        isAuthFailure: isAnthropicAuthFailure,
+        isServerError: (e) => e.status === 529,
+    });
 }
-/* v8 ignore start -- auth detection: only called from classifyAnthropicError which always passes Error @preserve */
 function isAnthropicAuthFailure(error) {
-    if (!(error instanceof Error))
-        return false;
-    const status = error.status;
-    if (status === 401 || status === 403)
-        return true;
     const lower = error.message.toLowerCase();
     return (lower.includes("oauth authentication") ||
         lower.includes("authentication failed") ||
         lower.includes("unauthorized") ||
         lower.includes("invalid api key"));
 }
-/* v8 ignore stop */
 async function streamAnthropicMessages(client, model, request) {
     const { system, messages } = toAnthropicMessages(request.messages);
     const anthropicTools = toAnthropicTools(request.activeTools);
@@ -438,7 +416,6 @@ function createAnthropicProviderRuntime(model) {
     function createClient(token) {
         return new sdk_1.default({
             authToken: token,
-            timeout: 30000,
             maxRetries: 0,
             defaultHeaders: {
                 "anthropic-beta": ANTHROPIC_OAUTH_BETA_HEADER,

package/dist/heart/providers/azure.js

@@ -41,28 +41,10 @@ const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
 const model_capabilities_1 = require("../model-capabilities");
+const error_classification_1 = require("./error-classification");
 const COGNITIVE_SERVICES_SCOPE = "https://cognitiveservices.azure.com/.default";
-/* v8 ignore start -- shared network error utility, tested via classification tests @preserve */
-function isNetworkError(error) {
-    const code = error.code || "";
-    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
-        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
-        return true;
-    const msg = error.message || "";
-    return msg.includes("fetch failed") || msg.includes("socket hang up") || msg.includes("getaddrinfo");
-}
-/* v8 ignore stop */
 function classifyAzureError(error) {
-    const status = error.status;
-    if (status === 401 || status === 403)
-        return "auth-failure";
-    if (status === 429)
-        return "rate-limit";
-    if (status && status >= 500)
-        return "server-error";
-    if (isNetworkError(error))
-        return "network-error";
-    return "unknown";
+    return (0, error_classification_1.classifyHttpError)(error);
 }
 // @azure/identity is imported dynamically (below) rather than at the top level
 // because it's a heavy package (~30+ transitive deps) and we only need it when
@@ -113,7 +95,6 @@ function createAzureProviderRuntime(model) {
         endpoint: azureConfig.endpoint.replace(/\/openai.*$/, ""),
         deployment: azureConfig.deployment,
         apiVersion: azureConfig.apiVersion,
-        timeout: 30000,
         maxRetries: 0,
     };
     if (useApiKey) {

package/dist/heart/providers/error-classification.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNetworkError = isNetworkError;
+exports.classifyHttpError = classifyHttpError;
+const runtime_1 = require("../../nerves/runtime");
+// Node socket / DNS error codes that indicate a transient network failure.
+const NETWORK_ERROR_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "ETIMEDOUT",
+    "EPIPE",
+    "EAI_AGAIN",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "ECONNABORTED",
+]);
+// Substrings the OpenAI/Anthropic SDKs use when wrapping fetch/socket failures
+// into Error.message instead of an err.code.
+const NETWORK_ERROR_MESSAGE_PATTERNS = [
+    "fetch failed",
+    "socket hang up",
+    "getaddrinfo",
+    "request timed out", // OpenAI SDK timeout — see SDK source
+    "request timeout",
+    "connection error",
+];
+// True if the error looks like a transient network issue (no HTTP status, just
+// a socket/DNS/timeout failure from the underlying transport).
+function isNetworkError(error) {
+    const code = error.code || "";
+    if (NETWORK_ERROR_CODES.has(code))
+        return true;
+    const msg = (error.message || "").toLowerCase();
+    return NETWORK_ERROR_MESSAGE_PATTERNS.some((pat) => msg.includes(pat));
+}
+// Standard HTTP error → ProviderErrorClassification mapping. Providers wrap
+// this with their own overrides.
+function classifyHttpError(error, overrides) {
+    const status = error.status;
+    if (overrides?.isAuthFailure?.(error) || status === 401 || status === 403) {
+        return "auth-failure";
+    }
+    if (status === 429) {
+        if (overrides?.isUsageLimit?.(error))
+            return "usage-limit";
+        return "rate-limit";
+    }
+    if (overrides?.isServerError?.(error) || (status !== undefined && status >= 500)) {
+        return "server-error";
+    }
+    if (isNetworkError(error))
+        return "network-error";
+    return "unknown";
+}
+/* v8 ignore start — module-level observability event */
+(0, runtime_1.emitNervesEvent)({
+    component: "engine",
+    event: "engine.error_classification_loaded",
+    message: "shared provider error classification loaded",
+    meta: {},
+});
+/* v8 ignore stop */

package/dist/heart/providers/github-copilot.js

@@ -10,30 +10,10 @@ const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
 const model_capabilities_1 = require("../model-capabilities");
-/* v8 ignore start -- duplicated from shared provider utils, tested there @preserve */
-function isNetworkError(error) {
-    const code = error.code || "";
-    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
-        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
-        return true;
-    const msg = error.message || "";
-    return msg.includes("fetch failed") || msg.includes("socket hang up") || msg.includes("getaddrinfo");
-}
-/* v8 ignore stop */
-/* v8 ignore start -- duplicated classification pattern, tested via provider unit tests @preserve */
+const error_classification_1 = require("./error-classification");
 function classifyGithubCopilotError(error) {
-    const status = error.status;
-    if (status === 401 || status === 403)
-        return "auth-failure";
-    if (status === 429)
-        return "rate-limit";
-    if (status && status >= 500)
-        return "server-error";
-    if (isNetworkError(error))
-        return "network-error";
-    return "unknown";
+    return (0, error_classification_1.classifyHttpError)(error);
 }
-/* v8 ignore stop */
 function createGithubCopilotProviderRuntime(model) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
@@ -57,7 +37,6 @@ function createGithubCopilotProviderRuntime(model) {
     const client = new openai_1.default({
         apiKey: config.githubToken,
         baseURL: config.baseUrl,
-        timeout: 30000,
         maxRetries: 0,
     });
     if (isCompletionsModel) {

package/dist/heart/providers/minimax.js

@@ -8,27 +8,9 @@ exports.createMinimaxProviderRuntime = createMinimaxProviderRuntime;
 const openai_1 = __importDefault(require("openai"));
 const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
-/* v8 ignore start -- shared network error utility, tested via classification tests @preserve */
-function isNetworkError(error) {
-    const code = error.code || "";
-    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
-        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
-        return true;
-    const msg = error.message || "";
-    return msg.includes("fetch failed") || msg.includes("socket hang up") || msg.includes("getaddrinfo");
-}
-/* v8 ignore stop */
+const error_classification_1 = require("./error-classification");
 function classifyMinimaxError(error) {
-    const status = error.status;
-    if (status === 401 || status === 403)
-        return "auth-failure";
-    if (status === 429)
-        return "rate-limit";
-    if (status && status >= 500)
-        return "server-error";
-    if (isNetworkError(error))
-        return "network-error";
-    return "unknown";
+    return (0, error_classification_1.classifyHttpError)(error);
 }
 const streaming_1 = require("../streaming");
 const model_capabilities_1 = require("../model-capabilities");
@@ -48,7 +30,6 @@ function createMinimaxProviderRuntime(model) {
     const client = new openai_1.default({
         apiKey: minimaxConfig.apiKey,
         baseURL: "https://api.minimaxi.chat/v1",
-        timeout: 30000,
         maxRetries: 0,
     });
     return {

package/dist/heart/providers/openai-codex.js

@@ -11,6 +11,7 @@ const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
 const model_capabilities_1 = require("../model-capabilities");
+const error_classification_1 = require("./error-classification");
 const OPENAI_CODEX_AUTH_FAILURE_MARKERS = [
     "authentication failed",
     "unauthorized",
@@ -43,43 +44,19 @@ function getOpenAICodexReauthGuidance(reason) {
         getOpenAICodexOAuthInstructions(),
     ].join("\n");
 }
-/* v8 ignore start -- shared network error utility, tested via classification tests @preserve */
-function isNetworkError(error) {
-    const code = error.code || "";
-    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
-        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
-        return true;
-    const msg = error.message || "";
-    return msg.includes("fetch failed") || msg.includes("socket hang up") || msg.includes("getaddrinfo");
-}
-/* v8 ignore stop */
 function classifyOpenAICodexError(error) {
-    const status = error.status;
-    if (status === 401 || status === 403 || isOpenAICodexAuthFailure(error))
-        return "auth-failure";
-    if (status === 429) {
-        const lower = error.message.toLowerCase();
-        if (lower.includes("usage") || lower.includes("quota") || lower.includes("exceeded your"))
-            return "usage-limit";
-        return "rate-limit";
-    }
-    if (status && status >= 500)
-        return "server-error";
-    if (isNetworkError(error))
-        return "network-error";
-    return "unknown";
+    return (0, error_classification_1.classifyHttpError)(error, {
+        isAuthFailure: isOpenAICodexAuthFailure,
+        isUsageLimit: (e) => {
+            const lower = e.message.toLowerCase();
+            return lower.includes("usage") || lower.includes("quota") || lower.includes("exceeded your");
+        },
+    });
 }
-/* v8 ignore start -- auth detection: only called from classifyOpenAICodexError which always passes Error @preserve */
 function isOpenAICodexAuthFailure(error) {
-    if (!(error instanceof Error))
-        return false;
-    const status = error.status;
-    if (status === 401 || status === 403)
-        return true;
     const lower = error.message.toLowerCase();
     return OPENAI_CODEX_AUTH_FAILURE_MARKERS.some((marker) => lower.includes(marker));
 }
-/* v8 ignore stop */
 function decodeJwtPayload(token) {
     const parts = token.split(".");
     if (parts.length < 2)
@@ -143,7 +120,6 @@ function createOpenAICodexProviderRuntime(model) {
             "OpenAI-Beta": "responses=experimental",
             originator: "ouroboros",
         },
-        timeout: 30000,
         maxRetries: 0,
     });
     let nativeInput = null;

package/dist/mind/friends/resolver.js

@@ -33,7 +33,7 @@ class FriendResolver {
             return existing;
         // Migration: local provider previously used "${username}@${hostname}" format.
         // If no exact match, try finding a friend with old-format external ID.
-        /* v8 ignore start -- one-time migration: hostname→username format, tested manually @preserve */
+        /* v8 ignore start -- migration path: only fires when legacy hostname-format friend exists @preserve */
         if (this.params.provider === "local" && !this.params.externalId.includes("@")) {
             try {
                 const all = typeof this.store.listAll === "function" ? await this.store.listAll() : [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.240",
+  "version": "0.1.0-alpha.242",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",