@iletai/nzb 1.7.3 → 1.8.0

package/dist/api/server.js

@@ -77,8 +77,23 @@ app.get("/stream", (req, res) => {
     sseClients.set(connectionId, res);
     // Heartbeat to keep connection alive
     const heartbeat = setInterval(() => {
-        res.write(`:ping\n\n`);
+        if (res.writableEnded || res.closed) {
+            clearInterval(heartbeat);
+            sseClients.delete(connectionId);
+            return;
+        }
+        try {
+            res.write(`:ping\n\n`);
+        }
+        catch {
+            clearInterval(heartbeat);
+            sseClients.delete(connectionId);
+        }
     }, 20_000);
+    res.on("error", () => {
+        clearInterval(heartbeat);
+        sseClients.delete(connectionId);
+    });
     req.on("close", () => {
         clearInterval(heartbeat);
         sseClients.delete(connectionId);
@@ -196,6 +211,13 @@ app.post("/send-photo", async (req, res) => {
         res.status(500).json({ error: msg });
     }
 });
+// Global error handler — catch unhandled Express errors
+app.use((err, _req, res, _next) => {
+    console.error("[nzb] Express error:", err.message);
+    if (!res.headersSent) {
+        res.status(500).json({ error: "Internal server error" });
+    }
+});
 export function startApiServer() {
     return new Promise((resolve, reject) => {
         const server = app.listen(config.apiPort, "127.0.0.1", () => {

package/dist/cli.js

@@ -45,6 +45,7 @@ Commands:
   tui         Connect to the daemon via terminal UI
   setup       Interactive first-run configuration
   update      Check for updates and install the latest version
+  cron        Manage scheduled cron jobs
   help        Show this help message
 
 Flags (start):
@@ -98,6 +99,101 @@ switch (command) {
         }
         break;
     }
+    case "cron": {
+        const subcommand = args[1] || "list";
+        const { listCronJobs, createCronJob, deleteCronJob, updateCronJob } = await import("./store/cron-store.js");
+        switch (subcommand) {
+            case "list": {
+                const jobs = listCronJobs();
+                if (jobs.length === 0) {
+                    console.log("No cron jobs configured.");
+                }
+                else {
+                    for (const job of jobs) {
+                        const status = job.enabled ? "✅" : "⏸️";
+                        console.log(`${status} ${job.id} — ${job.name} [${job.taskType}] ${job.cronExpression}`);
+                    }
+                }
+                break;
+            }
+            case "add": {
+                const id = args[2];
+                const name = args[3];
+                const cronExpr = args[4];
+                const taskType = args[5];
+                if (!id || !name || !cronExpr || !taskType) {
+                    console.error("Usage: nzb cron add <id> <name> <cron-expression> <task-type> [payload-json]");
+                    console.error("Task types: prompt, health_check, backup, notification, webhook");
+                    process.exit(1);
+                }
+                const validTypes = ["prompt", "health_check", "backup", "notification", "webhook"];
+                if (!validTypes.includes(taskType)) {
+                    console.error(`Invalid task type: ${taskType}. Valid: ${validTypes.join(", ")}`);
+                    process.exit(1);
+                }
+                const { Cron } = await import("croner");
+                try {
+                    new Cron(cronExpr);
+                }
+                catch {
+                    console.error(`Invalid cron expression: ${cronExpr}`);
+                    process.exit(1);
+                }
+                const payload = args[6] || "{}";
+                try {
+                    const job = createCronJob({
+                        id,
+                        name,
+                        cronExpression: cronExpr,
+                        taskType: taskType,
+                        payload,
+                    });
+                    console.log(`Created cron job '${job.id}' (${job.name}): ${job.cronExpression}`);
+                    console.log("Note: The job will be scheduled when the daemon starts.");
+                }
+                catch (err) {
+                    console.error("Error:", err instanceof Error ? err.message : err);
+                    process.exit(1);
+                }
+                break;
+            }
+            case "remove": {
+                const removeId = args[2];
+                if (!removeId) {
+                    console.error("Usage: nzb cron remove <id>");
+                    process.exit(1);
+                }
+                const deleted = deleteCronJob(removeId);
+                console.log(deleted ? `Deleted cron job '${removeId}'.` : `Job '${removeId}' not found.`);
+                break;
+            }
+            case "enable": {
+                const enableId = args[2];
+                if (!enableId) {
+                    console.error("Usage: nzb cron enable <id>");
+                    process.exit(1);
+                }
+                const enabled = updateCronJob(enableId, { enabled: true });
+                console.log(enabled ? `Enabled cron job '${enableId}'.` : `Job '${enableId}' not found.`);
+                break;
+            }
+            case "disable": {
+                const disableId = args[2];
+                if (!disableId) {
+                    console.error("Usage: nzb cron disable <id>");
+                    process.exit(1);
+                }
+                const disabled = updateCronJob(disableId, { enabled: false });
+                console.log(disabled ? `Disabled cron job '${disableId}'.` : `Job '${disableId}' not found.`);
+                break;
+            }
+            default:
+                console.error(`Unknown cron subcommand: ${subcommand}`);
+                console.error("Available: list, add, remove, enable, disable");
+                process.exit(1);
+        }
+        break;
+    }
     case "help":
     case "--help":
     case "-h":

package/dist/config.js

@@ -82,6 +82,10 @@ export const config = {
     groupMentionOnly: process.env.GROUP_MENTION_ONLY !== "false",
     /** Reasoning effort: low | medium | high */
     reasoningEffort: validateEnum(process.env.REASONING_EFFORT, ["low", "medium", "high"], "medium", "REASONING_EFFORT"),
+    /** Model failover chain: comma-separated list of fallback models */
+    modelFailoverChain: process.env.MODEL_FAILOVER_CHAIN?.split(",").map((s) => s.trim()).filter(Boolean) ?? [],
+    /** Cooldown duration (ms) for a model after failure before retrying it */
+    modelCooldownMs: parseInt(process.env.MODEL_COOLDOWN_MS ?? "60000"),
 };
 /** Persist an env variable to ~/.nzb/.env */
 export function persistEnvVar(key, value) {

package/dist/copilot/model-failover.js

@@ -0,0 +1,154 @@
+/**
+ * Model Failover Manager — tracks model health and selects fallback models
+ * when the primary model encounters errors (rate limits, timeouts, etc.).
+ *
+ * When MODEL_FAILOVER_CHAIN is empty, this module is a no-op:
+ * selectModel() returns the configured primary, and getNextFallback() returns undefined.
+ */
+/** Detect the provider from a model name string. */
+export function detectProvider(model) {
+    const lower = model.toLowerCase();
+    if (lower.startsWith("claude-"))
+        return "anthropic";
+    if (lower.startsWith("gpt-") || lower.startsWith("o1-") || lower.startsWith("o3-") || lower.startsWith("o4-"))
+        return "openai";
+    if (lower.startsWith("gemini-"))
+        return "google";
+    return "unknown";
+}
+/** Number of consecutive failures before a model is considered "degraded". */
+const DEGRADED_THRESHOLD = 3;
+export class ModelFailoverManager {
+    chain;
+    cooldownMs;
+    health = new Map();
+    constructor(chain, cooldownMs) {
+        this.chain = Array.isArray(chain) ? chain : [];
+        this.cooldownMs = cooldownMs || 60_000;
+        // Initialise health entries for every model in the chain
+        for (const model of this.chain) {
+            this.health.set(model, {
+                failures: 0,
+                lastFailure: undefined,
+                cooldownUntil: 0,
+                successCount: 0,
+            });
+        }
+    }
+    /** True when at least one fallback model is configured. */
+    get enabled() {
+        return this.chain.length > 0;
+    }
+    /**
+     * Select the best model to use right now.
+     * Returns the first healthy model from the chain, or undefined when the
+     * chain is empty (caller should fall back to `config.copilotModel`).
+     */
+    selectModel() {
+        if (this.chain.length === 0)
+            return undefined;
+        const now = Date.now();
+        for (const model of this.chain) {
+            const h = this.getOrCreate(model);
+            if (now >= h.cooldownUntil)
+                return model;
+        }
+        // All models are on cooldown — pick the one whose cooldown expires soonest
+        let earliest;
+        let earliestTime = Infinity;
+        for (const model of this.chain) {
+            const h = this.getOrCreate(model);
+            if (h.cooldownUntil < earliestTime) {
+                earliestTime = h.cooldownUntil;
+                earliest = model;
+            }
+        }
+        return earliest;
+    }
+    /** Record a successful request for `model`. Resets its failure counter. */
+    recordSuccess(model) {
+        const h = this.getOrCreate(model);
+        h.failures = 0;
+        h.cooldownUntil = 0;
+        h.successCount++;
+    }
+    /** Record a failed request for `model`. Applies cooldown after threshold. */
+    recordFailure(model) {
+        const h = this.getOrCreate(model);
+        h.failures++;
+        h.lastFailure = Date.now();
+        // Apply cooldown immediately on failure so we try a different model next
+        h.cooldownUntil = Date.now() + this.cooldownMs;
+    }
+    /**
+     * Get the next fallback model after `currentModel`.
+     * Prefers a model from a DIFFERENT provider to maximise availability.
+     */
+    getNextFallback(currentModel) {
+        if (this.chain.length === 0)
+            return undefined;
+        const now = Date.now();
+        const currentProvider = detectProvider(currentModel);
+        // First pass: healthy model from a different provider
+        for (const model of this.chain) {
+            if (model === currentModel)
+                continue;
+            const h = this.getOrCreate(model);
+            if (now >= h.cooldownUntil && detectProvider(model) !== currentProvider) {
+                return model;
+            }
+        }
+        // Second pass: any healthy model (same provider is OK)
+        for (const model of this.chain) {
+            if (model === currentModel)
+                continue;
+            const h = this.getOrCreate(model);
+            if (now >= h.cooldownUntil) {
+                return model;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Detect whether an error is a model-level error that warrants failover
+     * (as opposed to a generic connectivity issue that warrants simple retry).
+     */
+    isModelError(err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return /429|rate.?limit|too many requests|quota|capacity|overloaded|model.*not.*available|model.*error|resource.*exhausted/i.test(msg);
+    }
+    /** Return a snapshot of health status for every model in the chain. */
+    getHealthStatus() {
+        return this.chain.map((model) => {
+            const h = this.getOrCreate(model);
+            const now = Date.now();
+            let status;
+            if (h.failures >= DEGRADED_THRESHOLD) {
+                status = "degraded";
+            }
+            else if (now < h.cooldownUntil) {
+                status = "cooldown";
+            }
+            else {
+                status = "healthy";
+            }
+            return {
+                model,
+                provider: detectProvider(model),
+                status,
+                failures: h.failures,
+                successCount: h.successCount,
+                lastFailure: h.lastFailure ? new Date(h.lastFailure).toISOString() : undefined,
+            };
+        });
+    }
+    getOrCreate(model) {
+        let h = this.health.get(model);
+        if (!h) {
+            h = { failures: 0, lastFailure: undefined, cooldownUntil: 0, successCount: 0 };
+            this.health.set(model, h);
+        }
+        return h;
+    }
+}
+//# sourceMappingURL=model-failover.js.map

package/dist/copilot/orchestrator.js

@@ -8,6 +8,7 @@ import { completeTeam, updateTeamMemberResult } from "../store/team-store.js";
 import { formatAge, withTimeout } from "../utils.js";
 import { resetClient } from "./client.js";
 import { loadMcpConfig } from "./mcp-config.js";
+import { ModelFailoverManager } from "./model-failover.js";
 import { getSkillDirectories } from "./skills.js";
 import { getOrchestratorSystemMessage } from "./system-message.js";
 import { createTools } from "./tools.js";
@@ -32,6 +33,8 @@ const workers = new Map();
 const teams = new Map();
 let healthCheckTimer;
 let workerReaperTimer;
+// Model failover manager — initialised lazily in initOrchestrator
+let failoverManager;
 // Persistent orchestrator session
 let orchestratorSession;
 // Coalesces concurrent ensureOrchestratorSession calls
@@ -155,6 +158,8 @@ function startHealthCheck() {
             return;
         if (healthCheckRunning)
             return;
+        if (processing)
+            return; // Don't interfere while processing messages
         healthCheckRunning = true;
         try {
             const state = copilotClient.getState();
@@ -188,17 +193,17 @@ export function stopHealthCheck() {
 function startWorkerReaper() {
     if (workerReaperTimer)
         return;
-    workerReaperTimer = setInterval(() => {
+    workerReaperTimer = setInterval(async () => {
         const maxAge = config.workerTimeoutMs * 2;
         const now = Date.now();
         for (const [name, worker] of workers) {
             if (worker.startedAt && now - worker.startedAt > maxAge) {
                 console.log(`[nzb] Reaping stuck worker '${name}' (age: ${formatAge(worker.startedAt)})`);
                 try {
-                    worker.session.disconnect().catch(() => { });
+                    await withTimeout(worker.session.disconnect(), 5_000, `reaper: worker '${name}'`);
                 }
-                catch {
-                    // Session may already be destroyed
+                catch (err) {
+                    console.error(`[nzb] Reaper: worker '${name}' disconnect failed:`, err instanceof Error ? err.message : err);
                 }
                 workers.delete(name);
                 feedBackgroundResult(name, `⚠ Worker '${name}' was automatically killed after exceeding timeout.`);
@@ -334,6 +339,11 @@ async function createOrResumeSession() {
 export async function initOrchestrator(client) {
     copilotClient = client;
     const { mcpServers, skillDirectories } = getSessionConfig();
+    // Initialise failover manager from config
+    failoverManager = new ModelFailoverManager(config.modelFailoverChain, config.modelCooldownMs);
+    if (failoverManager.enabled) {
+        console.log(`[nzb] Model failover chain: ${config.modelFailoverChain.join(" → ")}`);
+    }
     // Validate configured model against available models (skip for default — saves 1-3s startup)
     if (config.copilotModel !== DEFAULT_MODEL) {
         try {
@@ -522,7 +532,10 @@ async function processQueue() {
     }
     // Re-check for messages that arrived during the last executeOnSession call
     if (messageQueue.length > 0) {
-        void processQueue();
+        processQueue().catch((err) => {
+            console.error("[nzb] processQueue re-check failed:", err instanceof Error ? err.message : err);
+            processing = false;
+        });
     }
 }
 function isRecoverableError(err) {
@@ -560,104 +573,172 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
     const sourceChannel = source.type === "telegram" ? "telegram" : source.type === "tui" ? "tui" : undefined;
     // Enqueue with priority — user messages go before background messages
     void (async () => {
-        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-            try {
-                const finalContent = await new Promise((resolve, reject) => {
-                    const item = {
-                        prompt: taggedPrompt,
-                        attachments,
-                        callback,
-                        onToolEvent,
-                        onUsage,
-                        sourceChannel,
-                        resolve,
-                        reject,
-                    };
-                    if (source.type === "background") {
-                        // Background results go to the back of the queue
-                        messageQueue.push(item);
-                    }
-                    else {
-                        // User messages inserted before any background messages (priority)
-                        const bgIndex = messageQueue.findIndex(isBackgroundMessage);
-                        if (bgIndex >= 0) {
-                            messageQueue.splice(bgIndex, 0, item);
+        // Safety timeout for entire message processing chain.
+        // Uses a flag to prevent double-callback if timeout fires while processing completes.
+        const GLOBAL_MSG_TIMEOUT_MS = 300_000; // 5 minutes
+        let globalTimedOut = false;
+        const globalTimer = setTimeout(() => {
+            globalTimedOut = true;
+            console.error("[nzb] Global message processing timeout (5 min). Force-failing.");
+            Promise.resolve(callback("Error: Message processing timed out after 5 minutes. Please try again.", true)).catch(() => { });
+        }, GLOBAL_MSG_TIMEOUT_MS);
+        try {
+            for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+                try {
+                    const finalContent = await new Promise((resolve, reject) => {
+                        const item = {
+                            prompt: taggedPrompt,
+                            attachments,
+                            callback,
+                            onToolEvent,
+                            onUsage,
+                            sourceChannel,
+                            resolve,
+                            reject,
+                        };
+                        if (source.type === "background") {
+                            // Background results go to the back of the queue
+                            messageQueue.push(item);
                         }
                         else {
-                            messageQueue.push(item);
+                            // User messages inserted before any background messages (priority)
+                            const bgIndex = messageQueue.findIndex(isBackgroundMessage);
+                            if (bgIndex >= 0) {
+                                messageQueue.splice(bgIndex, 0, item);
+                            }
+                            else {
+                                messageQueue.push(item);
+                            }
                         }
+                        processQueue();
+                    });
+                    // Deliver response to user FIRST, then log best-effort
+                    // Record success for failover tracking
+                    if (failoverManager?.enabled) {
+                        failoverManager.recordSuccess(config.copilotModel);
                     }
-                    processQueue();
-                });
-                // Deliver response to user FIRST, then log best-effort
-                try {
-                    logMessage("out", sourceLabel, finalContent);
-                }
-                catch {
-                    /* best-effort */
-                }
-                // Log both sides of the conversation before delivery so we have the row ID
-                let assistantLogId;
-                try {
-                    const telegramMsgId = source.type === "telegram" ? source.messageId : undefined;
-                    logConversation(logRole, prompt, sourceLabel, telegramMsgId);
-                }
-                catch {
-                    /* best-effort */
-                }
-                try {
-                    assistantLogId = logConversation("assistant", finalContent, sourceLabel);
-                }
-                catch {
-                    /* best-effort */
-                }
-                await callback(finalContent, true, { assistantLogId });
-                // Auto-continue: if the response was cut short by timeout, automatically
-                // send a follow-up "Continue" message so the user doesn't have to
-                if (finalContent.includes("⏱ Response was cut short (timeout)") && _autoContinueCount < MAX_AUTO_CONTINUE) {
-                    console.log(`[nzb] Auto-continuing after timeout (${_autoContinueCount + 1}/${MAX_AUTO_CONTINUE})…`);
-                    await sleep(1000);
-                    void sendToOrchestrator("Continue from where you left off. Do not repeat what was already said.", source, callback, onToolEvent, onUsage, _autoContinueCount + 1);
-                }
-                return;
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                // Don't retry cancelled messages
-                if (/cancelled|abort/i.test(msg)) {
-                    return;
-                }
-                // Vision not supported — strip attachments and retry with text-only prompt.
-                // executeOnSession already destroyed the tainted session.
-                if (/not supported for vision/i.test(msg)) {
-                    console.log(`[nzb] Vision not supported — retrying without attachments`);
-                    attachments = undefined;
-                    taggedPrompt =
-                        `[System: The current model '${config.copilotModel}' does not support image/vision analysis. ` +
-                            `The image path is already included in the user's message below. ` +
-                            `Please inform the user that the current model doesn't support direct image analysis, ` +
-                            `and suggest switching to a vision-capable model (e.g. gpt-4o, claude-sonnet-4, gemini-2.0-flash) ` +
-                            `using the /model command.]\n\n${taggedPrompt}`;
-                    continue;
-                }
-                if (isRecoverableError(err) && attempt < MAX_RETRIES) {
-                    const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
-                    console.error(`[nzb] Recoverable error: ${msg}. Retry ${attempt + 1}/${MAX_RETRIES} after ${delay}ms…`);
-                    await sleep(delay);
-                    // Reset client before retry in case the connection is stale
                     try {
-                        await ensureClient();
+                        logMessage("out", sourceLabel, finalContent);
                     }
                     catch {
-                        /* will fail again on next attempt */
+                        /* best-effort */
                     }
-                    continue;
+                    // Log both sides of the conversation before delivery so we have the row ID
+                    let assistantLogId;
+                    try {
+                        const telegramMsgId = source.type === "telegram" ? source.messageId : undefined;
+                        logConversation(logRole, prompt, sourceLabel, telegramMsgId);
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                    try {
+                        assistantLogId = logConversation("assistant", finalContent, sourceLabel);
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                    try {
+                        if (!globalTimedOut) {
+                            await callback(finalContent, true, { assistantLogId });
+                        }
+                    }
+                    catch (callbackErr) {
+                        console.error("[nzb] Callback error after successful response:", callbackErr instanceof Error ? callbackErr.message : callbackErr);
+                    }
+                    // Auto-continue: if the response was cut short by timeout, automatically
+                    // send a follow-up "Continue" message so the user doesn't have to
+                    if (finalContent.includes("⏱ Response was cut short (timeout)") && _autoContinueCount < MAX_AUTO_CONTINUE) {
+                        console.log(`[nzb] Auto-continuing after timeout (${_autoContinueCount + 1}/${MAX_AUTO_CONTINUE})…`);
+                        await sleep(1000);
+                        void sendToOrchestrator("Continue from where you left off. Do not repeat what was already said.", source, callback, onToolEvent, onUsage, _autoContinueCount + 1);
+                    }
+                    return;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    // Don't retry cancelled messages
+                    if (/cancelled|abort/i.test(msg)) {
+                        if (!globalTimedOut) {
+                            try {
+                                await callback("Request was cancelled.", true);
+                            }
+                            catch { /* best-effort */ }
+                        }
+                        return;
+                    }
+                    // Vision not supported — strip attachments and retry with text-only prompt.
+                    // executeOnSession already destroyed the tainted session.
+                    if (/not supported for vision/i.test(msg)) {
+                        console.log(`[nzb] Vision not supported — retrying without attachments`);
+                        attachments = undefined;
+                        taggedPrompt =
+                            `[System: The current model '${config.copilotModel}' does not support image/vision analysis. ` +
+                                `The image path is already included in the user's message below. ` +
+                                `Please inform the user that the current model doesn't support direct image analysis, ` +
+                                `and suggest switching to a vision-capable model (e.g. gpt-4o, claude-sonnet-4, gemini-2.0-flash) ` +
+                                `using the /model command.]\n\n${taggedPrompt}`;
+                        continue;
+                    }
+                    if (isRecoverableError(err) && attempt < MAX_RETRIES) {
+                        // Model failover: if it's a model-level error and we have fallbacks, switch model
+                        if (failoverManager?.enabled && failoverManager.isModelError(err)) {
+                            const failedModel = config.copilotModel;
+                            failoverManager.recordFailure(failedModel);
+                            const fallback = failoverManager.getNextFallback(failedModel);
+                            if (fallback) {
+                                console.log(`[nzb] Model failover: ${failedModel} → ${fallback} (${msg})`);
+                                config.copilotModel = fallback;
+                                // Force session recreation with the new model
+                                orchestratorSession = undefined;
+                                sessionCreatedAt = undefined;
+                                deleteState(ORCHESTRATOR_SESSION_KEY);
+                            }
+                        }
+                        const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
+                        console.error(`[nzb] Recoverable error: ${msg}. Retry ${attempt + 1}/${MAX_RETRIES} after ${delay}ms…`);
+                        await sleep(delay);
+                        // Reset client before retry in case the connection is stale
+                        try {
+                            await ensureClient();
+                        }
+                        catch {
+                            /* will fail again on next attempt */
+                        }
+                        continue;
+                    }
+                    // Model-level error with failover available — try switching model even if not normally recoverable
+                    if (failoverManager?.enabled && failoverManager.isModelError(err) && attempt < MAX_RETRIES) {
+                        const failedModel = config.copilotModel;
+                        failoverManager.recordFailure(failedModel);
+                        const fallback = failoverManager.getNextFallback(failedModel);
+                        if (fallback) {
+                            console.log(`[nzb] Model failover: ${failedModel} → ${fallback} (${msg})`);
+                            config.copilotModel = fallback;
+                            orchestratorSession = undefined;
+                            sessionCreatedAt = undefined;
+                            deleteState(ORCHESTRATOR_SESSION_KEY);
+                            await sleep(RECONNECT_DELAYS_MS[0]);
+                            try {
+                                await ensureClient();
+                            }
+                            catch {
+                                /* will fail again on next attempt */
+                            }
+                            continue;
+                        }
+                    }
+                    console.error(`[nzb] Error processing message: ${msg}`);
+                    if (!globalTimedOut) {
+                        await callback(`Error: ${msg}`, true);
+                    }
+                    return;
                 }
-                console.error(`[nzb] Error processing message: ${msg}`);
-                await callback(`Error: ${msg}`, true);
-                return;
             }
         }
+        finally {
+            clearTimeout(globalTimer);
+        }
     })().catch((err) => {
         console.error(`[nzb] Unhandled error in sendToOrchestrator: ${err instanceof Error ? err.message : String(err)}`);
     });
@@ -733,4 +814,8 @@ export async function compactSession() {
         return `Compaction failed: ${err instanceof Error ? err.message : String(err)}`;
     }
 }
+/** Expose the failover manager so tools can query health status. */
+export function getFailoverManager() {
+    return failoverManager;
+}
 //# sourceMappingURL=orchestrator.js.map