zubo 0.1.19 → 0.1.21

package/src/llm/factory.ts

@@ -8,6 +8,47 @@ import { FailoverProvider } from "./failover";
 import { SmartRouterProvider } from "./smart-router";
 import { logger } from "../util/logger";
 
+/**
+ * Query Ollama's /api/show endpoint to get the actual context window for a model.
+ * Returns the detected context length, or null if unavailable.
+ */
+export async function detectOllamaContextWindow(
+  model: string,
+  baseUrl: string = "http://localhost:11434"
+): Promise<number | null> {
+  try {
+    const res = await fetch(`${baseUrl}/api/show`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: model }),
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!res.ok) return null;
+    const data = (await res.json()) as any;
+
+    // Ollama returns model parameters with num_ctx or context_length
+    const params = data.model_info ?? data.details ?? {};
+    for (const [key, val] of Object.entries(params)) {
+      if (
+        (key.includes("context_length") || key === "num_ctx") &&
+        typeof val === "number" &&
+        val > 0
+      ) {
+        return val;
+      }
+    }
+
+    // Also check modelfile parameters
+    const modelfile = data.parameters ?? "";
+    const match = typeof modelfile === "string" && modelfile.match(/num_ctx\s+(\d+)/);
+    if (match) return parseInt(match[1], 10);
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 const KNOWN_BASE_URLS: Record<string, string> = {
   openai: "https://api.openai.com/v1",
   groq: "https://api.groq.com/openai/v1",
@@ -67,7 +108,7 @@ function buildSingleProvider(
   });
 }
 
