@vierratale/ai 0.1.0-beta.5 → 0.1.0-beta.7

package/README.md

@@ -12,27 +12,43 @@ npm install -g @vierratale/ai
 npx @vierratale/ai
 ```
 
+The first launch detects and, if needed, installs and starts the local engine
+(**Cortex** - "secretly" Ollama under the hood), then pulls the model you use.
+
 ## Usage
 
 ```bash
 vierrataleai                          # Start chat (auto-detect provider)
 vierrataleai --provider cortex        # Use local models
-vierrataleai --provider openai        # Use cloud models
+vierrataleai --provider openai        # Use cloud models (OpenAI)
+vierrataleai --provider anthropic     # Use cloud models (Claude)
+vierrataleai --provider gemini        # Use cloud models (Gemini)
 vierrataleai --model vierratale-pro   # Use specific model
 ```
 
 ## Models
 
-| Model | Description |
-|-------|-------------|
-| vierratale-lite | Minimal, fast responses |
-| vierratale-fast | Fast, balanced quality |
-| vierratale-small | Small, efficient |
-| vierratale-balanced | Balanced performance |
-| vierratale-plus | Enhanced capability |
-| vierratale-pro | Professional grade |
-| vierratale-cloud | Cloud-powered |
-| vierratale-cloud-pro | Cloud professional |
+Local models run through the **Cortex** engine:
+
+| Model | Backend |
+|-------|---------|
+| vierratale-lite | qwen2.5-coder:0.5b |
+| vierratale-fast | qwen2.5-coder:1.5b |
+| vierratale-small | qwen2.5-coder:3b |
+| vierratale-balanced | qwen2.5-coder:7b |
+| vierratale-plus | qwen2.5-coder:14b |
+| vierratale-pro | qwen2.5-coder:32b |
+
+Cloud models are available when the matching provider + API key is configured:
+
+| Model | Backend |
+|-------|---------|
+| vierratale-cloud-mini | gpt-4o-mini (OpenAI) |
+| vierratale-cloud | gpt-4o (OpenAI) |
+| vierratale-cloud-fast | claude-3-5-haiku-20241022 (Anthropic) |
+| vierratale-cloud-pro | claude-sonnet-4-20250514 (Anthropic) |
+| vierratale-cloud-lite | gemini-2.0-flash (Gemini) |
+| vierratale-cloud-plus | gemini-1.5-pro (Gemini) |
 
 ## Commands
 
@@ -40,6 +56,7 @@ vierrataleai --model vierratale-pro   # Use specific model
 - `/model [name]` - Switch model
 - `/provider [name]` - Switch provider
 - `/models` - List available models
+- `/system [text]` - Set a custom system prompt / persona
 - `/search <query>` - Search the web and summarize with AI
 - `/clear` - Clear screen
 - `/new` - Start a new conversation (clear memory)
@@ -67,9 +84,11 @@ you can continue where you left off. Use `/new` to start fresh.
 Config file: `~/.config/vierrataleai/config.json`
 
 Environment variables:
-- `VIERRATALE_PROVIDER` - Default provider
+- `VIERRATALE_PROVIDER` - Default provider (auto/cortex/openai/anthropic/gemini)
 - `VIERRATALE_MODEL` - Default model
-- `OPENAI_API_KEY` - OpenAI API key (for cloud models)
+- `OPENAI_API_KEY` - OpenAI API key (openai provider)
+- `ANTHROPIC_API_KEY` - Anthropic API key (anthropic provider)
+- `GEMINI_API_KEY` - Google AI API key (gemini provider)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.5",
+  "version": "0.1.0-beta.7",
   "description": "VierrataleAI - Intelligent terminal assistant",
   "type": "module",
   "bin": {
@@ -11,7 +11,9 @@
     ".": "./src/index.js"
   },
   "scripts": {
-    "start": "node bin/vierrataleai.js"
+    "start": "node bin/vierrataleai.js",
+    "test": "node --test test/",
+    "postinstall": "node scripts/postinstall.js"
   },
   "keywords": ["ai", "chatbot", "terminal", "assistant", "llm"],
   "author": "Vierratale",

package/scripts/postinstall.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// Optional engine setup after install. Never fails the package install.
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+
+const isInstalled = () => {
+  try {
+    execSync('which ollama 2>/dev/null', { stdio: 'ignore' });
+    return true;
+  } catch {}
+  return existsSync('/usr/local/bin/ollama') || existsSync('/usr/bin/ollama');
+};
+
+try {
+  if (isInstalled()) {
+    process.exit(0);
+  }
+
+  const nonInteractive =
+    !process.stdout.isTTY || process.env.CI || process.env.NODE_ENV === 'test';
+
+  // Only auto-install when explicitly requested. Otherwise just inform the user
+  // that the engine will be installed on first launch.
+  if (process.env.VIERRATALE_INSTALL_ENGINE === '1' && !nonInteractive) {
+    execSync('curl -fsSL https://ollama.com/install.sh | sh', { stdio: 'inherit' });
+  } else {
+    console.log(
+      '\n[vierrataleai] The local engine (ollama) was not detected.\n' +
+        '  - Run the CLI: it will attempt to install and start the engine automatically.\n' +
+        '  - Or install it yourself: curl -fsSL https://ollama.com/install.sh | sh\n'
+    );
+  }
+} catch {
+  // Never fail the install because of engine setup.
+}

package/src/catalog.js

@@ -60,6 +60,26 @@ export const Catalog = {
     return 'vierratale-fast';
   },
 
+  getDefaultCloudModel() {
+    return 'vierratale-cloud-mini';
+  },
+
+  isLocalModel(displayName) {
+    return LOCAL_MODELS.includes(displayName);
+  },
+
+  isCloudModel(displayName) {
+    return CLOUD_MODELS.includes(displayName);
+  },
+
+  getVendorForCloudModel(displayName) {
+    const real = REVERSE[displayName];
+    if (real && real.startsWith('claude-')) return 'anthropic';
+    if (real && real.startsWith('gemini-')) return 'gemini';
+    if (real && real.startsWith('gpt-')) return 'openai';
+    return 'openai';
+  },
+
   getModelInfo(displayName) {
     const real = REVERSE[displayName];
     if (!real) return null;

package/src/cli.js

@@ -7,6 +7,7 @@ import { Branding } from './ui/branding.js';
 import { Terminal } from './ui/terminal.js';
 import { loadSystemPrompt, showBanner } from './ui/banner.js';
 import { WebSearch } from './utils/websearch.js';
+import { WebFetch } from './utils/webfetch.js';
 import { detectIntent } from './utils/intents.js';
 import { Session } from './session.js';
 
@@ -41,6 +42,7 @@ Commands (in chat):
   /provider [name]        Switch provider
   /models                 List available models
   /search <query>         Search the web and summarize with AI
+  /fetch <url>            Open a link and summarize its content
   /clear                  Clear screen
   /new                    Start a new conversation (clear memory)
   /quit                   Exit
@@ -72,7 +74,55 @@ async function answerWithSearch(messages, provider, query, systemPrompt) {
   let response = '';
   try {
     for await (const chunk of provider.stream(messages, {
-      model: Config.get('model'),
+      model: Config.getEffectiveModel(provider.name),
+      systemPrompt,
+    })) {
+      Terminal.printAIChunk(chunk);
+      response += chunk;
+    }
+  } catch (err) {
+    Terminal.printError(err.message || 'Stream error');
+  }
+  Terminal.printAIEnd();
+  if (response) {
+    messages.push({ role: 'assistant', content: response });
+  }
+  Session.save(messages);
+}
+
+function extractUrlFromText(text) {
+  const m = text.match(/https?:\/\/[^\s<>"']+/i);
+  return m ? m[0] : null;
+}
+
+async function answerWithFetch(messages, provider, url, systemPrompt) {
+  Terminal.printInfo(`Opening ${url}...`);
+  let page;
+  try {
+    page = await WebFetch.fetch(url);
+  } catch (err) {
+    Terminal.printError(err.message || 'Could not fetch the link.');
+    return;
+  }
+
+  Terminal.printSuccess(`Opened: ${page.title || page.url}`);
+  const content = page.text.trim();
+  if (!content) {
+    Terminal.printWarning('Nothing readable found on that page.');
+    return;
+  }
+
+  messages.push({
+    role: 'user',
+    content: `Here is the content fetched from the URL "${page.url}" (${page.title || 'no title'}):\n\n${content}\n\nPlease summarize and answer based on this content. Be concise.`,
+  });
+  Session.save(messages);
+
+  Terminal.printAIStart();
+  let response = '';
+  try {
+    for await (const chunk of provider.stream(messages, {
+      model: Config.getEffectiveModel(provider.name),
       systemPrompt,
     })) {
       Terminal.printAIChunk(chunk);
@@ -102,21 +152,32 @@ async function chat(provider, systemPrompt) {
     terminal: false,
   });
 
+  let eof = false;
+  let pendingResolver = null;
+
   rl.on('close', () => {
-    if (!exited) {
-      exited = true;
-      process.exit(0);
+    // Graceful shutdown: don't hard-exit mid-command. Mark EOF so the loop
+    // stops asking for more input, and let any in-flight command finish.
+    eof = true;
+    if (pendingResolver) {
+      pendingResolver(null);
+      pendingResolver = null;
     }
   });
 
   const prompt = () => new Promise((resolve) => {
+    if (eof) return resolve(null);
+    pendingResolver = resolve;
     rl.question(
       `\n${Branding.colors.bold}${Branding.colors.primary}┌ ${Branding.USER_PROMPT}${Branding.colors.reset} `,
-      resolve
+      (ans) => {
+        pendingResolver = null;
+        resolve(ans);
+      }
     );
   });
 
-  while (!exited) {
+  while (!exited && !eof) {
     let input;
     try {
       input = await prompt();
@@ -140,7 +201,7 @@ async function chat(provider, systemPrompt) {
 
     if (cmd === '/clear') {
       Terminal.clear();
-      showBanner(provider.name, Config.get('model'), provider.displayName);
+      showBanner(provider.name, Config.getEffectiveModel(provider.name), provider.displayName);
       continue;
     }
 
@@ -157,13 +218,13 @@ async function chat(provider, systemPrompt) {
     }
 
     if (cmd === '/models') {
-      const models = provider.name === 'cortex'
+      const models = provider.isLocal
         ? Catalog.getLocalModels()
         : Catalog.getCloudModels();
       Terminal.printInfo('Available models:');
       for (const m of models) {
         const info = Catalog.getModelInfo(m);
-        const current = m === Config.get('model') ? ' (active)' : '';
+        const current = m === Config.getEffectiveModel(provider.name) ? ' (active)' : '';
         console.log(`  ${Branding.colors.accent}${m}${Branding.colors.dim}${current} - ${info.tier}${Branding.colors.reset}`);
       }
       continue;
@@ -174,6 +235,7 @@ async function chat(provider, systemPrompt) {
       if (modelName) {
         if (Catalog.getModelInfo(modelName)) {
           Config.save({ model: modelName });
+          Config.setProviderModel(provider.name, modelName);
           Terminal.printSuccess(`Model: ${modelName}`);
         } else {
           Terminal.printError(`Unknown model: ${modelName}`);
@@ -183,13 +245,13 @@ async function chat(provider, systemPrompt) {
     }
 
     if (cmd === '/model') {
-      Terminal.printInfo(`Current model: ${Config.get('model')}`);
+      Terminal.printInfo(`Current model: ${Config.getEffectiveModel(provider.name)}`);
       continue;
     }
 
     if (cmd.startsWith('/provider ')) {
       const prov = cmd.split(' ')[1];
-      if (['cortex', 'openai'].includes(prov)) {
+      if (['cortex', 'openai', 'anthropic', 'gemini'].includes(prov)) {
         Config.save({ provider: prov });
         const next = ProviderFactory.create(prov);
         if (next && await next.isAvailable()) {
@@ -209,6 +271,22 @@ async function chat(provider, systemPrompt) {
       continue;
     }
 
+    if (cmd.startsWith('/system')) {
+      const prompt = trimmed.slice(7).trim();
+      if (prompt.toLowerCase() === 'reset') {
+        Config.save({ systemPrompt: '' });
+        systemPrompt = loadSystemPrompt();
+        Terminal.printSuccess('System prompt reset to default.');
+      } else if (prompt) {
+        Config.save({ systemPrompt: prompt });
+        systemPrompt = prompt;
+        Terminal.printSuccess('System prompt updated.');
+      } else {
+        Terminal.printInfo(`Current system prompt: ${systemPrompt}`);
+      }
+      continue;
+    }
+
     if (cmd.startsWith('/search ')) {
       const query = trimmed.slice(8).trim();
       if (!query) {
@@ -219,6 +297,16 @@ async function chat(provider, systemPrompt) {
       continue;
     }
 
+    if (cmd.startsWith('/fetch ') || cmd === '/fetch') {
+      const urlPart = trimmed.slice(6).trim().split(/\s+/)[0];
+      if (!urlPart) {
+        Terminal.printWarning('Usage: /fetch <url>');
+        continue;
+      }
+      await answerWithFetch(messages, provider, urlPart, systemPrompt);
+      continue;
+    }
+
     const intent = detectIntent(trimmed);
     if (intent.type === 'knowledge') {
       Terminal.printSuccess(`Auto-search: "${trimmed}"`);
@@ -226,6 +314,16 @@ async function chat(provider, systemPrompt) {
       continue;
     }
 
+    // If the message contains a bare URL, open it automatically and ask the AI to summarize.
+    if (/https?:\/\/\S+/i.test(trimmed)) {
+      const url = extractUrlFromText(trimmed);
+      if (url) {
+        Terminal.printSuccess(`Auto-open link detected. Fetching...`);
+        await answerWithFetch(messages, provider, url, systemPrompt);
+        continue;
+      }
+    }
+
     messages.push({ role: 'user', content: trimmed });
     Session.save(messages);
     Terminal.printAIStart();
@@ -233,7 +331,7 @@ async function chat(provider, systemPrompt) {
     let response = '';
     try {
       for await (const chunk of provider.stream(messages, {
-        model: Config.get('model'),
+        model: Config.getEffectiveModel(provider.name),
         systemPrompt,
       })) {
         Terminal.printAIChunk(chunk);
@@ -280,7 +378,7 @@ export async function run() {
   Config.save({ provider: provider.name });
 
   if (args.clear) Terminal.clear();
-  showBanner(provider.name, Config.get('model'), provider.displayName);
+  showBanner(provider.name, Config.getEffectiveModel(provider.name), provider.displayName);
 
   const systemPrompt = loadSystemPrompt();
   await chat(provider, systemPrompt);

package/src/config.js

@@ -9,9 +9,10 @@ const DEFAULTS = {
   provider: 'auto',
   model: 'vierratale-fast',
   engineHost: 'http://127.0.0.1:11434',
-  numCtx: 8192,
+  numCtx: 2048,
   temperature: 0.7,
   maxTokens: 4096,
+  keepAlive: '5m',
 };
 
 function loadConfigFile() {
@@ -39,11 +40,15 @@ export const Config = {
       provider: getEnv('VIERRATALE_PROVIDER', file.provider || DEFAULTS.provider),
       model: getEnv('VIERRATALE_MODEL', file.model || DEFAULTS.model),
       engineHost: getEnv('VIERRATALE_ENGINE_HOST', engineHost),
-      numCtx: parseInt(getEnv('VIERRATALE_NUM_CTX', String(file.numCtx || DEFAULTS.numCtx))),
-      temperature: parseFloat(getEnv('VIERRATALE_TEMPERATURE', String(file.temperature || DEFAULTS.temperature))),
-      maxTokens: parseInt(getEnv('VIERRATALE_MAX_TOKENS', String(file.maxTokens || DEFAULTS.maxTokens))),
+      numCtx: parseInt(getEnv('VIERRATALE_NUM_CTX', String(file.numCtx ?? DEFAULTS.numCtx))),
+      temperature: parseFloat(getEnv('VIERRATALE_TEMPERATURE', String(file.temperature ?? DEFAULTS.temperature))),
+      maxTokens: parseInt(getEnv('VIERRATALE_MAX_TOKENS', String(file.maxTokens ?? DEFAULTS.maxTokens))),
+      keepAlive: getEnv('VIERRATALE_KEEP_ALIVE', file.keepAlive ?? DEFAULTS.keepAlive),
       openaiApiKey: getEnv('OPENAI_API_KEY', file.openaiApiKey || ''),
       anthropicApiKey: getEnv('ANTHROPIC_API_KEY', file.anthropicApiKey || ''),
+      geminiApiKey: getEnv('GEMINI_API_KEY', file.geminiApiKey || ''),
+      systemPrompt: file.systemPrompt || '',
+      providerModels: file.providerModels || {},
     };
     return this._config;
   },
@@ -58,6 +63,22 @@ export const Config = {
     return { ...this._config };
   },
 
+  getProviderModel(provider) {
+    if (!this._config) this.load();
+    return this._config.providerModels?.[provider] || null;
+  },
+
+  setProviderModel(provider, model) {
+    if (!this._config) this.load();
+    this._config.providerModels = this._config.providerModels || {};
+    this._config.providerModels[provider] = model;
+    this.save();
+  },
+
+  getEffectiveModel(provider) {
+    return this.getProviderModel(provider) || this.get('model');
+  },
+
   save(overrides = {}) {
     if (!existsSync(CONFIG_DIR)) {
       mkdirSync(CONFIG_DIR, { recursive: true });

package/src/providers/anthropic.js

@@ -0,0 +1,99 @@
+import { BaseProvider } from './base.js';
+import { Catalog } from '../catalog.js';
+import { Config } from '../config.js';
+
+const ANTHROPIC_URL = 'https://api.anthropic.com/v1/messages';
+
+export class AnthropicProvider extends BaseProvider {
+  constructor() {
+    super('anthropic');
+  }
+
+  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('claude-') ? real : 'claude-3-5-haiku-20241022';
+  }
+
+  async isAvailable() {
+    const key = Config.get('anthropicApiKey');
+    return Boolean(key);
+  }
+
+  async listModels() {
+    const key = Config.get('anthropicApiKey');
+    if (!key) return [];
+    const models = Object.keys(Catalog.getAllModels()).filter((m) => m.startsWith('claude-'));
+    return models.map((real) => ({
+      realName: real,
+      displayName: Catalog.getDisplayName(real),
+    }));
+  }
+
+  async *stream(messages, options = {}) {
+    const key = Config.get('anthropicApiKey');
+    if (!key) throw new Error('Anthropic API key not configured');
+
+    const model = this._resolveModel(options);
+    const systemPrompt = options.systemPrompt || '';
+
+    const system = [];
+    if (systemPrompt) system.push({ type: 'text', text: systemPrompt });
+    const apiMessages = messages.map((m) => ({
+      role: m.role === 'assistant' ? 'assistant' : 'user',
+      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'),
+      }),
+    });
+
+    if (!resp.ok) {
+      throw new Error('Failed to connect to cloud engine');
+    }
+
+    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);
+        try {
+          const json = JSON.parse(data);
+          if (json.type === 'content_block_delta' && json.delta?.text) {
+            yield json.delta.text;
+          }
+        } catch {}
+      }
+    }
+  }
+}

package/src/providers/base.js

@@ -7,6 +7,10 @@ export class BaseProvider {
     return 'Cortex';
   }
 
+  get isLocal() {
+    return false;
+  }
+
   async *stream(messages, options = {}) {
     throw new Error('stream() must be implemented');
   }

package/src/providers/cortex.js

@@ -12,6 +12,10 @@ export class CortexProvider extends BaseProvider {
     return 'Cortex';
   }
 
+  get isLocal() {
+    return true;
+  }
+
   async isAvailable() {
     try {
       const resp = await fetch(`${this.host}/api/tags`, { signal: AbortSignal.timeout(3000) });
@@ -55,6 +59,7 @@ export class CortexProvider extends BaseProvider {
         model,
         messages: engineMessages,
         stream: true,
+        keep_alive: Config.get('keepAlive'),
         options: {
           num_ctx: Config.get('numCtx'),
           temperature: options.temperature || Config.get('temperature'),

package/src/providers/gemini.js

@@ -0,0 +1,97 @@
+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('Gemini API key not configured');
+
+    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 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'),
+          },
+        }),
+      }
+    );
+
+    if (!resp.ok) {
+      throw new Error('Failed to connect to cloud engine');
+    }
+
+    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);
+        try {
+          const json = JSON.parse(data);
+          const text = json.candidates?.[0]?.content?.parts?.[0]?.text;
+          if (text) yield text;
+        } catch {}
+      }
+    }
+  }
+}

package/src/providers/index.js

@@ -1,5 +1,7 @@
 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 = {};
@@ -9,6 +11,8 @@ function getProviders() {
     providers = {
       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 ['cortex', 'openai']) {
+    for (const name of ['cortex', 'openai', 'anthropic', 'gemini']) {
       if (await ps[name].isAvailable()) return ps[name];
     }
 

package/src/providers/openai.js

@@ -45,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');
 
-    const model = Catalog.getRealModel(options.model || Config.get('model'));
+    const model = this._resolveModel(options);
     const systemPrompt = options.systemPrompt || '';
 
     const apiMessages = [];

package/src/ui/banner.js

@@ -3,10 +3,13 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { Branding } from './branding.js';
 import { Terminal } from './terminal.js';
+import { Config } from '../config.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 export function loadSystemPrompt() {
+  const custom = Config.get('systemPrompt');
+  if (custom) return custom;
   try {
     const jsonPath = join(__dirname, '..', 'prompts', 'system.json');
     const data = JSON.parse(readFileSync(jsonPath, 'utf-8'));
@@ -20,16 +23,18 @@ export function showBanner(providerName, model, providerDisplayName) {
   const C = Branding.colors;
   const width = 44;
   const border = `  ╔${'═'.repeat(width)}╗`;
+  const visible = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+  const pad = (s) => s + ' '.repeat(Math.max(1, width - visible(s).length));
 
   console.log();
   console.log(`${C.primary}${Branding.BANNER}${C.reset}`);
-  console.log(`  ${C.bold}${C.accent}▸ Vierratale AI ▸ Cortex Engine${C.reset}`);
+  console.log(`  ${C.bold}${C.accent}▸ Vierratale AI ▸ ${providerDisplayName || 'Cortex'} Engine${C.reset}`);
   console.log();
   console.log(border);
-  console.log(`  ║  ${C.bold}${C.primary}Model${C.reset}${' '.repeat(width - 12)}║`);
-  console.log(`  ║   ${C.accent}${model}${C.reset}${' '.repeat(Math.max(1, width - 5 - model.length))}║`);
-  console.log(`  ║  ${C.bold}${C.primary}Engine${C.reset}${' '.repeat(width - 13)}║`);
-  console.log(`  ║   ${C.accent}${providerDisplayName || 'Cortex'}${C.reset}${' '.repeat(Math.max(1, width - 7 - (providerDisplayName || 'Cortex').length))}║`);
+  console.log(`  ║${pad('  ' + C.bold + C.primary + 'Model' + C.reset)}║`);
+  console.log(`  ║${pad('   ' + C.accent + model + C.reset)}║`);
+  console.log(`  ║${pad('  ' + C.bold + C.primary + 'Engine' + C.reset)}║`);
+  console.log(`  ║${pad('   ' + C.accent + (providerDisplayName || 'Cortex') + C.reset)}║`);
   console.log(`  ╚${'═'.repeat(width)}╝`);
   console.log();
   console.log(`  ${C.dim}Type /help for commands · /quit to exit${C.reset}`);

package/src/ui/branding.js

@@ -1,6 +1,6 @@
 export const Branding = {
   APP_NAME: 'VierrataleAI',
-  VERSION: '0.1.0-beta.5',
+  VERSION: '0.1.0-beta.6',
 
   colors: {
     primary: '\x1b[38;2;124;58;237m',

package/src/utils/webfetch.js

@@ -0,0 +1,115 @@
+const UA = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36';
+
+const MAX_BYTES = 200000; // 200KB cap
+const MAX_TEXT = 8000;    // ~8k chars of readable text
+
+const BLOCK_TAGS = new Set([
+  'script', 'style', 'noscript', 'svg', 'head', 'title',
+  'nav', 'footer', 'aside', 'iframe', 'form', 'button', 'noscript',
+]);
+
+export class WebFetch {
+  static normalizeUrl(input) {
+    const trimmed = (input || '').trim();
+    if (!trimmed) return null;
+    let url = trimmed;
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) {
+      // Already has an explicit scheme — must be http(s).
+      if (!/^https?:\/\//i.test(url)) return null;
+    } else if (!/^https?:\/\//i.test(url)) {
+      url = `https://${url}`;
+    }
+    try {
+      const u = new URL(url);
+      if (u.protocol !== 'http:' && u.protocol !== 'https:') return null;
+      return u.toString();
+    } catch {
+      return null;
+    }
+  }
+
+  static async fetch(rawUrl, maxText = MAX_TEXT) {
+    const url = this.normalizeUrl(rawUrl);
+    if (!url) {
+      throw new Error('Invalid URL. Provide a valid http(s) address.');
+    }
+
+    let resp;
+    try {
+      resp = await fetch(url, {
+        headers: { 'User-Agent': UA, Accept: 'text/html,application/xhtml+xml' },
+        redirect: 'follow',
+        signal: AbortSignal.timeout(15000),
+      });
+    } catch {
+      throw new Error(`Could not reach ${url}`);
+    }
+
+    if (!resp.ok) {
+      throw new Error(`Request failed (${resp.status}) for ${url}`);
+    }
+
+    // Refuse to read the whole body past the cap.
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder('utf-8', { fatal: false });
+    let html = '';
+    let received = 0;
+    while (received < MAX_BYTES) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      received += value.length;
+      html += decoder.decode(value, { stream: true });
+    }
+    reader.cancel();
+    html += decoder.decode();
+
+    return {
+      url: resp.url || url,
+      title: this._extractTitle(html),
+      text: this._extractText(html).slice(0, maxText),
+    };
+  }
+
+  static _extractTitle(html) {
+    const m = /<title[^>]*>([^<]*)<\/title>/i.exec(html);
+    return m ? this._stripEntities(m[1].trim()) : '';
+  }
+
+  static _extractText(html) {
+    // Strip block tags' contents that add no readable value.
+    let s = html.replace(/<(script|style|noscript|svg|head|iframe|form|nav|footer|aside)[^>]*>[\s\S]*?<\/\1>/gi, ' ');
+
+    // Force spacing around block-level elements so words don't merge.
+    s = s.replace(/<\/(p|div|h[1-6]|li|tr|br|section|article)>/gi, '\n');
+    s = s.replace(/<(br|li|tr)[^>]*>/gi, '\n');
+
+    // Remove remaining tags.
+    s = s.replace(/<[^>]+>/g, ' ');
+
+    // College entities.
+    s = this._stripEntities(s);
+
+    // Collapse whitespace and trim lines.
+    return s
+      .replace(/[ \t]+/g, ' ')
+      .replace(/ *\n */g, '\n')
+      .replace(/\n{3,}/g, '\n\n')
+      .replace(/[ \t]+/g, ' ')
+      .replace(/\u00a0/g, ' ')
+      .trim();
+  }
+
+  static _stripEntities(text) {
+    const map = {
+      '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"',
+      '&#39;': "'", '&#039;': "'", '&apos;': "'", '&nbsp;': ' ',
+      '&ndash;': '–', '&mdash;': '—', '&hellip;': '...', '&copy;': '©',
+      '&#x27;': "'", '&rsquo;': '’', '&lsquo;': '‘', '&ldquo;': '“', '&rdquo;': '”',
+    };
+    return String(text)
+      .replace(/<[^>]*>/g, '')
+      .replace(/&[a-zA-Z0-9#]+;/g, (m) => map[m] ?? '')
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+}