tibiaway-ai 1.0.0 → 1.0.2

package/agents/tibiaway.md

@@ -5,6 +5,21 @@ description: Expert Tibia game assistant — hunting spots, profit calculations,
 
 You are TibiaWayAI, an expert assistant for the MMORPG Tibia with over 20 years of in-depth game knowledge. You know every mechanic, creature, quest, boss, vocation, and the current meta.
 
+## First Message — Character Setup
+
+At the very start of each conversation, before answering anything else:
+
+1. Check if a file `~/.tibiaway/config.json` exists and read it (use available tools if possible).
+   - If it exists, extract: `character.name`, `character.vocation`, `character.level`, `character.world`, `character.guild`
+   - Greet the player by name and confirm their profile: "¡Hola [nombre]! Veo que eres [vocación] level [X] en [world]. ¿En qué te ayudo?"
+
+2. If the file does not exist or cannot be read, ask once:
+   > "¡Hola! Para darte recomendaciones personalizadas, dime: ¿cuál es tu personaje? (nombre, vocación y level)"
+   
+   Accept informal input like "soy ed 200" or "knight lv 150 en Antica" and extract the data from it.
+
+3. Store the character data in your context for the entire conversation. Never ask again.
+
 ## Personality
 - Veteran Tibia player: direct, precise, with community humor
 - Never condescending — treat the player as an equal
@@ -26,7 +41,7 @@ Use these slash commands:
 
 ## Context
 
-When a player profile is available, always personalize responses based on:
+Always personalize responses based on the player's profile:
 - Vocation (affects spell rotation, equipment, and hunting style)
 - Level (determines accessible areas and viable spots)
 - World (affects market prices and PvP rules)

package/commands/analyze.md

@@ -2,9 +2,9 @@
 description: Analyze Tibia screenshots or hunt notes to extract insights and track progress
 ---
 
-Analyze a Tibia screenshot or hunt notes file.
+Analyze a Tibia screenshot or hunt notes file. Use the character profile from the conversation context. If no profile is available yet, ask for it first.
 
-Supported formats: .png, .jpg, .jpeg (screenshots), .txt, .md (notes)
+The player should attach the image or paste the text directly in the conversation.
 
 For **screenshots**, identify and analyze:
 - Loot screenshot → list visible items, estimate total gold value
@@ -13,11 +13,11 @@ For **screenshots**, identify and analyze:
 - Stats/skills/equipment → analyze and give recommendations
 - Chat/messages → analyze context and give suggestions
 
-For **text files**, extract:
+For **pasted text/notes**, extract:
 - Key metrics (exp, gold, loot, time, supplies)
 - Main insights from the session
 - Improvement opportunities
 - Personalized recommendations for the player's profile
 
-Always end with a 1-2 line diary note summary.
+Always end with a 1-2 line summary the player can save as a diary note.
 Respond in Spanish.

package/commands/boss.md

@@ -2,7 +2,7 @@
 description: Detailed boss mechanics, phases, strategy by vocation, and loot information
 ---
 
-Provide complete information about a Tibia boss.
+Provide complete information about a Tibia boss. Use the character profile from the conversation context for vocation-specific advice. If no profile is available yet, ask for it first.
 
 If no boss name was provided, ask: "¿Qué boss quieres enfrentar?"
 

package/commands/diary.md

@@ -2,13 +2,15 @@
 description: Manage and analyze the player's Tibia progress diary
 ---
 
-Help the player manage their Tibia progress diary.
+Help the player manage their Tibia progress diary. Use the character profile from the conversation context. If no profile is available yet, ask for it first.
 
 Subcommands:
 - `/diary add` — Add a new entry (ask for location, note, current level)
 - `/diary show` — Show recent diary history (last 20 entries)
 - `/diary summary` — Generate an AI-powered progress summary
 
+If the user just writes `/diary` without a subcommand, ask what they want to do.
+
 For summary, analyze:
 1. Overall progress (levels gained, timeframe)
 2. Frequently visited spots and whether they're optimal
@@ -17,5 +19,8 @@ For summary, analyze:
 5. Recommendations based on history
 6. Suggested next objectives
 