-export function createProvider(config: ZuboConfig): LlmProvider {
+export async function createProvider(config: ZuboConfig): Promise<LlmProvider> {
   // New multi-provider config
   if (config.providers && config.activeProvider) {
     const activeCfg = config.providers[config.activeProvider];
@@ -78,7 +119,18 @@ export function createProvider(config: ZuboConfig): LlmProvider {
     }
 
     const primary = buildSingleProvider(config.activeProvider, activeCfg);
-    logger.info(`LLM provider: ${primary.providerName}/${primary.model}`);
+
+    // Auto-detect context window for local providers if not explicitly set
+    if (!activeCfg.contextWindow && (config.activeProvider === "ollama" || config.activeProvider === "lmstudio")) {
+      const ollamaBase = activeCfg.baseUrl?.replace(/\/v1\/?$/, "") ?? "http://localhost:11434";
+      const detected = await detectOllamaContextWindow(activeCfg.model, ollamaBase);
+      if (detected) {
+        primary.contextWindow = detected;
+        logger.info(`Auto-detected context window for ${activeCfg.model}: ${detected} tokens`);
+      }
+    }
+
+    logger.info(`LLM provider: ${primary.providerName}/${primary.model} (context: ${primary.contextWindow})`);
 
     // Build failover chain
     let provider: LlmProvider = primary;
@@ -128,3 +180,30 @@ export function createProvider(config: ZuboConfig): LlmProvider {
     "No LLM provider configured. Run 'zubo setup' or add a providers section to config.json"
   );
 }
+
+/**
+ * Quick connectivity check — sends a minimal request to verify the API key works.
+ * Returns null on success, or a friendly error message on failure.
+ */
+export async function validateProvider(provider: LlmProvider): Promise<string | null> {
+  try {
+    await provider.chat({
+      system: "Respond with OK.",
+      messages: [{ role: "user", content: "Say OK" }],
+      maxTokens: 8,
+    });
+    return null;
+  } catch (err: any) {
+    const msg = err.message ?? String(err);
+    if (msg.includes("401") || msg.includes("Unauthorized") || msg.includes("invalid")) {
+      return `API key is invalid. Double-check your key for ${provider.providerName}.`;
+    }
+    if (msg.includes("404") || msg.includes("not found")) {
+      return `Model "${provider.model}" not found on ${provider.providerName}. Check the model name.`;
+    }
+    if (msg.includes("ECONNREFUSED") || msg.includes("fetch failed") || msg.includes("Connection refused")) {
+      return `Cannot reach ${provider.providerName}. Make sure the server is running.`;
+    }
+    return `${provider.providerName} test failed: ${msg}`;
+  }
+}

package/src/llm/failover.ts

@@ -1,10 +1,21 @@
 import type { LlmProvider, LlmRequest, LlmResponse, LlmStreamEvent } from "./provider";
+import { compactMessages } from "../agent/compaction";
 import { logger } from "../util/logger";
 
+/** Re-compact messages if the target provider has a smaller context window. */
+function fitToProvider(request: LlmRequest, provider: LlmProvider): LlmRequest {
+  const compacted = compactMessages(request.messages, provider.contextWindow);
+  if (compacted === request.messages) return request;
+  return { ...request, messages: compacted };
+}
+
+const PRIMARY_RETRY_INTERVAL_MS = 60_000; // Retry primary after 60 seconds
+
 export class FailoverProvider implements LlmProvider {
   providerName: string;
   model: string;
   contextWindow: number;
+  private failedOverAt: number = 0;
 
   constructor(
     private primary: LlmProvider,
@@ -15,9 +26,40 @@ export class FailoverProvider implements LlmProvider {
     this.contextWindow = primary.contextWindow;
   }
 
+  private get isOnPrimary(): boolean {
+    return this.providerName === this.primary.providerName &&
+      this.model === this.primary.model;
+  }
+
+  private restorePrimary(): void {
+    this.providerName = this.primary.providerName;
+    this.model = this.primary.model;
+    this.contextWindow = this.primary.contextWindow;
+    this.failedOverAt = 0;
+    logger.info(`Recovered to primary provider: ${this.primary.providerName}/${this.primary.model}`);
+  }
+
+  private shouldRetryPrimary(): boolean {
+    return !this.isOnPrimary &&
+      this.failedOverAt > 0 &&
+      Date.now() - this.failedOverAt >= PRIMARY_RETRY_INTERVAL_MS;
+  }
+
   async chat(request: LlmRequest): Promise<LlmResponse> {
+    // If we're on a fallback, periodically retry the primary
+    if (this.shouldRetryPrimary()) {
+      try {
+        const result = await this.primary.chat(fitToProvider(request, this.primary));
+        this.restorePrimary();
+        return result;
+      } catch {
+        // Primary still down, continue with fallbacks below
+        this.failedOverAt = Date.now();
+      }
+    }
+
     try {
-      return await this.primary.chat(request);
+      return await this.primary.chat(fitToProvider(request, this.primary));
     } catch (err: any) {
       logger.warn(`Primary provider (${this.primary.providerName}) failed`, {
         error: err.message,
@@ -26,9 +68,10 @@ export class FailoverProvider implements LlmProvider {
       for (const fb of this.fallbacks) {
         try {
           logger.info(`Trying fallback: ${fb.providerName}/${fb.model}`);
-          const result = await fb.chat(request);
+          const result = await fb.chat(fitToProvider(request, fb));
           this.providerName = fb.providerName;
           this.model = fb.model;
+          this.failedOverAt = Date.now();
           return result;
         } catch (fbErr: any) {
           logger.warn(`Fallback ${fb.providerName} also failed`, {
@@ -52,7 +95,7 @@ export class FailoverProvider implements LlmProvider {
       if (!provider.chatStream) return null;
       const events: LlmStreamEvent[] = [];
       try {
-        for await (const event of provider.chatStream(request)) {
+        for await (const event of provider.chatStream(fitToProvider(request, provider))) {
           if (events.length >= MAX_STREAM_EVENTS) {
             throw new Error(`Stream exceeded maximum event limit (${MAX_STREAM_EVENTS})`);
           }
@@ -67,6 +110,17 @@ export class FailoverProvider implements LlmProvider {
       }
     }
 
+    // If we're on a fallback, periodically retry the primary
+    if (this.shouldRetryPrimary()) {
+      const retryEvents = await collectStream(this.primary);
+      if (retryEvents) {
+        this.restorePrimary();
+        for (const event of retryEvents) yield event;
+        return;
+      }
+      this.failedOverAt = Date.now();
+    }
+
     // Try primary
     const primaryEvents = await collectStream(this.primary);
     if (primaryEvents) {
@@ -80,12 +134,13 @@ export class FailoverProvider implements LlmProvider {
       if (fbEvents) {
         this.providerName = fb.providerName;
         this.model = fb.model;
+        this.failedOverAt = Date.now();
         for (const event of fbEvents) yield event;
         return;
       }
     }
 
-    // If no provider supports streaming, fall back to non-streaming
+    // If no provider supports streaming, fall back to non-streaming (chat() already handles fitToProvider)
     logger.info("No streaming providers available, falling back to non-streaming");
     const response = await this.chat(request);
     for (const block of response.content) {

package/src/llm/smart-router.ts

@@ -4,8 +4,16 @@ import type {
   LlmResponse,
   LlmStreamEvent,
 } from "./provider";
+import { compactMessages } from "../agent/compaction";
 import { logger } from "../util/logger";
 
+/** Re-compact messages if the target provider has a smaller context window. */
+function fitToProvider(request: LlmRequest, provider: LlmProvider): LlmRequest {
+  const compacted = compactMessages(request.messages, provider.contextWindow);
+  if (compacted === request.messages) return request;
+  return { ...request, messages: compacted };
+}
+
 const CODE_MARKERS = [
   "```",
   "function ",
@@ -163,16 +171,16 @@ export class SmartRouterProvider implements LlmProvider {
 
     if (provider === this.fast) {
       try {
-        return await provider.chat(request);
+        return await provider.chat(fitToProvider(request, provider));
       } catch (err: any) {
         logger.warn("Fast model failed, falling back to primary", {
           error: err.message,
         });
-        return this.primary.chat(request);
+        return this.primary.chat(fitToProvider(request, this.primary));
       }
     }
 
-    return provider.chat(request);
+    return provider.chat(fitToProvider(request, provider));
   }
 
   async *chatStream(request: LlmRequest): AsyncIterable<LlmStreamEvent> {
@@ -185,7 +193,7 @@ export class SmartRouterProvider implements LlmProvider {
         const events: LlmStreamEvent[] = [];
         let succeeded = false;
         try {
-          for await (const event of provider.chatStream(request)) {
+          for await (const event of provider.chatStream(fitToProvider(request, provider))) {
             if (events.length >= MAX_STREAM_EVENTS) {
               throw new Error(`Stream exceeded maximum event limit (${MAX_STREAM_EVENTS})`);
             }
@@ -214,9 +222,9 @@ export class SmartRouterProvider implements LlmProvider {
 
     // Use primary model (streaming or non-streaming fallback)
     if (this.primary.chatStream) {
-      yield* this.primary.chatStream(request);
+      yield* this.primary.chatStream(fitToProvider(request, this.primary));
     } else {
-      const response = await this.primary.chat(request);
+      const response = await this.primary.chat(fitToProvider(request, this.primary));
       for (const block of response.content) {
         if (block.type === "text" && block.text) {
           yield { type: "text_delta", text: block.text };

package/src/memory/knowledge-graph.ts

@@ -326,7 +326,7 @@ export function getGraph(
 export function findMentionedEntities(db: Database, text: string, limit: number = 5): KgEntity[] {
   try {
     const allNames = db.query(
-      "SELECT DISTINCT name FROM kg_entities ORDER BY length(name) DESC"
+      "SELECT DISTINCT name FROM kg_entities ORDER BY length(name) DESC LIMIT 500"
     ).all() as { name: string }[];
 
     const lowerText = text.toLowerCase();

package/src/memory/vector-index.ts

@@ -41,7 +41,7 @@ export async function vectorSearch(
 
   const rows = db
     .query(
-      "SELECT id, content, source_file, embedding FROM memory_chunks WHERE embedding IS NOT NULL ORDER BY id DESC LIMIT 5000"
+      "SELECT id, content, source_file, embedding FROM memory_chunks WHERE embedding IS NOT NULL ORDER BY id DESC LIMIT 500"
     )
     .all() as Array<{
     id: number;

package/src/scheduler/visual-workflows.ts

@@ -154,7 +154,7 @@ async function executeAgentStep(
   const { agentLoop } = await import("../agent/loop");
 
   const appConfig = await loadConfig();
-  const llm = createProvider(appConfig);
+  const llm = await createProvider(appConfig);
   const result = await agentLoop(llm, `workflow:${workflowId}`, resolvedPrompt);
 
   const output = result.reply;