@vierratale/ai 0.1.0-beta.1 → 0.1.0-beta.11

package/src/providers/cortex.js

@@ -0,0 +1,298 @@
+import { BaseProvider } from './base.js';
+import { Catalog } from '../catalog.js';
+import { Config } from '../config.js';
+
+// Keep the prompt a local engine must re-process per call bounded: the
+// system prompt plus the most recent messages. Sending the whole growing
+// history makes prompt-processing time unbounded on slow hardware.
+const MAX_CONTEXT_MESSAGES = 12;
+
+function buildEngineMessages(systemPrompt, messages) {
+  const engineMessages = [];
+  if (systemPrompt) {
+    engineMessages.push({ role: 'system', content: systemPrompt });
+  }
+  for (const msg of messages) {
+    engineMessages.push({ role: msg.role, content: msg.content });
+  }
+  if (engineMessages.length > MAX_CONTEXT_MESSAGES) {
+    return [engineMessages[0], ...engineMessages.slice(-(MAX_CONTEXT_MESSAGES - 1))];
+  }
+  return engineMessages;
+}
+
+export class CortexProvider extends BaseProvider {
+  constructor() {
+    super('cortex');
+    this.host = Config.get('engineHost');
+  }
+
+  get displayName() {
+    return 'Cortex';
+  }
+
+  get isLocal() {
+    return true;
+  }
+
+  async isAvailable() {
+    try {
+      const resp = await fetch(`${this.host}/api/tags`, { signal: AbortSignal.timeout(3000) });
+      return resp.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async listModels() {
+    try {
+      const resp = await fetch(`${this.host}/api/tags`);
+      if (!resp.ok) return [];
+      const data = await resp.json();
+      return (data.models || []).map((m) => ({
+        realName: m.name,
+        displayName: Catalog.getDisplayName(m.name),
+        size: m.size,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  async *stream(messages, options = {}) {
+    const model = Catalog.getRealModel(options.model || Config.get('model'));
+    const engineMessages = buildEngineMessages(options.systemPrompt || '', messages);
+
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 600000);
+
+    let resp;
+    try {
+      resp = await fetch(`${this.host}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model,
+          messages: engineMessages,
+          stream: true,
+          keep_alive: Config.get('keepAlive'),
+          options: {
+            num_ctx: Config.get('numCtx'),
+            num_predict: options.maxTokens ?? Config.get('maxTokens'),
+            temperature: options.temperature || Config.get('temperature'),
+            num_thread: Config.get('numThreads'),
+          },
+        }),
+        signal: controller.signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not reach the engine (no response within 600s). Make sure the local engine is running.');
+      }
+      throw new Error('[ERR-0001] Could not reach the engine (no response). Make sure the local engine is running.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
+
+    if (!resp.ok) {
+      throw new Error(await describeEngineError(resp, model));
+    }
+
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 420000);
+    };
+    settle();
+    try {
+      while (true) {
+        let value, done;
+        try {
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the engine (no data for 420s).');
+          }
+          throw err;
+        }
+        if (done) break;
+        settle();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const json = JSON.parse(line);
+            if (json.message?.content) {
+              yield json.message.content;
+            }
+            if (json.done) return;
+          } catch {}
+        }
+      }
+    } finally {
+      if (idle) clearTimeout(idle);
+    }
+  }
+
+  // Non-streaming completion (used by the tool-planning step). Reads the
+  // streamed reply incrementally: on a slow engine a full answer can take
+  // minutes, so only a connection with no response for 180s (or an idle
+  // stream for 120s) counts as a failure - not a slowly progressing one.
+  async complete(messages, options = {}) {
+    const model = Catalog.getRealModel(options.model || Config.get('model'));
+    const engineMessages = buildEngineMessages(options.systemPrompt || '', messages);
+
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 600000);
+
+    if (options.signal) {
+      if (options.signal.aborted) controller.abort();
+      else options.signal.addEventListener('abort', () => controller.abort(), { once: true });
+    }
+
+    let resp;
+    try {
+      resp = await fetch(`${this.host}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model,
+          messages: engineMessages,
+          stream: true,
+          keep_alive: Config.get('keepAlive'),
+          options: {
+            num_ctx: Config.get('numCtx'),
+            num_predict: options.maxTokens ?? Config.get('maxTokens'),
+            temperature: options.temperature || Config.get('temperature'),
+            num_thread: Config.get('numThreads'),
+          },
+        }),
+        signal: controller.signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not complete the request (no response within 600s).');
+      }
+      throw new Error('[ERR-0001] Could not reach the engine (no response). Make sure the local engine is running.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
+
+    if (!resp.ok) {
+      throw new Error(await describeEngineError(resp, model));
+    }
+
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 120000);
+    };
+    settle();
+    let output = '';
+    try {
+      while (true) {
+        let value, done;
+        try {
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the engine (no data for 420s).');
+          }
+          throw err;
+        }
+        if (done) break;
+        settle();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const json = JSON.parse(line);
+            if (json.message?.content) {
+              output += json.message.content;
+            }
+            if (json.done) {
+              buffer = '';
+              break;
+            }
+          } catch {}
+        }
+      }
+    } finally {
+      if (idle) clearTimeout(idle);
+      controller.abort();
+    }
+    return output;
+  }
+
+  async warmup() {
+    // Fire-and-forget: ask the engine to load the model eagerly, then abort as
+    // soon as generation starts. The engine runs with a single slot, so an
+    // in-flight non-streaming 'hi' would block the first real request.
+    const model = Catalog.getRealModel(Config.get('model'));
+    const controller = new AbortController();
+    fetch(`${this.host}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: 'hi' }],
+        stream: true,
+        keep_alive: Config.get('keepAlive'),
+        options: { num_ctx: Config.get('numCtx') },
+      }),
+      signal: controller.signal,
+    })
+      .then(async (resp) => {
+        if (!resp.ok || !resp.body) return;
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        for (let i = 0; i < 100; i++) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split('\n');
+          buffer = lines.pop() || '';
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              if (JSON.parse(line).message?.content) {
+                controller.abort();
+                return;
+              }
+            } catch {}
+          }
+        }
+      })
+      .catch(() => {});
+  }
+}
+
+// Build a user-actionable message when the engine rejects a request (e.g. a
+// cloud model name posted to a local engine -> 404 "model not found"). The
+// engine host is deliberately kept out of the message; errors carry codes.
+async function describeEngineError(resp, model) {
+  if (/not found|does not exist|model.*missing/i.test(String(resp.statusText))) {
+    return `[ERR-0002] Model "${model}" is not installed on the engine. If you picked a cloud model, use /model VRTL-6.pro or /provider openai.`;
+  }
+  let body = '';
+  try {
+    body = (await resp.text()).slice(0, 300);
+  } catch {}
+  if (/not found|does not exist|model.*missing/i.test(body)) {
+    return `[ERR-0002] Model "${model}" is not installed on the engine. If you picked a cloud model, use /model VRTL-6.pro or /provider openai.`;
+  }
+  return `[ERR-0003] The engine returned HTTP ${resp.status}. Check the engine status or run /model VRTL-2.fast.`;
+}

package/src/providers/gemini.js

@@ -0,0 +1,128 @@
+import { BaseProvider } from './base.js';
+import { Catalog } from '../catalog.js';
+import { Config } from '../config.js';
+
+const GEMINI_URL = 'https://generativelanguage.googleapis.com/v1beta/models';
+
+export class GeminiProvider extends BaseProvider {
+  constructor() {
+    super('gemini');
+  }
+
+  get displayName() {
+    return 'Nebula';
+  }
+
+  _resolveModel(options) {
+    const requested = options.model || Config.get('model');
+    if (Catalog.isLocalModel(requested) || !Catalog.isCloudModel(requested)) {
+      return Catalog.getRealModel(Catalog.getDefaultCloudModel());
+    }
+    const real = Catalog.getRealModel(requested);
+    return real.startsWith('gemini-') ? real : 'gemini-2.0-flash';
+  }
+
+  async isAvailable() {
+    const key = Config.get('geminiApiKey');
+    return Boolean(key);
+  }
+
+  async listModels() {
+    const key = Config.get('geminiApiKey');
+    if (!key) return [];
+    const models = Object.keys(Catalog.getAllModels()).filter((m) => m.startsWith('gemini-'));
+    return models.map((real) => ({
+      realName: real,
+      displayName: Catalog.getDisplayName(real),
+    }));
+  }
+
+  async *stream(messages, options = {}) {
+    const key = Config.get('geminiApiKey');
+    if (!key) throw new Error('[ERR-0004] Cloud API key not configured. Add it to the config and try again.');
+
+    const model = this._resolveModel(options);
+    const systemPrompt = options.systemPrompt || '';
+
+    const contents = messages.map((m) => ({
+      role: m.role === 'assistant' ? 'model' : 'user',
+      parts: [{ text: m.content }],
+    }));
+    if (systemPrompt) {
+      contents.unshift({ role: 'user', parts: [{ text: `System: ${systemPrompt}` }] });
+    }
+
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 240000);
+
+    let resp;
+    try {
+      resp = await fetch(
+        `${GEMINI_URL}/${model}:streamGenerateContent?key=${key}&alt=sse`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            contents,
+            generationConfig: {
+              temperature: options.temperature || Config.get('temperature'),
+              maxOutputTokens: options.maxTokens || Config.get('maxTokens'),
+            },
+          }),
+          signal: controller.signal,
+        }
+      );
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not reach the API (no response within 60s). Check your network connection.');
+      }
+      throw new Error('[ERR-0001] Could not reach the API (no response). Check your network connection.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
+
+    if (!resp.ok) {
+      throw new Error('[ERR-0003] The cloud provider returned HTTP ' + resp.status + '. Check your API key in config.');
+    }
+
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 240000);
+    };
+    settle();
+    try {
+      while (true) {
+        let value, done;
+        try {
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the cloud API (no data for 60s).');
+          }
+          throw err;
+        }
+        if (done) break;
+        settle();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6);
+          try {
+            const json = JSON.parse(data);
+            const text = json.candidates?.[0]?.content?.parts?.[0]?.text;
+            if (text) yield text;
+          } catch {}
+        }
+      }
+    } finally {
+      if (idle) clearTimeout(idle);
+    }
+  }
+}

package/src/providers/index.js

@@ -1,5 +1,7 @@
-import { OllamaProvider } from './ollama.js';
+import { CortexProvider } from './cortex.js';
 import { OpenAIProvider } from './openai.js';
+import { AnthropicProvider } from './anthropic.js';
+import { GeminiProvider } from './gemini.js';
 import { Config } from '../config.js';
 
 let providers = {};
@@ -7,8 +9,10 @@ let providers = {};
 function getProviders() {
   if (Object.keys(providers).length === 0) {
     providers = {
-      ollama: new OllamaProvider(),
+      cortex: new CortexProvider(),
       openai: new OpenAIProvider(),
+      anthropic: new AnthropicProvider(),
+      gemini: new GeminiProvider(),
     };
   }
   return providers;
@@ -23,7 +27,7 @@ export const ProviderFactory = {
       if (await ps[requested].isAvailable()) return ps[requested];
     }
 
-    for (const name of ['ollama', 'openai']) {
+    for (const name of ['cortex', 'openai', 'anthropic', 'gemini']) {
       if (await ps[name].isAvailable()) return ps[name];
     }
 

package/src/providers/openai.js

@@ -7,6 +7,10 @@ export class OpenAIProvider extends BaseProvider {
     super('openai');
   }
 
+  get displayName() {
+    return 'Nebula';
+  }
+
   async isAvailable() {
     const key = Config.get('openaiApiKey');
     if (!key) return false;
@@ -41,11 +45,21 @@ export class OpenAIProvider extends BaseProvider {
     }
   }
 
+  // If the configured model is a local (ollama) model, use a cloud default so
+  // we never send a qwen model name to the OpenAI API.
+  _resolveModel(options) {
+    const requested = options.model || Config.get('model');
+    if (Catalog.isLocalModel(requested) || !Catalog.isCloudModel(requested)) {
+      return Catalog.getRealModel(Catalog.getDefaultCloudModel());
+    }
+    return Catalog.getRealModel(requested);
+  }
+
   async *stream(messages, options = {}) {
     const key = Config.get('openaiApiKey');
-    if (!key) throw new Error('Cloud API key not configured');
+    if (!key) throw new Error('[ERR-0004] Cloud API key not configured. Add it to the config and try again.');
 
-    const model = Catalog.getRealModel(options.model || Config.get('model'));
+    const model = this._resolveModel(options);
     const systemPrompt = options.systemPrompt || '';
 
     const apiMessages = [];
@@ -56,47 +70,78 @@ export class OpenAIProvider extends BaseProvider {
       apiMessages.push({ role: msg.role, content: msg.content });
     }
 
-    const resp = await fetch('https://api.openai.com/v1/chat/completions', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${key}`,
-      },
-      body: JSON.stringify({
-        model,
-        messages: apiMessages,
-        stream: true,
-        temperature: options.temperature || Config.get('temperature'),
-        max_tokens: options.maxTokens || Config.get('maxTokens'),
-      }),
-    });
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 240000);
+
+    let resp;
+    try {
+      resp = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${key}`,
+        },
+        body: JSON.stringify({
+          model,
+          messages: apiMessages,
+          stream: true,
+          temperature: options.temperature || Config.get('temperature'),
+          max_tokens: options.maxTokens || Config.get('maxTokens'),
+        }),
+        signal: controller.signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not reach the API (no response within 60s). Check your network connection.');
+      }
+      throw new Error('[ERR-0001] Could not reach the API (no response). Check your network connection.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
 
     if (!resp.ok) {
-      throw new Error('Failed to connect to cloud engine');
+      throw new Error('[ERR-0003] The cloud provider returned HTTP ' + resp.status + '. Check your API key in config.');
     }
 
     const reader = resp.body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-
-      for (const line of lines) {
-        if (!line.startsWith('data: ')) continue;
-        const data = line.slice(6);
-        if (data === '[DONE]') return;
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 240000);
+    };
+    settle();
+    try {
+      while (true) {
+        let value, done;
         try {
-          const json = JSON.parse(data);
-          const content = json.choices?.[0]?.delta?.content;
-          if (content) yield content;
-        } catch {}
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the cloud API (no data for 60s).');
+          }
+          throw err;
+        }
+        if (done) break;
+        settle();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6);
+          if (data === '[DONE]') return;
+          try {
+            const json = JSON.parse(data);
+            const content = json.choices?.[0]?.delta?.content;
+            if (content) yield content;
+          } catch {}
+        }
       }
+    } finally {
+      if (idle) clearTimeout(idle);
     }
   }
 }