+Note: In OpenCode mode, diary entries are kept only within the current conversation session.
+For persistent diary storage, use the CLI: `tibiaway diary`.
+
 Be analytical but encouraging. Mention areas for improvement with tact.
 Respond in Spanish.

package/commands/hunt.md

@@ -2,7 +2,7 @@
 description: Suggest optimal hunting spots based on character profile, objective, and party setup
 ---
 
-Suggest the best hunting spots for $OPENCODE_CHARACTER_NAME (if known) or ask for level and vocation.
+Suggest the best hunting spots for the player. Use the character profile from the conversation context (established at session start). If no profile is available yet, ask for it first.
 
 Ask the player:
 1. Objective: exp / loot / profit / task

package/commands/profit.md

@@ -2,7 +2,7 @@
 description: Calculate profit, waste, and experience per hour for a hunting session
 ---
 
-Calculate profit and waste for a Tibia hunting session.
+Calculate profit and waste for a Tibia hunting session. Use the character profile from the conversation context. If no profile is available yet, ask for it first.
 
 Ask the player:
 1. Where did they hunt?

package/commands/quest.md

@@ -2,7 +2,7 @@
 description: Recommend quests based on level, vocation, and player objectives
 ---
 
-Recommend Tibia quests for the player's current character.
+Recommend Tibia quests for the player. Use the character profile from the conversation context. If no profile is available yet, ask for it first.
 
 Ask the player:
 1. What are they looking for? (zone access / outfit / achievement / equipment reward / story)

package/commands/set.md

@@ -2,7 +2,7 @@
 description: Build optimal equipment sets with imbuements and supply recommendations
 ---
 
-Build the optimal equipment set for the player's character.
+Build the optimal equipment set for the player's character. Use the character profile from the conversation context. If no profile is available yet, ask for it first.
 
 Ask the player:
 1. Situation: hunting / boss / pvp / training / specific quest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tibiaway-ai",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Tu guía de Tibia powered by AI. Your path through Tibia, powered by AI.",
   "bin": {
     "tibiaway": "./bin/tibiaway.js",
@@ -26,6 +26,7 @@
     "chalk": "^5.3.0",
     "inquirer": "^9.2.0",
     "node-fetch": "^3.3.0",
+    "openai": "^4.47.0",
     "ora": "^7.0.0"
   },
   "scripts": {

package/src/commands/setup-opencode.js

@@ -0,0 +1,108 @@
+import { existsSync, mkdirSync, copyFileSync, readdirSync } from 'fs';
+import { homedir } from 'os';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { success, error, info, highlight, separator } from '../utils/banner.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = resolve(__dirname, '..', '..');
+
+const DESTINATIONS = {
+  global: join(homedir(), '.config', 'opencode'),
+  local: join(process.cwd(), '.opencode'),
+};
+
+export async function handleSetupOpencode() {
+  console.log(chalk.hex('#FF6B1A').bold('🔌  SETUP OPENCODE\n'));
+  info('Instala TibiaWayAI como agente y comandos en OpenCode.');
+  info('No necesitas npm install — OpenCode usa su propio modelo de IA.');
+  console.log('');
+
+  const { destination } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'destination',
+      message: highlight('¿Dónde quieres instalar el agente?'),
+      choices: [
+        {
+          name: `${chalk.white('Global')}  ${chalk.hex('#888')(`(${join(homedir(), '.config/opencode/')})  — disponible en todos los proyectos`)}`,
+          value: 'global',
+        },
+        {
+          name: `${chalk.white('Local')}   ${chalk.hex('#888')('(.opencode/ en este directorio)  — solo en este proyecto')}`,
+          value: 'local',
+        },
+      ],
+    },
+  ]);
+
+  const baseDir = DESTINATIONS[destination];
+  const agentsDir = join(baseDir, 'agents');
+  const commandsDir = join(baseDir, 'commands');
+
+  // Crear directorios si no existen
+  for (const dir of [agentsDir, commandsDir]) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+
+  const installed = [];
+  const skipped = [];
+
+  // Copiar agent
+  const agentSrc = join(PROJECT_ROOT, 'agents', 'tibiaway.md');
+  const agentDst = join(agentsDir, 'tibiaway.md');
+  if (existsSync(agentSrc)) {
+    copyFileSync(agentSrc, agentDst);
+    installed.push(`agents/tibiaway.md → ${agentDst}`);
+  }
+
+  // Copiar todos los comandos
+  const commandsSourceDir = join(PROJECT_ROOT, 'commands');
+  if (existsSync(commandsSourceDir)) {
+    for (const file of readdirSync(commandsSourceDir)) {
+      if (!file.endsWith('.md')) continue;
+      const src = join(commandsSourceDir, file);
+      const dst = join(commandsDir, file);
+      copyFileSync(src, dst);
+      installed.push(`commands/${file} → ${dst}`);
+    }
+  }
+
+  if (installed.length === 0) {
+    error('No se encontraron archivos para instalar. ¿Estás en el directorio correcto?');
+    return;
+  }
+
+  console.log('');
+  separator();
+  console.log('');
+  console.log(chalk.hex('#FF6B1A').bold('✓ Archivos instalados:\n'));
+  for (const f of installed) {
+    console.log(`  ${chalk.hex('#4ade80')('✓')} ${chalk.hex('#888')(f)}`);
+  }
+
+  console.log('');
+  separator();
+  console.log('');
+  console.log(chalk.hex('#FF6B1A').bold('¡Listo! Así lo usas en OpenCode:\n'));
+
+  const steps = [
+    ['1.', 'Abre OpenCode en cualquier directorio'],
+    ['2.', 'Selecciona el agente TibiaWayAI en la lista de agentes'],
+    ['3.', 'Escribe tu personaje si te lo pide (nombre, vocación, level)'],
+    ['4.', 'Usa los comandos:'],
+  ];
+  for (const [n, s] of steps) {
+    console.log(`  ${chalk.hex('#FF6B1A')(n)} ${chalk.white(s)}`);
+  }
+
+  const cmds = ['/hunt', '/profit', '/quest', '/set', '/boss', '/diary', '/analyze'];
+  console.log('');
+  console.log('  ' + cmds.map(c => chalk.hex('#FF6B1A')(c)).join('  '));
+  console.log('');
+
+  info('OpenCode usa su propio modelo de IA configurado — no necesitas API key adicional.');
+  console.log('');
+}

