@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/tui/chat.js

@@ -380,7 +380,11 @@ export class ChatSession extends EventEmitter {
             return;
         const { updated_at: _updatedAt, ...record } = status;
         void withLocalModelRuntimeRepository(this.workspaceRoot, async (repo) => {
-            await repo.upsertRuntimeStatus(record);
+            await repo.upsertRuntimeStatusWithTransition(record, {
+                from: this.currentRuntimeStatus?.bridge_status,
+                reason: "Interactive runtime status updated after provider/tool progress.",
+                evidence_refs: [this.sessionId],
+            });
         }).catch((error) => {
             this.emit("error", `Runtime status persistence failed: ${formatErrorMessage(error)}`);
         });
@@ -390,14 +394,26 @@ export class ChatSession extends EventEmitter {
             return;
         void withLocalModelRuntimeRepository(this.workspaceRoot, async (repo) => {
             if (input.activationLedger) {
-                await repo.upsertActivationLedger(input.activationLedger);
+                await repo.upsertActivationLedgerWithTransition(input.activationLedger, {
+                    from: this.activationLedger ? "updated" : "created",
+                    reason: "Interactive activation ledger updated after ACE session progress.",
+                    evidence_refs: [this.sessionId],
+                });
             }
             if (input.runtimeStatus) {
                 const { updated_at: _updatedAt, ...statusRecord } = input.runtimeStatus;
-                await repo.upsertRuntimeStatus(statusRecord);
+                await repo.upsertRuntimeStatusWithTransition(statusRecord, {
+                    from: this.currentRuntimeStatus?.bridge_status,
+                    reason: "Interactive runtime status updated after ACE session progress.",
+                    evidence_refs: [this.sessionId],
+                });
             }
             if (input.continuity) {
-                await repo.upsertContinuityRecord(input.continuity);
+                await repo.upsertContinuityRecordWithTransition(input.continuity, {
+                    from: this.currentRuntimeStatus?.bridge_status,
+                    reason: "Interactive continuity record updated after ACE session progress.",
+                    evidence_refs: [this.sessionId],
+                });
             }
         }).catch((error) => {
             this.emit("error", `ACE runtime persistence failed: ${formatErrorMessage(error)}`);
@@ -416,15 +432,79 @@ export class ChatSession extends EventEmitter {
             preferredRole: this.aceRole,
         });
         const executionRole = preflight.recommended_role ?? this.aceRole;
+        const prevLedger = this.activationLedger;
         let activationLedger = nextActivationLedger(this.sessionId, this.activationLedger ?? undefined, preflight.recommended_next_action);
-        const startupNudge = buildStartupNudge(preflight, activationLedger);
+        // Detect previously shown but unaccepted/unauto-executed nudges as ignored
+        if (prevLedger) {
+            const autoExecuted = prevLedger.auto_executed_nudges ?? [];
+            const accepted = prevLedger.accepted_nudges;
+            const alreadyIgnored = prevLedger.ignored_nudges ?? [];
+            const ignoredNow = prevLedger.shown_nudges.filter((id) => !accepted.includes(id) && !autoExecuted.includes(id) && !alreadyIgnored.includes(id));
+            if (ignoredNow.length > 0) {
+                activationLedger = {
+                    ...activationLedger,
+                    ignored_nudges: uniqueStrings([...(activationLedger.ignored_nudges ?? []), ...ignoredNow]),
+                };
+                if (this.workspaceRoot) {
+                    const wsr = this.workspaceRoot;
+                    for (const nudgeId of ignoredNow) {
+                        void withLocalModelRuntimeRepository(wsr, async (repo) => {
+                            await repo.appendTransitionRecord({
+                                session_id: this.sessionId,
+                                subject_kind: "nudge",
+                                subject_id: nudgeId,
+                                from: "shown",
+                                to: "ignored",
+                                reason: `Nudge ${nudgeId} ignored: user sent new message without accepting`,
+                                evidence_refs: [],
+                            });
+                        }).catch(() => { });
+                    }
+                }
+            }
+        }
+        const startupNudge = buildStartupNudge(preflight, activationLedger, this.currentRuntimeStatus);
         if (startupNudge) {
             activationLedger = {
                 ...activationLedger,
                 shown_nudges: uniqueStrings([...activationLedger.shown_nudges, startupNudge.id]),
+                ...(startupNudge.auto_executable
+                    ? {
+                        auto_executed_nudges: uniqueStrings([
+                            ...(activationLedger.auto_executed_nudges ?? []),
+                            startupNudge.id,
+                        ]),
+                    }
+                    : {}),
             };
             this.pushSystemMessage(`Hint: ${startupNudge.text}`);
             this.emit("startup_nudge", startupNudge);
+            if (this.workspaceRoot) {
+                const wsr = this.workspaceRoot;
+                const nudge = startupNudge;
+                void withLocalModelRuntimeRepository(wsr, async (repo) => {
+                    await repo.appendTransitionRecord({
+                        session_id: this.sessionId,
+                        subject_kind: "nudge",
+                        subject_id: nudge.id,
+                        from: "new",
+                        to: "shown",
+                        reason: `Startup nudge shown for action: ${nudge.recommended_action}`,
+                        evidence_refs: [],
+                    });
+                    if (nudge.auto_executable) {
+                        await repo.appendTransitionRecord({
+                            session_id: this.sessionId,
+                            subject_kind: "nudge",
+                            subject_id: nudge.id,
+                            from: "shown",
+                            to: "auto_executed",
+                            reason: `Auto-executed safe action: ${nudge.recommended_action}`,
+                            evidence_refs: [],
+                        });
+                    }
+                }).catch(() => { });
+            }
         }
         let runtimeStatus = this.buildRuntimeStatusPacket({
             role: executionRole,
@@ -488,15 +568,31 @@ export class ChatSession extends EventEmitter {
             },
             onToolCall: (tool, args) => {
                 toolNames.push(tool);
+                const nudgeToAccept = tool === startupNudge?.recommended_action ? startupNudge : undefined;
                 activationLedger = {
                     ...activationLedger,
                     updated_at: Date.now(),
                     activated_tools: uniqueStrings([...activationLedger.activated_tools, tool]),
                     activated_roles: uniqueStrings([...activationLedger.activated_roles, executionRole]),
-                    accepted_nudges: tool === startupNudge?.recommended_action
-                        ? uniqueStrings([...activationLedger.accepted_nudges, startupNudge.id])
+                    accepted_nudges: nudgeToAccept
+                        ? uniqueStrings([...activationLedger.accepted_nudges, nudgeToAccept.id])
                         : activationLedger.accepted_nudges,
                 };
+                if (nudgeToAccept && this.workspaceRoot) {
+                    const wsr = this.workspaceRoot;
+                    const nudge = nudgeToAccept;
+                    void withLocalModelRuntimeRepository(wsr, async (repo) => {
+                        await repo.appendTransitionRecord({
+                            session_id: this.sessionId,
+                            subject_kind: "nudge",
+                            subject_id: nudge.id,
+                            from: "shown",
+                            to: "manually_accepted",
+                            reason: `Nudge accepted via tool call: ${tool}`,
+                            evidence_refs: [],
+                        });
+                    }).catch(() => { });
+                }
                 runtimeStatus = {
                     ...runtimeStatus,
                     bridge_status: "running",

package/dist/tui/dashboard.d.ts

@@ -18,6 +18,7 @@ export declare class DashboardState extends EventEmitter {
     private runtimeEvents;
     private phase;
     private latestRuntimeStatus;
+    private latestTransitions;
     constructor(workspaceRoot: string);
     startWatching(): void;
     stopWatching(): void;

package/dist/tui/dashboard.js

@@ -7,6 +7,7 @@
 import { EventEmitter } from "node:events";
 import { pollStore } from "../store/state-reader.js";
 import { getWorkspaceStorePath } from "../store/store-snapshot.js";
+import { getLivenessDefaults } from "../runtime-profile.js";
 function dedupeEvents(events) {
     const seen = new Set();
     const ordered = [];
@@ -35,6 +36,18 @@ export function selectLiveRuntimeStatus(statuses) {
 }
 function derivePhase(snapshot) {
     const runtimeStatus = selectLiveRuntimeStatus(snapshot.runtimeStatuses);
+    if (runtimeStatus?.sleep_state === "stalled") {
+        return "Stalled";
+    }
+    if (runtimeStatus?.sleep_state === "sleeping") {
+        return "Sleeping";
+    }
+    if (runtimeStatus?.sleep_state === "approval_pending") {
+        return "Approval Pending";
+    }
+    if (runtimeStatus?.sleep_state === "dependency_wait") {
+        return runtimeStatus.waiting_on ? `Waiting: ${runtimeStatus.waiting_on}` : "Waiting";
+    }
     if (runtimeStatus?.bridge_status === "blocked") {
         return "Blocked";
     }
@@ -48,6 +61,15 @@ function derivePhase(snapshot) {
         return "Retrying";
     }
     if (runtimeStatus?.bridge_status === "running") {
+        const kind = runtimeStatus.surface_kind;
+        if (kind === "unattended_runtime")
+            return "Running (Unattended)";
+        if (kind === "scheduled_job")
+            return "Running (Scheduled)";
+        if (kind === "bridge_resumed")
+            return "Running (Resumed)";
+        if (kind === "supervised_step")
+            return "Running (Supervised)";
         return "Running";
     }
     if (snapshot.jobs.some((job) => String(job.status ?? "") === "running")) {
@@ -73,6 +95,7 @@ export class DashboardState extends EventEmitter {
     runtimeEvents = [];
     phase = "Initializing";
     latestRuntimeStatus;
+    latestTransitions = [];
     constructor(workspaceRoot) {
         super();
         this.workspaceRoot = workspaceRoot;
@@ -108,6 +131,7 @@ export class DashboardState extends EventEmitter {
             runtimeStatus: this.latestRuntimeStatus,
             tasks: this.tasks,
             events: dedupeEvents([...this.persistedEvents, ...this.runtimeEvents]).slice(-50),
+            recentTransitions: this.latestTransitions,
         };
     }
     getLatestRuntimeStatus() {
@@ -141,6 +165,25 @@ export class DashboardState extends EventEmitter {
         this.persistedEvents = dedupeEvents([...trackerEvents, ...ledgerEvents]).slice(-300);
         this.phase = derivePhase(snapshot);
         this.latestRuntimeStatus = selectLiveRuntimeStatus(snapshot.runtimeStatuses);
+        // Compute read-only staleness projection — no watcher, computed on each snapshot
+        if (this.latestRuntimeStatus?.last_progress_at) {
+            const livenessDefaults = getLivenessDefaults(this.latestRuntimeStatus.model_class);
+            const effectiveStallWindowMs = this.latestRuntimeStatus.stall_window_ms ?? livenessDefaults.stall_window_ms;
+            const stalenessSec = (Date.now() - this.latestRuntimeStatus.last_progress_at) / 1000;
+            const stallWindowSec = effectiveStallWindowMs / 1000;
+            this.latestRuntimeStatus["staleness_seconds"] = stalenessSec;
+            this.latestRuntimeStatus["stall_window_seconds"] = stallWindowSec;
+            this.latestRuntimeStatus["is_stale"] = stalenessSec >= stallWindowSec;
+        }
+        this.latestTransitions = (snapshot.recentTransitions ?? []).map((t) => ({
+            subject_kind: t.subject_kind,
+            subject_id: t.subject_id,
+            from: t.from,
+            to: t.to,
+            reason: t.reason,
+            evidence_refs: t.evidence_refs,
+            at: t.at,
+        }));
         // Surface discovered providers to the TUI controller so dashboard controls
         // reflect what's actually available in the store.
         if (snapshot.providers.length > 0) {

package/dist/tui/index.js

@@ -56,7 +56,13 @@ export class AceTui {
         const workspaceRoot = options.workspaceRoot ?? WORKSPACE_ROOT;
         this.workspaceRoot = workspaceRoot;
         this.provider = this.normalizeProvider(options.provider ?? inferProviderFromModel(options.model) ?? "ollama") ?? "ollama";
-        this.model = (options.model ?? defaultModelForProvider(this.provider)).trim();
+        const initialModel = options.model ??
+            (this.provider === "ollama"
+                ? defaultModelForProvider(this.provider)
+                : this.provider === "llama.cpp"
+                    ? ""
+                    : defaultModelForProvider(this.provider));
+        this.model = initialModel.trim();
         // Initialize modules
         const colorLevel = detectColorLevel();
         for (const [provider, baseUrl] of Object.entries(options.providerBaseUrls ?? {})) {
@@ -757,6 +763,9 @@ export class AceTui {
         else if (this.provider === "ollama") {
             this.model = DEFAULT_OLLAMA_MODEL;
         }
+        else if (this.provider === "llama.cpp") {
+            this.model = "";
+        }
         else {
             this.model = defaultModelForProvider(this.provider);
         }

package/dist/tui/layout.d.ts

@@ -60,11 +60,20 @@ interface RuntimeStatusSummary {
     bridge_status: string;
     preflight_state: string;
     role?: string;
+    model_class?: "frontier" | "mid" | "small_local";
     approval_state?: string;
     active_tool?: string;
     active_tool_role?: string;
     recommended_next_action?: string;
     blocked_reason?: string;
+    active_workspace_path?: string;
+    workspace_hook_health?: "ok" | "degraded" | "failed";
+    staleness_seconds?: number;
+    stall_window_seconds?: number;
+    is_stale?: boolean;
+    stall_restart_count?: number;
+    current_task?: string;
+    surface_kind?: string;
 }
 export declare class LayoutManager {
     private zones;
@@ -88,6 +97,7 @@ export declare class LayoutManager {
     renderStatusBar(state: StatusBarState): void;
     renderInputLine(buffer: string, cursorPos: number, mode: string, prompt?: string): void;
     renderDashboard(data: DashboardData, controls?: DashboardControlState): void;
+    private renderTransitionsPanel;
     private renderStatusPanel;
     private renderControlStrip;
     private renderTasksPanel;
@@ -119,11 +129,21 @@ export interface DashboardData {
     runtimeStatus?: RuntimeStatusSummary;
     tasks: TaskItem[];
     events: ActivityEvent[];
+    recentTransitions?: Array<{
+        subject_kind: string;
+        subject_id: string;
+        from?: string;
+        to: string;
+        reason: string;
+        evidence_refs?: string[];
+        at: number;
+    }>;
 }
 export interface TaskItem {
     title: string;
     done: boolean;
     priority?: string;
+    upstream_annotation?: string;
 }
 export interface ActivityEvent {
     timestamp: number;

package/dist/tui/layout.js

@@ -250,6 +250,18 @@ export class LayoutManager {
         drawBox(content.x, actY, content.width, actH, { title: "Agent Activity", titleColor: fg.brightGreen, borderColor: fg.gray, rounded: true });
         this.renderActivityLog(content.x + 2, actY + 1, content.width - 4, actH - 2, data.events);
     }
+    renderTransitionsPanel(x, y, w, data) {
+        const transitions = data.recentTransitions?.slice(-3) ?? [];
+        if (transitions.length === 0)
+            return;
+        writeAt(x, y, `${fg.gray}─── Recent Transitions ───`);
+        for (let i = 0; i < transitions.length; i++) {
+            const t = transitions[i];
+            const age = Math.round((Date.now() - t.at) / 1000);
+            const line = `${fg.gray}${age}s ago ${fg.cyan}${t.subject_kind}${fg.gray}:${fg.white}${t.to}${fg.gray} — ${truncate(t.reason, 28)}`;
+            writeAt(x, y + 1 + i, truncate(line + style.reset, w));
+        }
+    }
     renderStatusPanel(x, y, w, h, data) {
         const lines = [
             `${fg.gray}Phase:   ${fg.brightWhite}${data.phase}`,
@@ -266,12 +278,29 @@ export class LayoutManager {
             data.runtimeStatus?.role
                 ? `${fg.gray}Role:    ${fg.brightCyan}${data.runtimeStatus.role}`
                 : undefined,
+            data.runtimeStatus?.model_class
+                ? `${fg.gray}Model:   ${fg.brightCyan}${data.runtimeStatus.model_class}`
+                : undefined,
             data.runtimeStatus?.blocked_reason
                 ? `${fg.gray}Blocker: ${fg.brightRed}${data.runtimeStatus.blocked_reason}`
                 : undefined,
             data.runtimeStatus?.recommended_next_action
                 ? `${fg.gray}Next:    ${fg.white}${data.runtimeStatus.recommended_next_action}`
                 : undefined,
+            data.runtimeStatus?.active_workspace_path
+                ? `${fg.gray}Wrkspace:${fg.cyan} ${truncate(data.runtimeStatus.active_workspace_path, 32)} ${fg.gray}[hook: ${data.runtimeStatus.workspace_hook_health ?? "?"}]`
+                : undefined,
+            data.runtimeStatus?.stall_restart_count
+                ? `${fg.gray}Stalls:  ${fg.yellow}${data.runtimeStatus.stall_restart_count} restart(s)`
+                : undefined,
+            data.runtimeStatus?.is_stale
+                ? `${fg.brightRed}⚠ STALE  ${fg.gray}${(data.runtimeStatus.staleness_seconds ?? 0).toFixed(0)}s since last progress (window: ${(data.runtimeStatus.stall_window_seconds ?? 0).toFixed(0)}s)`
+                : data.runtimeStatus?.staleness_seconds !== undefined
+                    ? `${fg.gray}Progress:${fg.brightGreen} ${(data.runtimeStatus.staleness_seconds).toFixed(0)}s ago`
+                    : undefined,
+            data.runtimeStatus?.current_task
+                ? `${fg.gray}Task:    ${fg.white}${truncate(data.runtimeStatus.current_task, 40)}`
+                : undefined,
             `${fg.gray}Provider:${fg.brightCyan} ${padRight(data.provider, 8)}`,
             `${fg.gray}Model:   ${fg.brightCyan}${data.model}`,
             `${fg.gray}Agents:  ${fg.brightGreen}${data.activeAgents}${fg.gray}/${data.totalAgents} active`,
@@ -304,7 +333,8 @@ export class LayoutManager {
             const t = tasks[i];
             const icon = t.done ? `${fg.green}${symbols.check}` : `${fg.gray}${symbols.hollowBullet}`;
             const priority = t.priority ? `${fg.gray}[${t.priority}]` : "";
-            const line = `${icon} ${fg.white}${t.title} ${priority}${style.reset}`;
+            const upstream = t.upstream_annotation ? ` ${fg.gray}← ${t.upstream_annotation}` : "";
+            const line = `${icon} ${fg.white}${t.title} ${priority}${upstream}${style.reset}`;
             writeAt(x, y + i, truncate(line, w));
         }
         if (tasks.length === 0) {

package/dist/tui/local-model-contract.d.ts

@@ -15,11 +15,14 @@ export interface AcePreflightPacket {
     recall_summary?: string;
     should_synthesize_plan: boolean;
 }
-export interface StartupNudge {
+export interface AceStartupNudge {
     id: string;
     text: string;
     recommended_action: string;
+    auto_executable: boolean;
 }
+/** @deprecated Use AceStartupNudge */
+export type StartupNudge = AceStartupNudge;
 export declare function shouldSynthesizeShortPlan(task: string): boolean;
 export declare function buildAcePreflightPacket(input: {
     sessionId: string;
@@ -28,7 +31,8 @@ export declare function buildAcePreflightPacket(input: {
     preferredRole?: string;
 }): AcePreflightPacket;
 export declare function nextActivationLedger(sessionId: string, current: AceSessionActivationLedger | undefined, recommendedAction: string | undefined): AceSessionActivationLedger;
-export declare function buildStartupNudge(preflight: AcePreflightPacket, ledger: AceSessionActivationLedger): StartupNudge | undefined;
+export declare function shouldAutoExecuteNudge(action: string, surfaceKind: AceRuntimeStatusPacket["surface_kind"] | undefined): boolean;
+export declare function buildStartupNudge(preflight: AcePreflightPacket, ledger: AceSessionActivationLedger, statusPacket?: AceRuntimeStatusPacket | null): AceStartupNudge | undefined;
 export declare function buildBridgeTaskInput(conversation: string, preflight: AcePreflightPacket): string;
 export declare function mapBridgeResultToRuntimeStatus(input: {
     current: AceRuntimeStatusPacket;

package/dist/tui/local-model-contract.js

@@ -122,10 +122,18 @@ export function nextActivationLedger(sessionId, current, recommendedAction) {
         accepted_nudges: [...(current?.accepted_nudges ?? [])],
         activated_tools: [...(current?.activated_tools ?? [])],
         activated_roles: [...(current?.activated_roles ?? [])],
-        last_recommended_action: recommendedAction ?? current?.last_recommended_action,
+        auto_executed_nudges: current?.auto_executed_nudges ? [...current.auto_executed_nudges] : undefined,
+        ignored_nudges: current?.ignored_nudges ? [...current.ignored_nudges] : undefined,
     };
 }
-export function buildStartupNudge(preflight, ledger) {
+export function shouldAutoExecuteNudge(action, surfaceKind) {
+    const SAFE_TRIO = new Set(["validate_framework", "recall_context", "run_orchestrator"]);
+    return (SAFE_TRIO.has(action) &&
+        (surfaceKind === "unattended_runtime" ||
+            surfaceKind === "scheduled_job" ||
+            surfaceKind === "supervised_step"));
+}
+export function buildStartupNudge(preflight, ledger, statusPacket) {
     const action = preflight.recommended_next_action;
     if (!action)
         return undefined;
@@ -140,7 +148,12 @@ export function buildStartupNudge(preflight, ledger) {
             : action === "route_task"
                 ? "Role selection is still ambiguous. Route the task before deeper work."
                 : "Load ACE context first with recall_context before deeper work.";
-    return { id: nudgeId, text, recommended_action: action };
+    return {
+        id: nudgeId,
+        text,
+        recommended_action: action,
+        auto_executable: shouldAutoExecuteNudge(action, statusPacket?.surface_kind),
+    };
 }
 function compactTrapPack() {
     return [

package/dist/tui/ollama.d.ts

@@ -111,6 +111,13 @@ export declare class OllamaClient {
 export declare class OllamaError extends Error {
     statusCode: number;
     responseBody: string;
-    constructor(message: string, statusCode: number, responseBody: string);
+    kind?: string;
+    meta?: Record<string, unknown>;
+    suggested_remediation?: string;
+    constructor(message: string, statusCode: number, responseBody: string, options?: {
+        kind?: string;
+        model?: string;
+        suggested_remediation?: string;
+    });
 }
 //# sourceMappingURL=ollama.d.ts.map

package/dist/tui/ollama.js

@@ -5,6 +5,24 @@
  * Zero dependencies — uses Node.js built-in fetch/http.
  * Supports model listing, pulling, chat streaming, and health checks.
  */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function requestedModelFromOptions(options) {
+    if (typeof options?.body !== "string")
+        return undefined;
+    try {
+        const parsed = JSON.parse(options.body);
+        return typeof parsed.model === "string"
+            ? parsed.model
+            : typeof parsed.name === "string"
+                ? parsed.name
+                : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 // ── Client ───────────────────────────────────────────────────────────
 export class OllamaClient {
     baseUrl;
@@ -124,19 +142,36 @@ export class OllamaClient {
             throw new OllamaError("Ollama base URL is not configured. Set one explicitly or run `ace doctor --scan`.", 0, "");
         }
         const url = `${this.baseUrl}${path}`;
-        const res = await fetch(url, {
-            ...options,
-            headers: {
-                "Content-Type": "application/json",
-                Accept: "application/json",
-                ...(options?.headers ?? {}),
-            },
-        });
-        if (!res.ok) {
+        const maxAttempts = 3;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            const res = await fetch(url, {
+                ...options,
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                    ...(options?.headers ?? {}),
+                },
+            });
+            if (res.ok)
+                return res;
             const text = await res.text().catch(() => "");
-            throw new OllamaError(`Ollama API error: ${res.status} ${res.statusText}`, res.status, text);
+            const requestedModel = requestedModelFromOptions(options);
+            if (res.status >= 500 && /unable to load model/i.test(text)) {
+                throw new OllamaError(`Ollama was unable to load model${requestedModel ? ` '${requestedModel}'` : ""}. ` +
+                    `Run \`ollama pull ${requestedModel ?? "<model>"}\` or \`ace doctor --repair-ollama\`.`, res.status, text, {
+                    kind: "ollama_model_load_error",
+                    model: requestedModel,
+                    suggested_remediation: `run ollama pull ${requestedModel ?? "<model>"} or ace doctor --repair-ollama`,
+                });
+            }
+            lastError = new OllamaError(`Ollama API error: ${res.status} ${res.statusText}`, res.status, text);
+            if (res.status < 500 || attempt === maxAttempts) {
+                throw lastError;
+            }
+            await sleep(100 * attempt);
         }
-        return res;
+        throw lastError ?? new OllamaError("Ollama API request failed", 0, "");
     }
     /** Stream newline-delimited JSON from a ReadableStream */
     async *streamJsonLines(body) {
@@ -182,11 +217,17 @@ export class OllamaClient {
 export class OllamaError extends Error {
     statusCode;
     responseBody;
-    constructor(message, statusCode, responseBody) {
+    kind;
+    meta;
+    suggested_remediation;
+    constructor(message, statusCode, responseBody, options) {
         super(message);
         this.statusCode = statusCode;
         this.responseBody = responseBody;
         this.name = "OllamaError";
+        this.kind = options?.kind;
+        this.meta = options?.model ? { model: options.model } : undefined;
+        this.suggested_remediation = options?.suggested_remediation;
     }
 }
 //# sourceMappingURL=ollama.js.map

package/dist/tui/openai-compatible.d.ts

@@ -15,6 +15,7 @@ export interface OpenAICompatibleChatRequest {
     messages: OpenAICompatibleChatMessage[];
     temperature?: number;
     topP?: number;
+    onProviderEvent?: (event: OpenAICompatibleProviderEvent) => void;
 }
 export interface OpenAICompatibleChatChunk {
     text: string;
@@ -22,6 +23,18 @@ export interface OpenAICompatibleChatChunk {
     promptTokens?: number;
     completionTokens?: number;
 }
+export type OpenAICompatibleAdapterStage = "streaming_chat" | "non_streaming_chat" | "completions";
+export interface OpenAICompatibleProviderEvent {
+    provider: string;
+    stage: OpenAICompatibleAdapterStage;
+    event: "attempt" | "success" | "fallback" | "parse_error";
+    reason?: string;
+    statusCode?: number;
+    next_stage?: OpenAICompatibleAdapterStage;
+    fallback_count?: number;
+    sample_hex?: string;
+    sample_text?: string;
+}
 export interface ProviderConfigOverride {
     baseUrl?: string;
     apiKey?: string;