@ouro.bot/cli 0.1.0-alpha.235 → 0.1.0-alpha.236

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_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.236",
+      "changes": [
+        "fix(engine): provider-aware retry classification — retries now use both generic isTransientError AND provider classifyError",
+        "feat(engine): retry instrumentation — engine.provider_retry / engine.provider_retry_skip events with full diagnostics"
+      ]
+    },
     {
       "version": "0.1.0-alpha.235",
       "changes": [

package/dist/heart/core.js

@@ -959,20 +959,48 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 callbacks.onError(new Error("context trimmed, retrying..."), "transient");
                 continue;
             }
-            // Transient errors: retry with exponential backoff
-            if (isTransientError(e) && retryCount < MAX_RETRIES) {
+            // 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).
+            const errorForClassification = e instanceof Error ? e : /* v8 ignore next -- defensive @preserve */ new Error(String(e));
+            let providerClassification;
+            try {
+                providerClassification = providerRuntime.classifyError(errorForClassification);
+            }
+            catch {
+                /* 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;
+            (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`,
+                meta: {
+                    provider: providerRuntime.id,
+                    model: providerRuntime.model,
+                    retryCount,
+                    maxRetries: MAX_RETRIES,
+                    retryableByGeneric,
+                    retryableByClassification,
+                    providerClassification,
+                    errorMessage: errorForClassification.message.slice(0, 200),
+                    httpStatus: e.status ?? null,
+                },
+            });
+            if (shouldRetry) {
                 retryCount++;
                 const delay = RETRY_BASE_MS * Math.pow(2, retryCount - 1);
-                let classification;
-                try {
-                    classification = providerRuntime.classifyError(e instanceof Error ? e : /* v8 ignore next -- defensive: errors are always Error instances @preserve */ new Error(String(e)));
-                }
-                catch {
-                    /* v8 ignore next -- defensive: classifyError should not throw @preserve */
-                    classification = classifyTransientError(e);
-                }
                 /* v8 ignore next -- defensive: all classifications have labels @preserve */
-                const cause = TRANSIENT_RETRY_LABELS[classification] ?? classification;
+                const cause = TRANSIENT_RETRY_LABELS[providerClassification] ?? 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) => {
@@ -995,14 +1023,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 providerRuntime.resetTurnState(messages);
                 continue;
             }
-            terminalError = e instanceof Error ? e : new Error(String(e));
-            try {
-                terminalErrorClassification = providerRuntime.classifyError(terminalError);
-            }
-            catch {
-                /* v8 ignore next -- defensive: classifyError should not throw @preserve */
-                terminalErrorClassification = "unknown";
-            }
+            terminalError = errorForClassification;
+            terminalErrorClassification = providerClassification;
             /* v8 ignore start — auth-failure guidance: tested via provider error classification tests @preserve */
             if (terminalErrorClassification === "auth-failure") {
                 const agentName = (0, identity_2.getAgentName)();

package/package.json

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