@juspay/neurolink 9.40.0 → 9.42.0

package/dist/types/taskTypes.d.ts

@@ -0,0 +1,275 @@
+/**
+ * Type definitions for the NeuroLink TaskManager system.
+ *
+ * TaskManager provides scheduled and self-running task capabilities,
+ * enabling AI agents to execute prompts on cron, interval, or one-shot schedules.
+ */
+import type { Cron } from "croner";
+import type { createClient } from "redis";
+import type { ThinkingLevel } from "./configTypes.js";
+export type TaskScheduleType = "cron" | "interval" | "once";
+export type CronSchedule = {
+    type: "cron";
+    /** Standard 5-field cron expression, e.g. "0 9 * * *" */
+    expression: string;
+    /** IANA timezone, e.g. "America/New_York" */
+    timezone?: string;
+};
+export type IntervalSchedule = {
+    type: "interval";
+    /** Interval in milliseconds */
+    every: number;
+};
+export type OnceSchedule = {
+    type: "once";
+    /** ISO 8601 timestamp or Date object */
+    at: Date | string;
+};
+export type TaskSchedule = CronSchedule | IntervalSchedule | OnceSchedule;
+/**
+ * - "isolated": Each run gets a fresh context. No memory of previous runs.
+ * - "continuation": Conversation history is preserved across runs.
+ */
+export type TaskExecutionMode = "isolated" | "continuation";
+export type TaskStatus = "pending" | "active" | "paused" | "completed" | "failed" | "cancelled";
+export type TaskDefinition = {
+    name: string;
+    prompt: string;
+    schedule: TaskSchedule;
+    mode?: TaskExecutionMode;
+    provider?: string;
+    model?: string;
+    thinkingLevel?: ThinkingLevel;
+    systemPrompt?: string;
+    /** Enable/disable tools for this task. Default: true */
+    tools?: boolean;
+    maxTokens?: number;
+    temperature?: number;
+    /** Max number of executions. Omit for unlimited. */
+    maxRuns?: number;
+    /** Per-run timeout in ms. Default: 120000 */
+    timeout?: number;
+    retry?: {
+        /** Default: 3 */
+        maxAttempts?: number;
+        /** Default: [30000, 60000, 300000] */
+        backoffMs?: number[];
+    };
+    onSuccess?: (result: TaskRunResult) => void | Promise<void>;
+    onError?: (error: TaskRunError) => void | Promise<void>;
+    /** Called when task reaches a terminal state (completed, failed, cancelled) */
+    onComplete?: (task: Task) => void | Promise<void>;
+    metadata?: Record<string, unknown>;
+};
+export type Task = {
+    id: string;
+    name: string;
+    prompt: string;
+    schedule: TaskSchedule;
+    mode: TaskExecutionMode;
+    status: TaskStatus;
+    provider?: string;
+    model?: string;
+    thinkingLevel?: ThinkingLevel;
+    systemPrompt?: string;
+    tools: boolean;
+    maxTokens?: number;
+    temperature?: number;
+    maxRuns?: number;
+    timeout: number;
+    retry: {
+        maxAttempts: number;
+        backoffMs: number[];
+    };
+    runCount: number;
+    lastRunAt?: string;
+    nextRunAt?: string;
+    createdAt: string;
+    updatedAt: string;
+    /** Conversation session ID for continuation mode */
+    sessionId?: string;
+    metadata?: Record<string, unknown>;
+};
+/** Shape of the tasks.json file used by FileTaskStore */
+export type TasksFile = {
+    version: number;
+    tasks: Record<string, Task>;
+};
+export type TaskRunResult = {
+    taskId: string;
+    runId: string;
+    status: "success" | "error";
+    /** AI response text */
+    output?: string;
+    toolCalls?: Array<{
+        name: string;
+        input: unknown;
+        output: unknown;
+    }>;
+    tokensUsed?: {
+        input: number;
+        output: number;
+    };
+    durationMs: number;
+    /** ISO 8601 */
+    timestamp: string;
+    error?: string;
+};
+export type TaskRunError = {
+    taskId: string;
+    runId: string;
+    error: string;
+    attempt: number;
+    maxAttempts: number;
+    willRetry: boolean;
+    /** ISO 8601 */
+    timestamp: string;
+};
+/**
+ * Abstracts task persistence. Auto-selected based on backend:
+ * - BullMQ → RedisTaskStore
+ * - NodeTimeout → FileTaskStore
+ */
+export interface TaskStore {
+    readonly type: "redis" | "file";
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    save(task: Task): Promise<void>;
+    get(taskId: string): Promise<Task | null>;
+    list(filter?: {
+        status?: TaskStatus;
+    }): Promise<Task[]>;
+    update(taskId: string, updates: Partial<Task>): Promise<Task>;
+    delete(taskId: string): Promise<void>;
+    appendRun(taskId: string, run: TaskRunResult): Promise<void>;
+    getRuns(taskId: string, options?: {
+        limit?: number;
+        status?: string;
+    }): Promise<TaskRunResult[]>;
+    appendHistory(taskId: string, messages: ConversationEntry[]): Promise<void>;
+    getHistory(taskId: string): Promise<ConversationEntry[]>;
+    clearHistory(taskId: string): Promise<void>;
+}
+export type ConversationEntry = {
+    role: "user" | "assistant";
+    content: string;
+    timestamp: string;
+};
+export type TaskExecutorFn = (task: Task) => Promise<TaskRunResult>;
+/**
+ * Abstracts the scheduling/looping mechanism.
+ * Implementations: BullMQ (production), NodeTimeout (development).
+ */
+export interface TaskBackend {
+    readonly name: string;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    /** Schedule a task for execution */
+    schedule(task: Task, executor: TaskExecutorFn): Promise<void>;
+    /** Cancel a scheduled task */
+    cancel(taskId: string): Promise<void>;
+    /** Pause a task's schedule */
+    pause(taskId: string): Promise<void>;
+    /** Resume a paused task */
+    resume(taskId: string): Promise<void>;
+    /** Check if backend is operational */
+    isHealthy(): Promise<boolean>;
+}
+/** Redis client type used by RedisTaskStore */
+export type RedisClient = ReturnType<typeof createClient>;
+/** Minimal interface for the NeuroLink SDK methods needed by TaskExecutor */
+export type NeuroLinkExecutable = {
+    generate(optionsOrPrompt: unknown): Promise<{
+        content: string;
+        toolExecutions?: Array<{
+            name: string;
+            input: unknown;
+            output: unknown;
+        }>;
+        usage?: {
+            input?: number;
+            output?: number;
+        };
+    }>;
+};
+/** Internal scheduling entry used by NodeTimeoutBackend */
+export type ScheduledEntry = {
+    taskId: string;
+    executor: TaskExecutorFn;
+    task: Task;
+    cronJob?: Cron;
+    intervalId?: ReturnType<typeof setInterval>;
+    timeoutId?: ReturnType<typeof setTimeout>;
+};
+export type TaskBackendName = "bullmq" | "node-timeout";
+export type TaskBackendFactoryFn = (config: TaskManagerConfig) => Promise<TaskBackend>;
+export type TaskRetentionConfig = {
+    /** Auto-delete completed tasks after N ms. Default: 30 days */
+    completedTTL?: number;
+    /** Auto-delete failed tasks after N ms. Default: 7 days */
+    failedTTL?: number;
+    /** Auto-delete cancelled tasks after N ms. Default: 7 days */
+    cancelledTTL?: number;
+    /** Auto-expire individual run log entries after N ms. Default: 30 days */
+    runLogTTL?: number;
+};
+export type TaskManagerConfig = {
+    /** Default: true */
+    enabled?: boolean;
+    /** Default: "bullmq" */
+    backend?: TaskBackendName;
+    redis?: {
+        host?: string;
+        port?: number;
+        password?: string;
+        db?: number;
+        /** Alternative: full Redis URL */
+        url?: string;
+    };
+    /** Default: ".neurolink/tasks/tasks.json" */
+    storePath?: string;
+    /** Default: ".neurolink/tasks/runs/" */
+    logsPath?: string;
+    /** Maximum number of tasks that can exist at once. Default: 100 */
+    maxTasks?: number;
+    /** Default: 5 */
+    maxConcurrentRuns?: number;
+    /** Max run log entries per task. Default: 2000 */
+    maxRunLogs?: number;
+    /** Max continuation history entries per task. Default: 200 (100 exchanges) */
+    maxHistoryEntries?: number;
+    taskRetention?: TaskRetentionConfig;
+};
+export declare const TASK_DEFAULTS: {
+    readonly enabled: true;
+    readonly maxTasks: 100;
+    readonly backend: TaskBackendName;
+    readonly mode: TaskExecutionMode;
+    readonly timeout: 120000;
+    readonly maxConcurrentRuns: 5;
+    readonly maxRunLogs: 2000;
+    readonly maxHistoryEntries: 200;
+    readonly tools: true;
+    readonly retry: {
+        readonly maxAttempts: 3;
+        readonly backoffMs: readonly [30000, 60000, 300000];
+    };
+    readonly storePath: ".neurolink/tasks/tasks.json";
+    readonly logsPath: ".neurolink/tasks/runs/";
+    readonly redis: {
+        readonly host: "localhost";
+        readonly port: 6379;
+    };
+    readonly retention: {
+        readonly completedTTL: number;
+        readonly failedTTL: number;
+        readonly cancelledTTL: number;
+        readonly runLogTTL: number;
+    };
+};
+/** State persisted by the CLI task worker daemon */
+export type WorkerState = {
+    pid: number;
+    startedAt: string;
+    logFile: string;
+};

