@vierratale/ai 0.1.0-beta.8 → 0.1.0-beta.9

package/src/providers/anthropic.js

@@ -39,7 +39,7 @@ export class AnthropicProvider extends BaseProvider {
 
   async *stream(messages, options = {}) {
     const key = Config.get('anthropicApiKey');
-    if (!key) throw new Error('Anthropic 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 = this._resolveModel(options);
     const systemPrompt = options.systemPrompt || '';
@@ -51,49 +51,80 @@ export class AnthropicProvider extends BaseProvider {
       content: m.content,
     }));
 
-    const resp = await fetch(ANTHROPIC_URL, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': key,
-        'anthropic-version': '2023-06-01',
-      },
-      body: JSON.stringify({
-        model,
-        system: system.length ? system : undefined,
-        messages: apiMessages,
-        max_tokens: options.maxTokens || Config.get('maxTokens'),
-        stream: true,
-        temperature: options.temperature || Config.get('temperature'),
-      }),
-    });
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 240000);
+
+    let resp;
+    try {
+      resp = await fetch(ANTHROPIC_URL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': key,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+          model,
+          system: system.length ? system : undefined,
+          messages: apiMessages,
+          max_tokens: options.maxTokens || Config.get('maxTokens'),
+          stream: true,
+          temperature: options.temperature || Config.get('temperature'),
+        }),
+        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);
+    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);
-          if (json.type === 'content_block_delta' && json.delta?.text) {
-            yield json.delta.text;
+          ({ 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).');
           }
-        } catch {}
+          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);
+            if (json.type === 'content_block_delta' && json.delta?.text) {
+              yield json.delta.text;
+            }
+          } catch {}
+        }
       }
+    } finally {
+      if (idle) clearTimeout(idle);
     }
   }
 }

package/src/providers/base.js

@@ -15,6 +15,16 @@ export class BaseProvider {
     throw new Error('stream() must be implemented');
   }
 
+  // Non-streaming convenience: collects the stream. Providers may override
+  // with a proper single-shot request (see CortexProvider).
+  async complete(messages, options = {}) {
+    let out = '';
+    for await (const chunk of this.stream(messages, options)) {
+      out += chunk;
+    }
+    return out;
+  }
+
   async listModels() {
     throw new Error('listModels() must be implemented');
   }

package/src/providers/cortex.js

@@ -2,6 +2,25 @@ 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');
@@ -42,74 +61,238 @@ export class CortexProvider extends BaseProvider {
 
   async *stream(messages, options = {}) {
     const model = Catalog.getRealModel(options.model || Config.get('model'));
-    const systemPrompt = options.systemPrompt || '';
+    const engineMessages = buildEngineMessages(options.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 });
-    }
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 600000);
 
-    const 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'),
-          temperature: options.temperature || Config.get('temperature'),
-        },
-      }),
-    });
+    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('Failed to connect to backend engine');
+      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 });
+    }
 
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
+    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);
+    }
 
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
+    if (!resp.ok) {
+      throw new Error(await describeEngineError(resp, model));
+    }
 
-      for (const line of lines) {
-        if (!line.trim()) continue;
+    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 {
-          const json = JSON.parse(line);
-          if (json.message?.content) {
-            yield json.message.content;
+          ({ 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).');
           }
-          if (json.done) return;
-        } catch {}
+          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: send a tiny request so ollama loads the model into
-    // memory eagerly, so the first real query doesn't pay the cold-load cost.
+    // 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: false,
+        stream: true,
         keep_alive: Config.get('keepAlive'),
         options: { num_ctx: Config.get('numCtx') },
       }),
-    }).catch(() => {});
+      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

@@ -39,7 +39,7 @@ export class GeminiProvider extends BaseProvider {
 
   async *stream(messages, options = {}) {
     const key = Config.get('geminiApiKey');
-    if (!key) throw new Error('Gemini 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 = this._resolveModel(options);
     const systemPrompt = options.systemPrompt || '';
@@ -52,46 +52,77 @@ export class GeminiProvider extends BaseProvider {
       contents.unshift({ role: 'user', parts: [{ text: `System: ${systemPrompt}` }] });
     }
 
-    const 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'),
-          },
-        }),
+    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('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);
+    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 text = json.candidates?.[0]?.content?.parts?.[0]?.text;
-          if (text) yield text;
-        } 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);
+          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);
     }
   }
 }