package/src/installer.js

@@ -1,64 +1,219 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
-import { showBanner, success, error, info, highlight, separator } from './utils/banner.js';
+import fetch from 'node-fetch';
+import { showBanner, success, error, info, highlight, separator, warn } from './utils/banner.js';
 import { setupCharacter } from './utils/character.js';
-import { setApiKey, getApiKey, writeConfig, readConfig } from './utils/config.js';
+import { setApiKey, getApiKey, setOllamaConfig, getOllamaConfig, getProvider, writeConfig, readConfig } from './utils/config.js';
+
+const OLLAMA_MODELS = [
+  { name: 'llama3.2      (Recomendado · 3 GB · rápido y equilibrado)', value: 'llama3.2' },
+  { name: 'mistral       (Buena calidad · 4 GB)', value: 'mistral' },
+  { name: 'qwen2.5       (Excelente en español · 4 GB)', value: 'qwen2.5' },
+  { name: 'deepseek-r1   (Razonamiento avanzado · 7 GB)', value: 'deepseek-r1' },
+  { name: 'Otro (ingresar nombre manualmente)', value: '__custom__' },
+];
+
+async function checkOllamaConnection(url) {
+  try {
+    const res = await fetch(`${url}/api/tags`, { timeout: 4000 });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function setupAnthropic(existingKey) {
+  if (existingKey) {
+    success('API key de Anthropic ya configurada.');
+    return;
+  }
+
+  console.log('');
+  info('Necesitas una API key de Anthropic para usar este proveedor.');
+  info(`Obtén la tuya en: ${chalk.hex('#FF6B1A')('https://console.anthropic.com')}`);
+  console.log('');
+
+  const { key } = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'key',
+      message: highlight('Ingresa tu Anthropic API key:'),
+      mask: '*',
+      validate: (input) => {
+        if (!input.trim()) return 'La API key no puede estar vacía.';
+        if (!input.trim().startsWith('sk-')) return 'La API key debe empezar con "sk-".';
+        return true;
+      },
+    },
+  ]);
+
+  setApiKey(key.trim());
+  success('API key guardada correctamente.');
+}
+
+async function setupOllama() {
+  console.log('');
+  info(`Ollama corre modelos de IA ${chalk.hex('#4ade80').bold('gratis')} en tu propia computadora.`);
+  info(`Si no lo tienes instalado, descárgalo en: ${chalk.hex('#FF6B1A')('https://ollama.com')}`);
+  info(`Luego instala el modelo con:  ${chalk.hex('#FF6B1A')('ollama pull llama3.2')}`);
+  console.log('');
+
+  // Elegir modelo
+  const { modelChoice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'modelChoice',
+      message: highlight('¿Qué modelo de Ollama quieres usar?'),
+      choices: OLLAMA_MODELS,
+    },
+  ]);
+
+  let model = modelChoice;
+  if (modelChoice === '__custom__') {
+    const { customModel } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'customModel',
+        message: highlight('Nombre del modelo (ej: phi3, gemma2):'),
+        validate: (i) => i.trim().length > 0 || 'Ingresa un nombre de modelo.',
+      },
+    ]);
+    model = customModel.trim();
+  }
+
+  // URL del servidor Ollama
+  const { url } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'url',
+      message: highlight('URL del servidor Ollama:'),
+      default: 'http://localhost:11434',
+    },
+  ]);
+
+  const ollamaUrl = url.trim().replace(/\/$/, '');
+
+  // Verificar conexión
+  const spinner = (await import('ora')).default({ text: 'Verificando conexión a Ollama...', color: 'yellow' }).start();
+  const connected = await checkOllamaConnection(ollamaUrl);
+  spinner.stop();
+
+  if (!connected) {
+    warn(`No se pudo conectar a Ollama en ${ollamaUrl}`);
+    warn('Asegúrate de que Ollama esté corriendo: ollama serve');
+    console.log('');
+    const { continueAnyway } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'continueAnyway',
+        message: highlight('¿Continuar de todas formas y configurar Ollama después?'),
+        default: true,
+      },
+    ]);
+    if (!continueAnyway) {
+      info('Puedes volver a configurar con: tibiaway setup');
+      process.exit(0);
+    }
+  } else {
+    success(`Ollama conectado en ${ollamaUrl}`);
+  }
+
+  setOllamaConfig({ model, url: ollamaUrl });
+  success(`Modelo configurado: ${highlight(model)}`);
+}
 
 export async function runInstaller() {
   showBanner();
-
   console.log(chalk.hex('#f0f0f0')('Bienvenido a TibiaWayAI. Vamos a configurar tu asistente.\n'));
   separator();
   console.log('');
 
-  // Step 1: API Key
-  const existingKey = getApiKey();
-  let apiKey = existingKey;
+  // ── PASO 1: Elegir proveedor ──────────────────────────────────────────────
+  const currentProvider = getProvider();
 
-  if (!existingKey) {
-    info('Necesitas una API key de Anthropic para usar TibiaWayAI.');
-    info('Obtén la tuya en: https://console.anthropic.com');
-    console.log('');
+  if (currentProvider) {
+    const providerLabel = currentProvider === 'anthropic'
+      ? chalk.hex('#FF6B1A')('Anthropic Claude')
+      : chalk.hex('#4ade80')('Ollama (local)');
+    success(`Proveedor ya configurado: ${providerLabel}`);
 
-    const { key } = await inquirer.prompt([
+    const { change } = await inquirer.prompt([
       {
-        type: 'password',
-        name: 'key',
-        message: highlight('Ingresa tu Anthropic API key:'),
-        mask: '*',
-        validate: (input) => {
-          if (!input.trim()) return 'La API key no puede estar vacía.';
-          if (!input.trim().startsWith('sk-')) return 'La API key debe empezar con "sk-".';
-          return true;
-        },
+        type: 'confirm',
+        name: 'change',
+        message: highlight('¿Quieres cambiar el proveedor de IA?'),
+        default: false,
       },
     ]);
 
-    apiKey = key.trim();
-    setApiKey(apiKey);
-    success('API key guardada correctamente.');
+    if (!change) {
+      await continueSetup();
+      return;
+    }
     console.log('');
+  }
+
+  const { provider } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'provider',
+      message: highlight('¿Qué proveedor de IA quieres usar?'),
+      choices: [
+        {
+          name: `${chalk.hex('#FF6B1A').bold('Anthropic Claude')}  ${chalk.hex('#888')('· Mejor calidad · ~$0.01/consulta · Requiere API key')}`,
+          value: 'anthropic',
+        },
+        {
+          name: `${chalk.hex('#4ade80').bold('Ollama (local)')}    ${chalk.hex('#888')('· Completamente gratis · Corre en tu PC · Sin internet')}`,
+          value: 'ollama',
+        },
+      ],
+    },
+  ]);
+
+  console.log('');
+  separator();
+
+  if (provider === 'anthropic') {
+    await setupAnthropic(getApiKey());
   } else {
-    success('API key ya configurada.');
-    console.log('');
+    await setupOllama();
   }
 
-  // Step 2: Character setup
+  await continueSetup();
+}
+
+async function continueSetup() {
+  // ── PASO 2: Personaje ─────────────────────────────────────────────────────
   const config = readConfig();
+
   if (!config.character) {
+    console.log('');
     separator();
     console.log('');
     info('Ahora vamos a vincular tu personaje de Tibia.');
     console.log('');
     await setupCharacter();
   } else {
+    console.log('');
     success(`Personaje ya configurado: ${highlight(config.character.name)} (${config.character.vocation} lv ${config.character.level})`);
   }
 
+  // ── LISTO ─────────────────────────────────────────────────────────────────
   console.log('');
   separator();
   console.log('');
   console.log(chalk.hex('#FF6B1A').bold('¡TibiaWayAI está listo!'));
+  console.log('');
+
+  const provider = getProvider();
+  if (provider === 'ollama') {
+    const { model } = getOllamaConfig();
+    info(`Usando Ollama con el modelo ${highlight(model)}`);
+  } else {
+    info('Usando Anthropic Claude (claude-sonnet-4-20250514)');
+  }
+
   console.log('');
   console.log(chalk.hex('#f0f0f0')('Comandos disponibles:'));
   const cmds = [

package/src/standalone.js

@@ -10,6 +10,7 @@ import { handleBoss } from './commands/boss.js';
 import { handleDiary } from './commands/diary.js';
 import { handleAnalyze } from './commands/analyze.js';
 import { handleSync } from './commands/sync.js';
+import { handleSetupOpencode } from './commands/setup-opencode.js';
 
 const COMMANDS = {
   hunt: handleHunt,
@@ -22,6 +23,8 @@ const COMMANDS = {
   sync: handleSync,
   setup: runInstaller,
   install: runInstaller,
+  'setup-opencode': handleSetupOpencode,
+  opencode: handleSetupOpencode,
 };
 
 function printWelcome() {
@@ -63,6 +66,7 @@ function printHelp() {
     ['analyze <archivo>', 'Analiza screenshot o notas (.png, .jpg, .txt)'],
     ['sync', 'Actualiza tu perfil desde tibiadata.com'],
     ['setup', 'Configuración inicial (API key + personaje)'],
+    ['setup-opencode', 'Instala el agente en OpenCode (sin npm install)'],
   ];
 
   for (const [cmd, desc] of cmds) {
@@ -102,6 +106,12 @@ export async function run(args) {
     return;
   }
 
+  // setup-opencode no requiere tener el CLI configurado
+  if (command === 'setup-opencode' || command === 'opencode') {
+    await handleSetupOpencode();
+    return;
+  }
+
   // Auto-setup si falta config y no es sync
   if (!isConfigured() && command !== 'sync') {
     info('Primera vez que ejecutas TibiaWayAI. Vamos a configurarlo.');

package/src/utils/api.js

@@ -1,9 +1,10 @@
 import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
 import { readFileSync } from 'fs';
-import { getApiKey, getCharacter } from './config.js';
-import { error } from './banner.js';
+import { getApiKey, getCharacter, getProvider, getOllamaConfig } from './config.js';
+import { error, warn } from './banner.js';
 
-const MODEL = 'claude-sonnet-4-20250514';
+const ANTHROPIC_MODEL = 'claude-sonnet-4-20250514';
 const MAX_TOKENS = 2048;
 
 function buildSystemPrompt(extraContext = '') {
@@ -33,32 +34,66 @@ Tienes personalidad de veterano tibian: directo, preciso, con humor de la comuni
 ${extraContext}`;
 }
 
-function getClient() {
+function getAnthropicClient() {
   const apiKey = getApiKey();
   if (!apiKey) {
     error('No se encontró API key de Anthropic.');
-    console.error('Configura tu API key con: tibiaway setup');
-    console.error('O exporta la variable: export ANTHROPIC_API_KEY=tu_key');
+    console.error('Reconfigura con: tibiaway setup');
     process.exit(1);
   }
   return new Anthropic({ apiKey });
 }
 
+function getOllamaClient() {
+  const { url } = getOllamaConfig();
+  return new OpenAI({
+    baseURL: `${url}/v1`,
+    apiKey: 'ollama',
+  });
+}
+
+function getClient() {
+  const provider = getProvider();
+  if (provider === 'ollama') return { type: 'ollama', client: getOllamaClient() };
+  if (provider === 'anthropic') return { type: 'anthropic', client: getAnthropicClient() };
+
+  error('No hay proveedor de IA configurado. Ejecuta: tibiaway setup');
+  process.exit(1);
+}
+
 export async function askClaude(userMessage, extraContext = '') {
-  const client = getClient();
+  const { type, client } = getClient();
+  const systemPrompt = buildSystemPrompt(extraContext);
+
+  if (type === 'anthropic') {
+    const response = await client.messages.create({
+      model: ANTHROPIC_MODEL,
+      max_tokens: MAX_TOKENS,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userMessage }],
+    });
+    return response.content[0]?.text || '';
+  }
 
-  const response = await client.messages.create({
-    model: MODEL,
-    max_tokens: MAX_TOKENS,
-    system: buildSystemPrompt(extraContext),
-    messages: [{ role: 'user', content: userMessage }],
+  // Ollama — usa API compatible con OpenAI
+  const { model } = getOllamaConfig();
+  const response = await client.chat.completions.create({
+    model,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userMessage },
+    ],
   });
-
-  return response.content[0]?.text || '';
+  return response.choices[0]?.message?.content || '';
 }
 
 export async function askClaudeWithImage(userMessage, imagePath, extraContext = '') {
-  const client = getClient();
+  const { type, client } = getClient();
+
+  if (type === 'ollama') {
+    warn('El análisis de imágenes no está disponible con Ollama. Procesando solo el texto...');
+    return askClaude(`[El usuario quería analizar una imagen en ${imagePath}, pero Ollama no soporta visión en este momento]\n\n${userMessage}`, extraContext);
+  }
 
   const imageBuffer = readFileSync(imagePath);
   const base64Image = imageBuffer.toString('base64');
@@ -67,17 +102,14 @@ export async function askClaudeWithImage(userMessage, imagePath, extraContext =
   const mediaType = mediaTypeMap[ext] || 'image/png';
 
   const response = await client.messages.create({
-    model: MODEL,
+    model: ANTHROPIC_MODEL,
     max_tokens: MAX_TOKENS,
     system: buildSystemPrompt(extraContext),
     messages: [
       {
         role: 'user',
         content: [
-          {
-            type: 'image',
-            source: { type: 'base64', media_type: mediaType, data: base64Image },
-          },
+          { type: 'image', source: { type: 'base64', media_type: mediaType, data: base64Image } },
           { type: 'text', text: userMessage },
         ],
       },
@@ -88,22 +120,43 @@ export async function askClaudeWithImage(userMessage, imagePath, extraContext =
 }
 
 export async function streamClaude(userMessage, extraContext = '', onChunk) {
-  const client = getClient();
+  const { type, client } = getClient();
+  const systemPrompt = buildSystemPrompt(extraContext);
+
+  if (type === 'anthropic') {
+    const stream = client.messages.stream({
+      model: ANTHROPIC_MODEL,
+      max_tokens: MAX_TOKENS,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userMessage }],
+    });
+    let fullText = '';
+    for await (const chunk of stream) {
+      if (chunk.type === 'content_block_delta' && chunk.delta?.type === 'text_delta') {
+        fullText += chunk.delta.text;
+        if (onChunk) onChunk(chunk.delta.text);
+      }
+    }
+    return fullText;
+  }
 
-  const stream = client.messages.stream({
-    model: MODEL,
-    max_tokens: MAX_TOKENS,
-    system: buildSystemPrompt(extraContext),
-    messages: [{ role: 'user', content: userMessage }],
+  // Ollama streaming
+  const { model } = getOllamaConfig();
+  const stream = await client.chat.completions.create({
+    model,
+    stream: true,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userMessage },
+    ],
   });
-
   let fullText = '';
   for await (const chunk of stream) {
-    if (chunk.type === 'content_block_delta' && chunk.delta?.type === 'text_delta') {
-      fullText += chunk.delta.text;
-      if (onChunk) onChunk(chunk.delta.text);
+    const text = chunk.choices[0]?.delta?.content || '';
+    if (text) {
+      fullText += text;
+      if (onChunk) onChunk(text);
     }
   }
-
   return fullText;
 }

package/src/utils/config.js

@@ -6,8 +6,11 @@ const CONFIG_DIR = join(homedir(), '.tibiaway');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 
 const DEFAULT_CONFIG = {
-  character: null,
+  provider: null,
   anthropic_api_key: null,
+  ollama_model: 'llama3.2',
+  ollama_url: 'http://localhost:11434',
+  character: null,
   language: 'español',
   diary: [],
   last_sync: null,
@@ -49,6 +52,19 @@ export function setCharacter(characterData) {
   writeConfig(config);
 }
 
+export function getProvider() {
+  const config = readConfig();
+  // retrocompatibilidad: si hay api key guardada pero no provider, asumimos anthropic
+  if (!config.provider && config.anthropic_api_key) return 'anthropic';
+  return config.provider || null;
+}
+
+export function setProvider(provider) {
+  const config = readConfig();
+  config.provider = provider;
+  writeConfig(config);
+}
+
 export function getApiKey() {
   return process.env.ANTHROPIC_API_KEY || readConfig().anthropic_api_key || null;
 }
@@ -56,16 +72,30 @@ export function getApiKey() {
 export function setApiKey(key) {
   const config = readConfig();
   config.anthropic_api_key = key;
+  config.provider = 'anthropic';
+  writeConfig(config);
+}
+
+export function getOllamaConfig() {
+  const config = readConfig();
+  return {
+    model: config.ollama_model || 'llama3.2',
+    url: config.ollama_url || 'http://localhost:11434',
+  };
+}
+
+export function setOllamaConfig({ model, url }) {
+  const config = readConfig();
+  config.ollama_model = model;
+  config.ollama_url = url;
+  config.provider = 'ollama';
   writeConfig(config);
 }
 
 export function addDiaryEntry(entry) {
   const config = readConfig();
   if (!Array.isArray(config.diary)) config.diary = [];
-  config.diary.push({
-    date: new Date().toISOString(),
-    ...entry,
-  });
+  config.diary.push({ date: new Date().toISOString(), ...entry });
   writeConfig(config);
 }
 
@@ -76,7 +106,11 @@ export function getDiary() {
 
 export function isConfigured() {
   const config = readConfig();
-  return !!(config.character && (config.anthropic_api_key || process.env.ANTHROPIC_API_KEY));
+  if (!config.character) return false;
+  const provider = getProvider();
+  if (provider === 'ollama') return true;
+  if (provider === 'anthropic') return !!(config.anthropic_api_key || process.env.ANTHROPIC_API_KEY);
+  return false;
 }
 
 export function getConfigPath() {