package/dist/types/taskTypes.js

@@ -0,0 +1,36 @@
+/**
+ * Type definitions for the NeuroLink TaskManager system.
+ *
+ * TaskManager provides scheduled and self-running task capabilities,
+ * enabling AI agents to execute prompts on cron, interval, or one-shot schedules.
+ */
+// ── Defaults ────────────────────────────────────────────
+const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+export const TASK_DEFAULTS = {
+    enabled: true,
+    maxTasks: 100,
+    backend: "bullmq",
+    mode: "isolated",
+    timeout: 120_000,
+    maxConcurrentRuns: 5,
+    maxRunLogs: 2000,
+    maxHistoryEntries: 200,
+    tools: true,
+    retry: {
+        maxAttempts: 3,
+        backoffMs: [30_000, 60_000, 300_000],
+    },
+    storePath: ".neurolink/tasks/tasks.json",
+    logsPath: ".neurolink/tasks/runs/",
+    redis: {
+        host: "localhost",
+        port: 6379,
+    },
+    retention: {
+        completedTTL: THIRTY_DAYS_MS,
+        failedTTL: SEVEN_DAYS_MS,
+        cancelledTTL: SEVEN_DAYS_MS,
+        runLogTTL: THIRTY_DAYS_MS,
+    },
+};

