@ouro.bot/cli 0.1.0-alpha.439 → 0.1.0-alpha.440

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_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.440",
+      "changes": [
+        "Shared live provider checks now narrate each real attempt and retry across `ouro up`, the connect bay, `ouro check`, `ouro use`, and auth verification, so a slow or busy provider no longer feels like one frozen `checking <provider>` line.",
+        "One shared retry-progress formatter translates the real failure class into plain language like `provider is busy right now` or `provider asked us to slow down`, while the shared provider attempt runner now exposes attempt-start callbacks for every human-facing verification surface.",
+        "New daemon/provider progress coverage locks in the shared callback contract and the human-facing retry narration, with the full coverage, integration, package-e2e, and installed-product verification stack carried through for the published release."
+      ]
+    },
     {
       "version": "0.1.0-alpha.439",
       "changes": [

package/dist/heart/daemon/agent-config-check.js

@@ -46,6 +46,7 @@ const provider_state_1 = require("../provider-state");
 const provider_credentials_1 = require("../provider-credentials");
 const vault_unlock_1 = require("../../repertoire/vault-unlock");
 const readiness_repair_1 = require("./readiness-repair");
+const provider_ping_progress_1 = require("./provider-ping-progress");
 function isAgentProvider(value) {
     return Object.prototype.hasOwnProperty.call(identity_1.PROVIDER_CREDENTIALS, value);
 }
@@ -386,8 +387,12 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
     }
     const groups = [...pingGroups.values()];
     const pingResults = await Promise.all(groups.map(async (group) => {
-        deps.onProgress?.(`checking ${group.provider} / ${group.model}...`);
-        const result = await ping(group.provider, providerCredentialConfig(group.record), { model: group.model });
+        const result = await ping(group.provider, providerCredentialConfig(group.record), {
+            model: group.model,
+            ...(deps.onProgress
+                ? (0, provider_ping_progress_1.createProviderPingProgressReporter)({ provider: group.provider, model: group.model }, deps.onProgress)
+                : {}),
+        });
         return { group, result };
     }));
     let firstFailure = null;

package/dist/heart/daemon/cli-exec.js

@@ -95,6 +95,7 @@ const terminal_ui_1 = require("./terminal-ui");
 const startup_tui_1 = require("./startup-tui");
 const stale_bundle_prune_1 = require("./stale-bundle-prune");
 const up_progress_1 = require("./up-progress");
+const provider_ping_progress_1 = require("./provider-ping-progress");
 const provider_ping_1 = require("../provider-ping");
 const agent_discovery_1 = require("./agent-discovery");
 const connect_bay_1 = require("./connect-bay");
@@ -845,13 +846,13 @@ async function listGithubCopilotModels(baseUrl, token, fetchImpl = fetch) {
 }
 // ── Provider credential verification ──
 /* v8 ignore start -- verifyProviderCredentials: delegates to pingProvider @preserve */
-async function verifyProviderCredentials(provider, providers) {
+async function verifyProviderCredentials(provider, providers, options = {}) {
     const config = providers[provider];
     if (!config)
         return "not configured";
     try {
         const { pingProvider } = await Promise.resolve().then(() => __importStar(require("../../heart/provider-ping")));
-        const result = await pingProvider(provider, config);
+        const result = await pingProvider(provider, config, options);
         return result.ok ? "ok" : `failed (${result.message})`;
     }
     catch (error) {
@@ -2728,6 +2729,7 @@ async function executeProviderUse(command, deps, options = {}) {
             model: command.model,
             attemptPolicy: { baseDelayMs: 0 },
             sleep: deps.sleep,
+            ...(0, provider_ping_progress_1.createProviderPingProgressReporter)({ provider: command.provider, model: command.model }, (message) => progress?.updateDetail(message)),
         });
         const attempts = pingAttemptCount(pingResult);
         const status = pingResult.ok ? "ready" : `failed (${pingResult.message})`;
@@ -2793,6 +2795,7 @@ async function executeProviderCheck(command, deps) {
             model: binding.model,
             attemptPolicy: { baseDelayMs: 0 },
             sleep: deps.sleep,
+            ...(0, provider_ping_progress_1.createProviderPingProgressReporter)({ provider: binding.provider, model: binding.model }, (message) => progress.updateDetail(message)),
         });
         const attempts = pingAttemptCount(pingResult);
         const status = pingResult.ok ? "ready" : `failed (${pingResult.message})`;
@@ -2949,6 +2952,9 @@ async function executeAuthRun(command, deps) {
         verificationStatus = credential.ok
             ? await verifyProviderCredentials(provider, {
                 [provider]: { ...credential.record.config, ...credential.record.credentials },
+            }, {
+                sleep: deps.sleep,
+                ...(0, provider_ping_progress_1.createProviderPingProgressReporter)({ provider }, (message) => progress.updateDetail(message)),
             })
             : `stored but could not be re-read from vault (${credential.error})`;
         progress.completePhase(`verifying ${provider}`, verificationStatus);
@@ -4918,6 +4924,9 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 progress.startPhase(`verifying ${command.provider}`);
                 const status = await verifyProviderCredentials(command.provider, {
                     [command.provider]: { ...record.config, ...record.credentials },
+                }, {
+                    sleep: deps.sleep,
+                    ...(0, provider_ping_progress_1.createProviderPingProgressReporter)({ provider: command.provider }, (message) => progress.updateDetail(message)),
                 });
                 progress.completePhase(`verifying ${command.provider}`, status);
                 const message = useTTYBoard
@@ -4934,6 +4943,9 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             for (const [p, record] of entries) {
                 const status = await verifyProviderCredentials(p, {
                     [p]: { ...record.config, ...record.credentials },
+                }, {
+                    sleep: deps.sleep,
+                    ...(0, provider_ping_progress_1.createProviderPingProgressReporter)({ provider: p }, (message) => progress.updateDetail(message)),
                 });
                 const line = `${p}: ${status}`;
                 lines.push(line);

package/dist/heart/daemon/provider-ping-progress.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatProviderAttemptProgress = formatProviderAttemptProgress;
+exports.formatProviderRetryProgress = formatProviderRetryProgress;
+exports.createProviderPingProgressReporter = createProviderPingProgressReporter;
+const runtime_1 = require("../../nerves/runtime");
+function formatProviderPingLabel(context) {
+    return context.model ? `${context.provider} / ${context.model}` : context.provider;
+}
+function providerRetryReason(record) {
+    switch (record.classification) {
+        case "auth-failure":
+            return "credentials were rejected";
+        case "usage-limit":
+            return "usage limit hit";
+        case "rate-limit":
+            return "provider asked us to slow down";
+        case "server-error":
+            return record.httpStatus === 529 ? "provider is busy right now" : "provider is having trouble right now";
+        case "network-error":
+            return "network connection dropped";
+        case "unknown":
+            return "last check failed";
+        default:
+            return "last check failed";
+    }
+}
+function providerRetryTiming(delayMs) {
+    if (!delayMs || delayMs <= 0)
+        return "now";
+    const seconds = delayMs / 1000;
+    const rounded = Number.isInteger(seconds) ? `${seconds.toFixed(0)}s` : `${seconds.toFixed(1).replace(/\.0$/, "")}s`;
+    return `in ${rounded}`;
+}
+function formatProviderAttemptProgress(context, attempt, maxAttempts) {
+    return `checking ${formatProviderPingLabel(context)} (attempt ${attempt} of ${maxAttempts})...`;
+}
+function formatProviderRetryProgress(record, maxAttempts) {
+    const nextAttempt = Math.min(record.attempt + 1, maxAttempts);
+    return `${formatProviderPingLabel(record)}: ${providerRetryReason(record)}; retrying ${providerRetryTiming(record.delayMs)} (attempt ${nextAttempt} of ${maxAttempts})`;
+}
+function createProviderPingProgressReporter(context, onProgress) {
+    return {
+        onAttemptStart: async (attempt, maxAttempts) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.provider_ping_progress_reported",
+                message: "reported provider ping attempt progress",
+                meta: {
+                    provider: context.provider,
+                    model: context.model ?? null,
+                    kind: "attempt",
+                    attempt,
+                    maxAttempts,
+                },
+            });
+            onProgress(formatProviderAttemptProgress(context, attempt, maxAttempts));
+        },
+        onRetry: async (record, maxAttempts) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.provider_ping_progress_reported",
+                message: "reported provider ping retry progress",
+                meta: {
+                    provider: record.provider,
+                    model: record.model,
+                    kind: "retry",
+                    attempt: record.attempt,
+                    maxAttempts,
+                    classification: record.classification ?? "unknown",
+                },
+            });
+            onProgress(formatProviderRetryProgress(record, maxAttempts));
+        },
+    };
+}

package/dist/heart/provider-attempt.js

@@ -51,6 +51,7 @@ async function runProviderAttempt(input) {
     const attempts = [];
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         try {
+            await input.onAttemptStart?.(attempt, maxAttempts);
             const value = await input.run();
             attempts.push({
                 attempt,

package/dist/heart/provider-ping.js

@@ -180,6 +180,8 @@ async function pingProvider(provider, config, options = {}) {
             ...options.attemptPolicy,
         },
         sleep: options.sleep,
+        onAttemptStart: options.onAttemptStart,
+        onRetry: options.onRetry,
         run: async () => {
             const controller = new AbortController();
             /* v8 ignore next -- timeout callback: only fires after 10s, tests resolve faster @preserve */

package/package.json

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