package/dist/utils/messageBuilder.js

@@ -775,6 +775,7 @@ async function processUnifiedFilesArray(options, maxSize, provider) {
         return;
     }
     const totalFiles = options.input.files.length;
+    const files = options.input.files;
     return withSpan({
         name: "neurolink.file.process_all",
         tracer: tracers.file,
@@ -787,8 +788,8 @@ async function processUnifiedFilesArray(options, maxSize, provider) {
         options.input.text = options.input.text || "";
         let includedCount = 0;
         const fileRegistry = options.fileRegistry;
-        for (let fileIdx = 0; fileIdx < options.input.files.length; fileIdx++) {
-            const file = options.input.files[fileIdx];
+        for (let fileIdx = 0; fileIdx < files.length; fileIdx++) {
+            const file = files[fileIdx];
             const filename = extractFilename(file, fileIdx);
             try {
                 // ─── Lazy file registration path ──────────────────────────────

package/dist/utils/providerHealth.d.ts

@@ -98,6 +98,20 @@ export declare class ProviderHealthChecker {
      * Check Azure OpenAI configuration
      */
     private static checkAzureConfig;
+    private static getLiteLLMBaseUrl;
+    private static getLiteLLMModelsUrl;
+    private static getConfiguredLiteLLMModel;
+    private static getOllamaBaseUrl;
+    private static getOllamaTagsUrl;
+    private static getConfiguredOllamaModel;
+    private static fetchJsonWithTimeout;
+    private static normalizeModelList;
+    private static hasRequestedModel;
+    private static getOllamaAvailableModels;
+    private static getLiteLLMAvailableModels;
+    private static checkOllamaAvailability;
+    private static checkLiteLLMAvailability;
+    private static checkLiteLLMConfig;
     /**
      * Check Ollama configuration
      */
@@ -169,6 +183,10 @@ export declare class ProviderHealthChecker {
      * Clear health cache for a provider or all providers
      */
     static clearHealthCache(providerName?: AIProviderName): void;
+    static checkFallbackProviderAvailability(providerName: string, model: string): Promise<{
+        available: boolean;
+        reason?: string;
+    }>;
     /**
      * Get the best healthy provider from a list of options (NON-BLOCKING)
      * Prioritizes healthy providers over configured but unhealthy ones

package/dist/utils/providerHealth.js

@@ -228,7 +228,8 @@ export class ProviderHealthChecker {
         }
         // Providers that don't use API keys directly
         if (providerName === AIProviderName.OLLAMA ||
-            providerName === AIProviderName.BEDROCK) {
+            providerName === AIProviderName.BEDROCK ||
+            providerName === AIProviderName.LITELLM) {
             healthStatus.hasApiKey = true;
             return;
         }
@@ -368,6 +369,8 @@ export class ProviderHealthChecker {
                 return [];
             case AIProviderName.AZURE:
                 return ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT"];
+            case AIProviderName.LITELLM:
+                return [];
             case AIProviderName.OLLAMA:
                 return []; // Ollama typically doesn't require API keys
             default:
@@ -391,8 +394,10 @@ export class ProviderHealthChecker {
                 return "AWS_ACCESS_KEY_ID";
             case AIProviderName.AZURE:
                 return "AZURE_OPENAI_API_KEY";
+            case AIProviderName.LITELLM:
+                return "LITELLM_API_KEY";
             case AIProviderName.OLLAMA:
-                return "OLLAMA_API_BASE";
+                return "OLLAMA_BASE_URL";
             default:
                 return "";
         }
@@ -416,6 +421,8 @@ export class ProviderHealthChecker {
                 return apiKey.length >= API_KEY_LENGTHS.AWS_ACCESS_KEY; // AWS access key length
             case AIProviderName.AZURE:
                 return apiKey.length >= API_KEY_LENGTHS.AZURE_MIN; // Azure OpenAI API key length
+            case AIProviderName.LITELLM:
+                return apiKey.length > 0;
             case AIProviderName.OLLAMA:
                 return true; // Ollama usually doesn't require specific format
             default:
@@ -437,8 +444,10 @@ export class ProviderHealthChecker {
                 return null; // Complex authentication required
             case AIProviderName.BEDROCK:
                 return null; // AWS endpoints vary by region
+            case AIProviderName.LITELLM:
+                return this.getLiteLLMModelsUrl();
             case AIProviderName.OLLAMA:
-                return "http://localhost:11434/api/version";
+                return this.getOllamaTagsUrl();
             default:
                 return null;
         }
@@ -457,6 +466,9 @@ export class ProviderHealthChecker {
             case AIProviderName.AZURE:
                 await this.checkAzureConfig(healthStatus);
                 break;
+            case AIProviderName.LITELLM:
+                await this.checkLiteLLMConfig(healthStatus);
+                break;
             case AIProviderName.OLLAMA:
                 await this.checkOllamaConfig(healthStatus);
                 break;
@@ -648,15 +660,177 @@ export class ProviderHealthChecker {
             healthStatus.recommendations.push("Set one of: AZURE_OPENAI_MODEL, AZURE_OPENAI_DEPLOYMENT, or AZURE_OPENAI_DEPLOYMENT_ID");
         }
     }
+    static getLiteLLMBaseUrl() {
+        return process.env.LITELLM_BASE_URL || "http://localhost:4000";
+    }
+    static getLiteLLMModelsUrl() {
+        return new URL("/v1/models", this.getLiteLLMBaseUrl()).toString();
+    }
+    static getConfiguredLiteLLMModel() {
+        return process.env.LITELLM_MODEL || "openai/gpt-4o-mini";
+    }
+    static getOllamaBaseUrl() {
+        return (process.env.OLLAMA_BASE_URL ||
+            process.env.OLLAMA_API_BASE ||
+            "http://localhost:11434");
+    }
+    static getOllamaTagsUrl() {
+        return new URL("/api/tags", this.getOllamaBaseUrl()).toString();
+    }
+    static getConfiguredOllamaModel() {
+        return process.env.OLLAMA_MODEL || "llama3.1:8b";
+    }
+    static async fetchJsonWithTimeout(url, options = {}) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), options.timeout ?? this.DEFAULT_TIMEOUT);
+        try {
+            const proxyFetch = createProxyFetch();
+            const response = await proxyFetch(url, {
+                method: "GET",
+                headers: options.headers,
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    static normalizeModelList(models) {
+        return models
+            .map((entry) => {
+            if (typeof entry === "string") {
+                return entry;
+            }
+            if (entry &&
+                typeof entry === "object" &&
+                "id" in entry &&
+                typeof entry.id === "string") {
+                return entry.id;
+            }
+            if (entry &&
+                typeof entry === "object" &&
+                "name" in entry &&
+                typeof entry.name === "string") {
+                return entry.name;
+            }
+            return null;
+        })
+            .filter((model) => typeof model === "string");
+    }
+    static hasRequestedModel(availableModels, requestedModel) {
+        return availableModels.some((model) => model === requestedModel ||
+            model.startsWith(`${requestedModel}:`) ||
+            requestedModel.startsWith(`${model}:`));
+    }
+    static async getOllamaAvailableModels(timeout = 2000) {
+        const payload = (await this.fetchJsonWithTimeout(this.getOllamaTagsUrl(), {
+            timeout,
+        }));
+        return this.normalizeModelList(payload.models ?? []);
+    }
+    static async getLiteLLMAvailableModels(timeout = 2000) {
+        const payload = (await this.fetchJsonWithTimeout(this.getLiteLLMModelsUrl(), {
+            timeout,
+            headers: {
+                Authorization: `Bearer ${process.env.LITELLM_API_KEY || "sk-anything"}`,
+                "Content-Type": "application/json",
+            },
+        }));
+        return this.normalizeModelList(payload.data ?? []);
+    }
+    static async checkOllamaAvailability(options) {
+        try {
+            const models = await this.getOllamaAvailableModels(options.timeout);
+            if (!this.hasRequestedModel(models, options.model)) {
+                return {
+                    available: false,
+                    reason: `Configured Ollama model '${options.model}' is not installed`,
+                    models,
+                };
+            }
+            return { available: true, models };
+        }
+        catch (error) {
+            return {
+                available: false,
+                reason: error instanceof Error ? error.message : String(error),
+                models: [],
+            };
+        }
+    }
+    static async checkLiteLLMAvailability(options) {
+        try {
+            const models = await this.getLiteLLMAvailableModels(options.timeout);
+            if (models.length === 0) {
+                return {
+                    available: false,
+                    reason: "LiteLLM returned an empty model list",
+                    models,
+                };
+            }
+            if (!this.hasRequestedModel(models, options.model)) {
+                return {
+                    available: false,
+                    reason: `Configured LiteLLM model '${options.model}' is not exposed by the proxy`,
+                    models,
+                };
+            }
+            return { available: true, models };
+        }
+        catch (error) {
+            return {
+                available: false,
+                reason: error instanceof Error ? error.message : String(error),
+                models: [],
+            };
+        }
+    }
+    static async checkLiteLLMConfig(healthStatus) {
+        const liteLLMBase = this.getLiteLLMBaseUrl();
+        if (!liteLLMBase.startsWith("http")) {
+            healthStatus.isConfigured = false;
+            healthStatus.configurationIssues.push("Invalid LITELLM_BASE_URL format");
+            healthStatus.recommendations.push("Set LITELLM_BASE_URL to a valid URL (e.g., http://localhost:4000)");
+            return;
+        }
+        const availability = await this.checkLiteLLMAvailability({
+            model: this.getConfiguredLiteLLMModel(),
+            timeout: 2000,
+        });
+        if (!availability.available) {
+            healthStatus.isConfigured = false;
+            healthStatus.configurationIssues.push(`LiteLLM runtime check failed: ${availability.reason ?? "unknown error"}`);
+            healthStatus.recommendations.push("Start the LiteLLM proxy and ensure the configured model is available from /v1/models");
+            return;
+        }
+        healthStatus.isConfigured = true;
+    }
     /**
      * Check Ollama configuration
      */
     static async checkOllamaConfig(healthStatus) {
-        const ollamaBase = process.env.OLLAMA_API_BASE || "http://localhost:11434";
+        const ollamaBase = this.getOllamaBaseUrl();
         if (!ollamaBase.startsWith("http")) {
-            healthStatus.configurationIssues.push("Invalid OLLAMA_API_BASE format");
-            healthStatus.recommendations.push("Set OLLAMA_API_BASE to a valid URL (e.g., http://localhost:11434)");
+            healthStatus.isConfigured = false;
+            healthStatus.configurationIssues.push("Invalid OLLAMA_BASE_URL format (OLLAMA_API_BASE is still accepted as a legacy alias)");
+            healthStatus.recommendations.push("Set OLLAMA_BASE_URL to a valid URL (e.g., http://localhost:11434). OLLAMA_API_BASE remains supported as a legacy alias.");
+            return;
         }
+        const availability = await this.checkOllamaAvailability({
+            model: this.getConfiguredOllamaModel(),
+            timeout: 2000,
+        });
+        if (!availability.available) {
+            healthStatus.isConfigured = false;
+            healthStatus.configurationIssues.push(`Ollama runtime check failed: ${availability.reason ?? "unknown error"}`);
+            healthStatus.recommendations.push("Start Ollama and install the configured model before using Ollama as a fallback provider");
+            return;
+        }
+        healthStatus.isConfigured = true;
     }
     /**
      * Get common models for a provider
@@ -703,8 +877,21 @@ export class ProviderHealthChecker {
                 return [BedrockModels.CLAUDE_3_SONNET, BedrockModels.CLAUDE_3_HAIKU];
             case AIProviderName.AZURE:
                 return [OpenAIModels.GPT_4O, OpenAIModels.GPT_4O_MINI, "gpt-35-turbo"];
-            case AIProviderName.OLLAMA:
-                return ["llama3.2:latest", "llama3.1:latest", "mistral:latest"];
+            case AIProviderName.LITELLM:
+                return [
+                    "openai/gpt-4o-mini",
+                    "anthropic/claude-3-haiku",
+                    "google/gemini-2.5-flash",
+                ];
+            case AIProviderName.OLLAMA: {
+                const envModel = process.env.OLLAMA_MODEL;
+                const defaults = [
+                    "llama3.2:latest",
+                    "llama3.1:latest",
+                    "mistral:latest",
+                ];
+                return envModel ? [envModel, ...defaults] : defaults;
+            }
             default:
                 return [];
         }
@@ -1139,18 +1326,61 @@ export class ProviderHealthChecker {
             this.consecutiveFailures.clear();
         }
     }
+    static async checkFallbackProviderAvailability(providerName, model) {
+        const provider = providerName;
+        if (provider === AIProviderName.OLLAMA) {
+            const availability = await this.checkOllamaAvailability({
+                model,
+                timeout: 2000,
+            });
+            return {
+                available: availability.available,
+                reason: availability.reason,
+            };
+        }
+        if (provider === AIProviderName.LITELLM) {
+            const availability = await this.checkLiteLLMAvailability({
+                model,
+                timeout: 2000,
+            });
+            return {
+                available: availability.available,
+                reason: availability.reason,
+            };
+        }
+        try {
+            const health = await this.checkProviderHealth(provider, {
+                includeConnectivityTest: false,
+                cacheResults: true,
+                maxCacheAge: 15_000,
+                timeout: 2000,
+            });
+            return {
+                available: health.isHealthy,
+                reason: health.error || health.configurationIssues[0] || health.warning,
+            };
+        }
+        catch (error) {
+            return {
+                available: false,
+                reason: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
     /**
      * Get the best healthy provider from a list of options (NON-BLOCKING)
      * Prioritizes healthy providers over configured but unhealthy ones
      * Uses fast, cached health checks to avoid blocking initialization
      */
     static async getBestHealthyProvider(preferredProviders = [
+        "litellm",
+        "ollama",
         "openai",
         "anthropic",
         "vertex",
+        "google-ai",
         "bedrock",
         "azure",
-        "google-ai",
     ]) {
         const healthStatuses = await this.checkAllProvidersHealth({
             includeConnectivityTest: false, // Quick config check only
@@ -1191,6 +1421,7 @@ export class ProviderHealthChecker {
             AIProviderName.OPENAI,
             AIProviderName.BEDROCK,
             AIProviderName.AZURE,
+            AIProviderName.LITELLM,
             AIProviderName.OLLAMA,
         ];
         const healthChecks = providers.map((provider) => this.checkProviderHealth(provider, options));