claude-connect 0.1.5 → 0.1.7

package/README.md

@@ -1,11 +1,11 @@
 # Claude Connect
 
-> Conecta `Claude Code` con `OpenCode Go`, `Zen`, `Kimi`, `DeepSeek`, `OpenRouter` y `Qwen` desde una interfaz de consola clara, rápida y reversible.
+> Conecta `Claude Code` con `OpenCode Go`, `Zen`, `Kimi`, `DeepSeek`, `Ollama`, `OpenAI`, `Inception Labs`, `OpenRouter` y `Qwen` desde una interfaz de consola clara, rápida y reversible.
 
 [![npm version](https://img.shields.io/npm/v/claude-connect?style=for-the-badge&logo=npm&color=cb3837)](https://www.npmjs.com/package/claude-connect)
 [![node](https://img.shields.io/badge/node-%3E%3D22-2f7d32?style=for-the-badge&logo=node.js&logoColor=white)](https://nodejs.org/)
 [![license](https://img.shields.io/badge/license-MIT-0f172a?style=for-the-badge)](./LICENSE)
-[![providers](https://img.shields.io/badge/providers-OpenCode%20Go%20%7C%20Zen%20%7C%20Kimi%20%7C%20DeepSeek%20%7C%20OpenRouter%20%7C%20Qwen-0ea5e9?style=for-the-badge)](https://www.npmjs.com/package/claude-connect)
+[![providers](https://img.shields.io/badge/providers-OpenCode%20Go%20%7C%20Zen%20%7C%20Kimi%20%7C%20DeepSeek%20%7C%20Ollama%20%7C%20OpenAI%20%7C%20Inception%20Labs%20%7C%20OpenRouter%20%7C%20Qwen-0ea5e9?style=for-the-badge)](https://www.npmjs.com/package/claude-connect)
 
 ## Why Claude Connect
 
@@ -13,7 +13,7 @@
 
 ### Highlights
 
-- `OpenCode Go`, `Zen`, `Kimi`, `DeepSeek`, `OpenRouter` y `Qwen` listos desde el primer arranque
+- `OpenCode Go`, `Zen`, `Kimi`, `DeepSeek`, `Ollama`, `OpenAI`, `Inception Labs`, `OpenRouter` y `Qwen` listos desde el primer arranque
 - soporte para `Token` y `OAuth` cuando el proveedor lo permite
 - API keys compartidas por proveedor para no repetir el mismo token en cada modelo
 - activación reversible sobre la instalación real de `Claude Code`
@@ -78,6 +78,9 @@ Al activar:
 - `Zen` usa conexión directa o gateway según el modelo elegido
 - `Kimi` usa gateway local y reenvia al endpoint Anthropic de `https://api.kimi.com/coding/`
 - `DeepSeek` apunta a `https://api.deepseek.com/anthropic`
+- `Ollama` pide una URL local o remota, valida `/api/tags` y usa el gateway local sobre `.../api/chat`
+- `OpenAI` usa el gateway local sobre `https://api.openai.com/v1/chat/completions`
+- `Inception Labs` usa el gateway local sobre `https://api.inceptionlabs.ai/v1/chat/completions`
 - `OpenRouter` usa `openrouter/free` por gateway sobre `https://openrouter.ai/api/v1`
 - `Qwen` apunta al gateway local `http://127.0.0.1:4310/anthropic`
 
@@ -89,6 +92,9 @@ Al activar:
 | `Zen` | `Claude*` de Zen + modelos `chat/completions` de Zen | `Token` | Mixta |
 | `Kimi` | `kimi-for-coding` | `Token` | Gateway local |
 | `DeepSeek` | `deepseek-chat`, `deepseek-reasoner` | `Token` | Directa |
+| `Ollama` | modelos descubiertos desde tu servidor | `Servidor Ollama` | Gateway local |
+| `OpenAI` | `gpt-5.4`, `gpt-5.4-mini`, `gpt-5.3-codex`, `gpt-5.2-codex`, `gpt-5.2`, `gpt-5.1-codex-max`, `gpt-5.1-codex-mini` | `Token` | Gateway local |
+| `Inception Labs` | `mercury-2` | `Token` | Gateway local |
 | `OpenRouter` | `openrouter/free` | `Token` | Gateway local |
 | `Qwen` | `qwen3-coder-plus` | `OAuth`, `Token` | Gateway local |
 
@@ -103,6 +109,38 @@ Nota sobre `Zen`:
 - los modelos de Zen servidos por `chat/completions` van por gateway local
 - esta primera integración no incluye todavía los modelos de Zen expuestos por `responses` ni los de endpoint tipo Google
 
+Nota sobre `OpenAI`:
+
+- esta integración usa `Chat Completions` por `gateway local`
+- el bridge actual encaja bien con los modelos GPT/Codex listados porque Claude Code sigue hablando Anthropic hacia `claude-connect`
+- la autenticación soportada hoy es `API key`; no se expone `OAuth` para este proveedor
+- `gpt-5.4` quedó validado con una llamada real a través del gateway local
+- referencia oficial:
+  - https://platform.openai.com/docs/api-reference/chat/create
+  - https://platform.openai.com/docs/api-reference/authentication
+  - https://developers.openai.com/api/docs/models
+
+Nota sobre `Inception Labs`:
+
+- esta primera integracion expone solo `mercury-2`, que es el modelo chat-compatible oficial en `v1/chat/completions`
+- `Mercury Edit 2` no se publica todavia en Claude Connect porque usa endpoints `fim/edit` que no encajan con Claude Code en esta arquitectura
+- autenticacion soportada: `API key`
+- referencias oficiales:
+  - https://docs.inceptionlabs.ai/get-started/get-started
+  - https://docs.inceptionlabs.ai/get-started/authentication
+  - https://docs.inceptionlabs.ai/get-started/models
+
+Nota sobre `Ollama`:
+
+- la URL del servidor se define al crear la conexión
+- sirve tanto para `localhost` como para un VPS o servidor remoto con Ollama expuesto
+- Claude Connect consulta `/api/tags` para listar modelos y validar la conexión antes de guardar
+- luego usa el endpoint nativo `POST /api/chat`, que resultó más compatible para servidores remotos que publican mal `/v1/*`
+- servidores remotos pueden seguir fallando por timeout, auth cloud o respuestas pobres del modelo; la app ya distingue mejor esos casos
+- referencia oficial:
+  - https://docs.ollama.com/openai
+  - https://docs.ollama.com/api/tags
+
 ## What It Stores
 
 Claude Connect guarda el estado sensible fuera del repo.
@@ -125,14 +163,16 @@ Ahí viven:
 El catálogo SQLite local se genera automáticamente en:
 
 ```text
-storage/claude-connect.sqlite
+Linux: ~/.claude-connect/storage/claude-connect.sqlite
+Windows: %APPDATA%\claude-connect\storage\claude-connect.sqlite
 ```
 
 Importante:
 
 - esa base ya no se versiona en git
 - el catálogo se siembra desde `src/data/catalog-store.js`
-- esto evita conflictos molestos al hacer `git pull`
+- ya no se crea en la carpeta donde ejecutas el comando
+- esto evita conflictos molestos al hacer `git pull` y carpetas `storage/` accidentales en proyectos ajenos
 
 ## Claude Code Switching
 
@@ -149,6 +189,7 @@ Eso permite:
 - activar otro proveedor sin tocar archivos manualmente
 - evitar el `Auth conflict` entre sesión `claude.ai` y `API key`
 - volver a tu estado original con `Revertir Claude`
+- bloquear la activación si `Claude Code` no está realmente instalado todavía
 
 ## Qwen OAuth
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-connect",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "CLI para configurar Claude Code con proveedores de modelos externos",
   "author": "wmcarlosv",
   "type": "module",
@@ -36,6 +36,8 @@
     "anthropic",
     "deepseek",
     "kimi",
+    "ollama",
+    "openai",
     "qwen",
     "terminal"
   ],

package/src/data/catalog-store.js

@@ -1,8 +1,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
+import { resolveClaudeConnectHomeSync } from '../lib/app-paths.js';
 
-export const defaultCatalogDbPath = path.join(process.cwd(), 'storage', 'claude-connect.sqlite');
+export function getDefaultCatalogDbPath(options = {}) {
+  const pathModule = options.platform === 'win32' ? path.win32 : path.posix;
+  return pathModule.join(resolveClaudeConnectHomeSync(options), 'storage', 'claude-connect.sqlite');
+}
+
+export const defaultCatalogDbPath = getDefaultCatalogDbPath();
 
 const schemaSql = `
 PRAGMA foreign_keys = ON;
@@ -521,6 +527,197 @@ const seedProviders = [
       }
     ]
   },
+  {
+    id: 'ollama',
+    name: 'Ollama',
+    vendor: 'Ollama',
+    description: 'Servidor Ollama autohospedado. La conexion pide una base URL manual, descubre modelos via /api/tags y luego usa Chat Completions por el gateway local.',
+    docsUrl: 'https://docs.ollama.com/openai',
+    docsVerifiedAt: '2026-04-02',
+    baseUrl: 'http://127.0.0.1:11434',
+    defaultModelId: null,
+    defaultAuthMethodId: 'server',
+    defaultApiKeyEnvVar: 'OLLAMA_API_KEY',
+    models: [],
+    authMethods: [
+      {
+        id: 'server',
+        name: 'Servidor Ollama',
+        description: 'Conexion sin API key propia de Claude Connect. Solo necesitas la URL de tu servidor Ollama local o remoto.',
+        credentialKind: 'none',
+        sortOrder: 1,
+        isDefault: 1
+      }
+    ]
+  },
+  {
+    id: 'openai',
+    name: 'OpenAI',
+    vendor: 'OpenAI',
+    description: 'OpenAI con modelos GPT y Codex orientados a coding. Claude Code se conecta a traves del gateway local para mantener compatibilidad Anthropic, herramientas y vision.',
+    docsUrl: 'https://developers.openai.com/api/docs/models',
+    docsVerifiedAt: '2026-04-02',
+    baseUrl: 'https://api.openai.com/v1',
+    defaultModelId: 'gpt-5.4',
+    defaultAuthMethodId: 'token',
+    defaultApiKeyEnvVar: 'OPENAI_API_KEY',
+    models: [
+      {
+        id: 'gpt-5.4',
+        name: 'GPT-5.4',
+        category: 'OpenAI Chat Completions',
+        contextWindow: '1M',
+        summary: 'Modelo frontier actual de OpenAI para trabajo complejo, coding y flujos profesionales.',
+        upstreamModelId: 'gpt-5.4',
+        transportMode: 'gateway',
+        apiStyle: 'openai-chat',
+        apiBaseUrl: 'https://api.openai.com/v1',
+        apiPath: '/chat/completions',
+        authEnvMode: 'auth_token',
+        sortOrder: 1,
+        isDefault: 1
+      },
+      {
+        id: 'gpt-5.4-mini',
+        name: 'GPT-5.4 Mini',
+        category: 'OpenAI Chat Completions',
+        contextWindow: '400K',
+        summary: 'Variante mas rapida y economica de GPT-5.4 para coding, subagentes y alto volumen.',
+        upstreamModelId: 'gpt-5.4-mini',
+        transportMode: 'gateway',
+        apiStyle: 'openai-chat',
+        apiBaseUrl: 'https://api.openai.com/v1',
+        apiPath: '/chat/completions',
+        authEnvMode: 'auth_token',
+        sortOrder: 2,
+        isDefault: 0
+      },
+      {
+        id: 'gpt-5.3-codex',
+        name: 'GPT-5.3 Codex',
+        category: 'OpenAI Chat Completions',
+        contextWindow: '400K',
+        summary: 'Modelo Codex mas capaz de OpenAI para tareas agenticas de programacion.',
+        upstreamModelId: 'gpt-5.3-codex',
+        transportMode: 'gateway',
+        apiStyle: 'openai-chat',
+        apiBaseUrl: 'https://api.openai.com/v1',
+        apiPath: '/chat/completions',
+        authEnvMode: 'auth_token',
+        sortOrder: 3,
+        isDefault: 0
+      },
+      {
+        id: 'gpt-5.2-codex',
+        name: 'GPT-5.2 Codex',
+        category: 'OpenAI Chat Completions',
+        contextWindow: '400K',
+        summary: 'Modelo Codex inteligente para tareas largas de coding y automatizacion.',
+        upstreamModelId: 'gpt-5.2-codex',
+        transportMode: 'gateway',
+        apiStyle: 'openai-chat',
+        apiBaseUrl: 'https://api.openai.com/v1',
+        apiPath: '/chat/completions',
+        authEnvMode: 'auth_token',
+        sortOrder: 4,
+        isDefault: 0
+      },
+      {
+        id: 'gpt-5.2',
+        name: 'GPT-5.2',
+        category: 'OpenAI Chat Completions',
+        contextWindow: '400K',
+        summary: 'Modelo frontier previo de OpenAI para trabajo profesional con razonamiento configurable.',
+        upstreamModelId: 'gpt-5.2',
+        transportMode: 'gateway',
+        apiStyle: 'openai-chat',
+        apiBaseUrl: 'https://api.openai.com/v1',
+        apiPath: '/chat/completions',
+        authEnvMode: 'auth_token',
+        sortOrder: 5,
+        isDefault: 0
+      },
+      {
+        id: 'gpt-5.1-codex-max',
+        name: 'GPT-5.1 Codex Max',
+        category: 'OpenAI Chat Completions',
+        contextWindow: '400K',
+        summary: 'Variante Codex optimizada para tareas de larga duracion y sesiones de coding mas extensas.',
+        upstreamModelId: 'gpt-5.1-codex-max',
+        transportMode: 'gateway',
+        apiStyle: 'openai-chat',
+        apiBaseUrl: 'https://api.openai.com/v1',
+        apiPath: '/chat/completions',
+        authEnvMode: 'auth_token',
+        sortOrder: 6,
+        isDefault: 0
+      },
+      {
+        id: 'gpt-5.1-codex-mini',
+        name: 'GPT-5.1 Codex Mini',
+        category: 'OpenAI Chat Completions',
+        contextWindow: '400K',
+        summary: 'Version mas ligera y economica de la linea Codex 5.1 para iteraciones rapidas.',
+        upstreamModelId: 'gpt-5.1-codex-mini',
+        transportMode: 'gateway',
+        apiStyle: 'openai-chat',
+        apiBaseUrl: 'https://api.openai.com/v1',
+        apiPath: '/chat/completions',
+        authEnvMode: 'auth_token',
+        sortOrder: 7,
+        isDefault: 0
+      }
+    ],
+    authMethods: [
+      {
+        id: 'token',
+        name: 'Token',
+        description: 'Conexion por API key de OpenAI.',
+        credentialKind: 'env_var',
+        sortOrder: 1,
+        isDefault: 1
+      }
+    ]
+  },
+  {
+    id: 'inception',
+    name: 'Inception Labs',
+    vendor: 'Inception Labs',
+    description: 'Inception Platform con Mercury 2 sobre un endpoint OpenAI-compatible. Claude Code se conecta a traves del gateway local para mantener compatibilidad Anthropic y herramientas.',
+    docsUrl: 'https://docs.inceptionlabs.ai/get-started/get-started',
+    docsVerifiedAt: '2026-04-03',
+    baseUrl: 'https://api.inceptionlabs.ai/v1',
+    defaultModelId: 'mercury-2',
+    defaultAuthMethodId: 'token',
+    defaultApiKeyEnvVar: 'INCEPTION_API_KEY',
+    models: [
+      {
+        id: 'mercury-2',
+        name: 'Mercury 2',
+        category: 'OpenAI Chat Completions',
+        contextWindow: '128K',
+        summary: 'Modelo generalista y de razonamiento de Inception Labs expuesto por v1/chat/completions.',
+        upstreamModelId: 'mercury-2',
+        transportMode: 'gateway',
+        apiStyle: 'openai-chat',
+        apiBaseUrl: 'https://api.inceptionlabs.ai/v1',
+        apiPath: '/chat/completions',
+        authEnvMode: 'auth_token',
+        sortOrder: 1,
+        isDefault: 1
+      }
+    ],
+    authMethods: [
+      {
+        id: 'token',
+        name: 'Token',
+        description: 'Conexion por API key de Inception Labs.',
+        credentialKind: 'env_var',
+        sortOrder: 1,
+        isDefault: 1
+      }
+    ]
+  },
   {
     id: 'openrouter',
     name: 'OpenRouter',
@@ -869,7 +1066,7 @@ function mapOAuthRow(row) {
   };
 }
 
-export function createCatalogStore({ filename = defaultCatalogDbPath } = {}) {
+export function createCatalogStore({ filename = getDefaultCatalogDbPath() } = {}) {
   if (filename !== ':memory:') {
     fs.mkdirSync(path.dirname(filename), { recursive: true });
   }

package/src/gateway/messages.js

@@ -192,6 +192,10 @@ function buildOpenAIContentPartFromAnthropicBlock(block) {
 }
 
 function safeParseJson(value) {
+  if (isObject(value)) {
+    return value;
+  }
+
   if (typeof value !== 'string' || value.length === 0) {
     return {};
   }
@@ -232,6 +236,10 @@ export function estimateTokenCountFromAnthropicRequest(body) {
   return Math.max(1, Math.ceil(totalLength / 4));
 }
 
+function usesMaxCompletionTokens(model) {
+  return typeof model === 'string' && /^gpt-5(?:[.-]|$)/.test(model);
+}
+
 export function buildOpenAIRequestFromAnthropic({ body, model }) {
   const messages = [];
   const systemText = collectText(body.system).trim();
@@ -323,7 +331,11 @@ export function buildOpenAIRequestFromAnthropic({ body, model }) {
   };
 
   if (typeof body.max_tokens === 'number') {
-    request.max_tokens = body.max_tokens;
+    if (usesMaxCompletionTokens(model)) {
+      request.max_completion_tokens = body.max_tokens;
+    } else {
+      request.max_tokens = body.max_tokens;
+    }
   }
 
   if (typeof body.temperature === 'number') {
@@ -368,6 +380,134 @@ export function buildOpenAIRequestFromAnthropic({ body, model }) {
   return request;
 }
 
+export function buildOllamaRequestFromAnthropic({ body, model }) {
+  const messages = [];
+  const toolUseIdToName = new Map();
+  const systemText = collectText(body.system).trim();
+
+  if (systemText.length > 0) {
+    messages.push({
+      role: 'system',
+      content: systemText
+    });
+  }
+
+  for (const message of Array.isArray(body.messages) ? body.messages : []) {
+    const blocks = normalizeBlocks(message?.content);
+
+    if (message?.role === 'user') {
+      let textParts = [];
+      let imageParts = [];
+
+      const flushUserMessage = () => {
+        if (textParts.length === 0 && imageParts.length === 0) {
+          return;
+        }
+
+        messages.push({
+          role: 'user',
+          content: textParts.join('\n\n'),
+          ...(imageParts.length > 0 ? { images: imageParts } : {})
+        });
+
+        textParts = [];
+        imageParts = [];
+      };
+
+      for (const block of blocks) {
+        if (block?.type === 'tool_result') {
+          flushUserMessage();
+          messages.push({
+            role: 'tool',
+            tool_name: toolUseIdToName.get(block.tool_use_id) ?? block.tool_use_id ?? 'tool',
+            content: collectText(block.content)
+          });
+          continue;
+        }
+
+        if (block?.type === 'image' && block?.source?.type === 'base64' && typeof block?.source?.data === 'string') {
+          imageParts.push(block.source.data);
+          continue;
+        }
+
+        textParts.push(collectText(block?.text ?? block));
+      }
+
+      flushUserMessage();
+      continue;
+    }
+
+    if (message?.role === 'assistant') {
+      const textParts = [];
+      const toolCalls = [];
+
+      for (const block of blocks) {
+        if (block?.type === 'tool_use') {
+          toolUseIdToName.set(block.id, block.name);
+          toolCalls.push({
+            function: {
+              name: block.name,
+              arguments: block.input ?? {}
+            }
+          });
+          continue;
+        }
+
+        textParts.push(collectText(block?.text ?? block));
+      }
+
+      messages.push({
+        role: 'assistant',
+        content: textParts.join('\n\n'),
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {})
+      });
+    }
+  }
+
+  const request = {
+    model,
+    messages,
+    stream: false
+  };
+
+  if (typeof body.max_tokens === 'number') {
+    request.options = {
+      ...(isObject(request.options) ? request.options : {}),
+      num_predict: body.max_tokens
+    };
+  }
+
+  if (typeof body.temperature === 'number') {
+    request.options = {
+      ...(isObject(request.options) ? request.options : {}),
+      temperature: body.temperature
+    };
+  }
+
+  if (Array.isArray(body.stop_sequences) && body.stop_sequences.length > 0) {
+    request.options = {
+      ...(isObject(request.options) ? request.options : {}),
+      stop: body.stop_sequences
+    };
+  }
+
+  if (Array.isArray(body.tools) && body.tools.length > 0) {
+    request.tools = body.tools.map((tool) => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description ?? '',
+        parameters: tool.input_schema ?? {
+          type: 'object',
+          properties: {}
+        }
+      }
+    }));
+  }
+
+  return request;
+}
+
 export function buildAnthropicMessageFromOpenAI({ response, requestedModel }) {
   const choice = response?.choices?.[0] ?? {};
   const assistantMessage = choice?.message ?? {};
@@ -413,6 +553,47 @@ export function buildAnthropicMessageFromOpenAI({ response, requestedModel }) {
   };
 }
 
+export function buildAnthropicMessageFromOllama({ response, requestedModel }) {
+  const assistantMessage = isObject(response?.message) ? response.message : {};
+  const content = [];
+  const text = typeof assistantMessage.content === 'string' ? assistantMessage.content : '';
+  const toolCalls = Array.isArray(assistantMessage.tool_calls) ? assistantMessage.tool_calls : [];
+
+  if (text.length > 0) {
+    content.push({
+      type: 'text',
+      text
+    });
+  }
+
+  for (const toolCall of toolCalls) {
+    content.push({
+      type: 'tool_use',
+      id: `toolu_${crypto.randomUUID().replace(/-/g, '')}`,
+      name: toolCall?.function?.name || 'tool',
+      input: safeParseJson(toolCall?.function?.arguments)
+    });
+  }
+
+  return {
+    id: `msg_${crypto.randomUUID().replace(/-/g, '')}`,
+    type: 'message',
+    role: 'assistant',
+    model: requestedModel || response?.model || 'unknown',
+    content,
+    stop_reason: toolCalls.length > 0
+      ? 'tool_use'
+      : response?.done_reason === 'length'
+        ? 'max_tokens'
+        : 'end_turn',
+    stop_sequence: null,
+    usage: {
+      input_tokens: Number(response?.prompt_eval_count ?? 0),
+      output_tokens: Number(response?.eval_count ?? 0)
+    }
+  };
+}
+
 function writeSseEvent(response, event, payload) {
   response.write(`event: ${event}\n`);
   response.write(`data: ${JSON.stringify(payload)}\n\n`);

package/src/gateway/server.js

@@ -6,7 +6,9 @@ import process from 'node:process';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import {
+  buildAnthropicMessageFromOllama,
   buildAnthropicMessageFromOpenAI,
+  buildOllamaRequestFromAnthropic,
   buildOpenAIRequestFromAnthropic,
   estimateTokenCountFromAnthropicRequest,
   normalizeAnthropicRequestForUpstream,
@@ -33,6 +35,30 @@ function isObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+function describeRequestError(error) {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+
+  const parts = [error.message];
+  const cause = error.cause;
+
+  if (cause && typeof cause === 'object') {
+    const code = 'code' in cause && typeof cause.code === 'string' ? cause.code : null;
+    const message = 'message' in cause && typeof cause.message === 'string' ? cause.message : null;
+
+    if (code) {
+      parts.push(`code=${code}`);
+    }
+
+    if (message && message !== error.message) {
+      parts.push(message);
+    }
+  }
+
+  return parts.join(' · ');
+}
+
 async function terminatePid(pid) {
   if (!isProcessAlive(pid)) {
     return false;
@@ -136,6 +162,18 @@ function getUpstreamModelId(profile) {
 }
 
 function resolveGatewayUpstreamConfig(profile) {
+  if (profile?.provider?.id === 'ollama') {
+    return {
+      upstreamBaseUrl: typeof profile?.endpoint?.baseUrl === 'string' && profile.endpoint.baseUrl.length > 0
+        ? profile.endpoint.baseUrl
+        : typeof profile?.model?.apiBaseUrl === 'string' && profile.model.apiBaseUrl.length > 0
+          ? profile.model.apiBaseUrl
+          : 'http://127.0.0.1:11434',
+      upstreamApiStyle: 'ollama-chat',
+      upstreamApiPath: '/api/chat'
+    };
+  }
+
   return {
     upstreamBaseUrl: typeof profile?.model?.apiBaseUrl === 'string' && profile.model.apiBaseUrl.length > 0
       ? profile.model.apiBaseUrl
@@ -169,6 +207,19 @@ async function resolveGatewayContext() {
   const profile = await readProfileFile(switchState.profilePath);
   const authMethod = profile?.auth?.method === 'api_key' ? 'token' : profile?.auth?.method;
 
+  if (authMethod === 'server' && profile?.provider?.id === 'ollama') {
+    const upstream = resolveGatewayUpstreamConfig(profile);
+
+    return {
+      profile,
+      authMethod,
+      upstreamBaseUrl: upstream.upstreamBaseUrl,
+      upstreamApiStyle: upstream.upstreamApiStyle,
+      upstreamApiPath: upstream.upstreamApiPath,
+      accessToken: 'ollama'
+    };
+  }
+
   if (authMethod === 'token') {
     const envVar = profile?.auth?.envVar;
     let token = typeof envVar === 'string' ? process.env[envVar] : '';
@@ -236,11 +287,25 @@ async function resolveGatewayContext() {
 }
 
 async function forwardUpstreamRequest({ targetUrl, headers, payload, context, refreshOnUnauthorized = true }) {
-  const response = await fetch(targetUrl, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify(payload)
-  });
+  let response;
+
+  try {
+    response = await fetch(targetUrl, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(payload)
+    });
+  } catch (error) {
+    const providerName = context?.profile?.provider?.name ?? context?.profile?.provider?.id ?? 'El proveedor';
+
+    if (context?.profile?.provider?.id === 'ollama') {
+      throw new Error(
+        `${providerName} no respondio en ${targetUrl}. Revisa que el servidor remoto este accesible, que el puerto este expuesto y que Ollama escuche en esa URL. Detalle: ${describeRequestError(error)}`
+      );
+    }
+
+    throw new Error(`${providerName} no respondio en ${targetUrl}. Detalle: ${describeRequestError(error)}`);
+  }
 
   const responsePayload = await response.json().catch(() => ({}));
 
@@ -305,6 +370,22 @@ async function forwardChatCompletion({ openAiRequest, context, refreshOnUnauthor
   });
 }
 
+async function forwardOllamaChat({ ollamaRequest, context, refreshOnUnauthorized = true }) {
+  const targetUrl = `${context.upstreamBaseUrl.replace(/\/$/, '')}${context.upstreamApiPath || '/api/chat'}`;
+
+  return forwardUpstreamRequest({
+    targetUrl,
+    headers: {
+      'content-type': 'application/json',
+      accept: 'application/json',
+      'user-agent': 'claude-connect-gateway/0.1.0'
+    },
+    payload: ollamaRequest,
+    context,
+    refreshOnUnauthorized
+  });
+}
+
 async function forwardAnthropicMessage({ requestBody, context, refreshOnUnauthorized = true }) {
   const targetUrl = `${context.upstreamBaseUrl.replace(/\/$/, '')}${context.upstreamApiPath || '/v1/messages'}`;
 
@@ -384,6 +465,36 @@ async function handleMessages(request, response) {
     return;
   }
 
+  if (context.upstreamApiStyle === 'ollama-chat') {
+    const ollamaRequest = buildOllamaRequestFromAnthropic({
+      body,
+      model: getUpstreamModelId(context.profile)
+    });
+    const upstreamResponse = await forwardOllamaChat({
+      ollamaRequest,
+      context
+    });
+    const anthropicMessage = buildAnthropicMessageFromOllama({
+      response: upstreamResponse,
+      requestedModel: getUpstreamModelId(context.profile)
+    });
+
+    if (body.stream === true) {
+      response.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache, no-transform',
+        connection: 'keep-alive',
+        'x-accel-buffering': 'no'
+      });
+      writeAnthropicStreamFromMessage(response, anthropicMessage);
+      response.end();
+      return;
+    }
+
+    sendJson(response, 200, anthropicMessage);
+    return;
+  }
+
   if (context.upstreamApiStyle !== 'openai-chat') {
     throw new Error(`El gateway todavia no soporta el estilo ${context.upstreamApiStyle} para ${context.profile.provider.name}.`);
   }

package/src/lib/app-paths.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
@@ -48,6 +49,14 @@ async function pathExists(targetPath) {
   }
 }
 
+function pathExistsSync(targetPath) {
+  try {
+    return fsSync.existsSync(targetPath);
+  } catch (_error) {
+    return false;
+  }
+}
+
 function defaultHomedir(env, fallbackHomedir) {
   const pathModule = getPathModule(process.platform);
 
@@ -179,6 +188,18 @@ export async function resolveClaudeConnectHome(options = {}) {
   return candidates[0];
 }
 
+export function resolveClaudeConnectHomeSync(options = {}) {
+  const candidates = buildClaudeConnectHomeCandidates(options);
+
+  for (const candidate of candidates) {
+    if (pathExistsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return candidates[0];
+}
+
 export async function resolveClaudeSettingsPath(options = {}) {
   if (typeof options.env?.CLAUDE_SETTINGS_PATH === 'string' && options.env.CLAUDE_SETTINGS_PATH.trim().length > 0) {
     return buildClaudeSettingsPathCandidates(options)[0];
@@ -244,6 +265,8 @@ export async function resolveClaudeConnectPaths(options = {}) {
 
   return {
     claudeConnectHome,
+    storageDir: path.join(claudeConnectHome, 'storage'),
+    catalogDbPath: path.join(claudeConnectHome, 'storage', 'claude-connect.sqlite'),
     profilesDir: path.join(claudeConnectHome, 'profiles'),
     tokensDir: path.join(claudeConnectHome, 'tokens'),
     secretsDir: path.join(claudeConnectHome, 'secrets'),
@@ -269,3 +292,90 @@ export async function resolveClaudePaths(options = {}) {
     ...claudeConnectPaths
   };
 }
+
+function buildExecutableNames(command, platform = process.platform, env = process.env) {
+  if (platform !== 'win32') {
+    return [command];
+  }
+
+  const pathext = typeof env.PATHEXT === 'string' && env.PATHEXT.length > 0
+    ? env.PATHEXT.split(';').filter(Boolean)
+    : ['.EXE', '.CMD', '.BAT', '.COM'];
+  const hasExt = path.win32.extname(command).length > 0;
+
+  if (hasExt) {
+    return [command];
+  }
+
+  return pathext.map((ext) => `${command}${ext.toLowerCase()}`);
+}
+
+export async function findExecutableOnPath(command, {
+  platform = process.platform,
+  env = process.env
+} = {}) {
+  const pathModule = getPathModule(platform);
+  const pathValue = typeof env.PATH === 'string' ? env.PATH : '';
+  const pathEntries = pathValue.split(path.delimiter).filter(Boolean);
+  const commandNames = buildExecutableNames(command, platform, env);
+
+  for (const directory of pathEntries) {
+    for (const commandName of commandNames) {
+      const candidate = pathModule.join(directory, commandName);
+
+      if (await pathExists(candidate)) {
+        return candidate;
+      }
+    }
+  }
+
+  return null;
+}
+
+export async function detectClaudeCodeInstallation(options = {}) {
+  const settingsCandidates = buildClaudeSettingsPathCandidates(options);
+  const accountCandidates = buildClaudeAccountPathCandidates(options);
+  const credentialsCandidates = buildClaudeCredentialsPathCandidates(options);
+  const executablePath = await findExecutableOnPath('claude', options);
+
+  const [existingSettingsPath, existingAccountPath, existingCredentialsPath] = await Promise.all([
+    (async () => {
+      for (const candidate of settingsCandidates) {
+        if (await pathExists(candidate)) {
+          return candidate;
+        }
+      }
+
+      return null;
+    })(),
+    (async () => {
+      for (const candidate of accountCandidates) {
+        if (await pathExists(candidate)) {
+          return candidate;
+        }
+      }
+
+      return null;
+    })(),
+    (async () => {
+      for (const candidate of credentialsCandidates) {
+        if (await pathExists(candidate)) {
+          return candidate;
+        }
+      }
+
+      return null;
+    })()
+  ]);
+
+  return {
+    isInstalled: Boolean(executablePath || existingSettingsPath || existingAccountPath || existingCredentialsPath),
+    executablePath,
+    existingSettingsPath,
+    existingAccountPath,
+    existingCredentialsPath,
+    settingsCandidates,
+    accountCandidates,
+    credentialsCandidates
+  };
+}

package/src/lib/claude-settings.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { resolveClaudePaths } from './app-paths.js';
+import { detectClaudeCodeInstallation, resolveClaudePaths } from './app-paths.js';
 import { readManagedProviderTokenSecret, readManagedTokenSecret } from './secrets.js';
 
 function isObject(value) {
@@ -99,6 +99,10 @@ export async function readSwitchState() {
 }
 
 async function resolveTokenValueForProfile(profile) {
+  if (profile?.provider?.id === 'ollama') {
+    return 'ollama';
+  }
+
   const envVar = profile?.auth?.envVar;
   const envToken = typeof envVar === 'string' ? process.env[envVar] : '';
 
@@ -163,6 +167,16 @@ export async function resolveClaudeTransportForProfile({
     };
   }
 
+  if (authMethod === 'server') {
+    return {
+      connectionMode: 'gateway',
+      connectionBaseUrl: gatewayBaseUrl,
+      authToken: 'claude-connect-local',
+      authEnvMode: 'auth_token',
+      extraEnv: {}
+    };
+  }
+
   return {
     connectionMode: 'gateway',
     connectionBaseUrl: gatewayBaseUrl,
@@ -212,6 +226,9 @@ export function buildClaudeSettingsForProfile({
   if (authMethod === 'token') {
     env.CLAUDE_CONNECT_TOKEN_ENV_VAR = profile.auth.envVar;
     delete env.CLAUDE_CONNECT_TOKEN_FILE;
+  } else if (authMethod === 'server') {
+    delete env.CLAUDE_CONNECT_TOKEN_ENV_VAR;
+    delete env.CLAUDE_CONNECT_TOKEN_FILE;
   } else if (authMethod === 'oauth' && profile.auth.oauth?.tokenFile) {
     env.CLAUDE_CONNECT_TOKEN_FILE = profile.auth.oauth.tokenFile;
     delete env.CLAUDE_CONNECT_TOKEN_ENV_VAR;
@@ -223,6 +240,14 @@ export function buildClaudeSettingsForProfile({
 }
 
 export async function activateClaudeProfile({ profile, gatewayBaseUrl = 'http://127.0.0.1:4310/anthropic' }) {
+  const installation = await detectClaudeCodeInstallation();
+
+  if (!installation.isInstalled) {
+    throw new Error(
+      'Claude Code no parece estar instalado en esta maquina. Instala o ejecuta Claude Code primero y luego vuelve a activar la conexion.'
+    );
+  }
+
   const {
     claudeSettingsPath,
     claudeAccountPath,

package/src/lib/ollama.js

@@ -0,0 +1,100 @@
+function describeRequestError(error) {
+  if (error && typeof error === 'object') {
+    if ('cause' in error && error.cause && typeof error.cause === 'object' && 'message' in error.cause) {
+      return String(error.cause.message);
+    }
+
+    if ('message' in error) {
+      return String(error.message);
+    }
+  }
+
+  return String(error);
+}
+
+export function normalizeOllamaBaseUrl(value) {
+  const trimmed = typeof value === 'string' ? value.trim() : '';
+
+  if (trimmed.length === 0) {
+    throw new Error('La URL de Ollama no puede quedar vacia.');
+  }
+
+  const withProtocol = /^https?:\/\//i.test(trimmed)
+    ? trimmed
+    : `http://${trimmed}`;
+
+  let url;
+
+  try {
+    url = new URL(withProtocol);
+  } catch (_error) {
+    throw new Error('La URL de Ollama no es valida.');
+  }
+
+  if (!url.hostname) {
+    throw new Error('La URL de Ollama no es valida.');
+  }
+
+  return url.toString().replace(/\/$/, '');
+}
+
+function summarizeOllamaModel(model) {
+  const details = model?.details && typeof model.details === 'object' ? model.details : {};
+  const segments = [
+    typeof details.family === 'string' && details.family.length > 0 ? details.family : null,
+    typeof details.parameter_size === 'string' && details.parameter_size.length > 0 ? details.parameter_size : null,
+    typeof details.quantization_level === 'string' && details.quantization_level.length > 0 ? details.quantization_level : null
+  ].filter(Boolean);
+
+  return segments.length > 0
+    ? segments.join(' · ')
+    : 'Modelo descubierto desde /api/tags';
+}
+
+export async function fetchOllamaModels({ baseUrl, timeoutMs = 8000 }) {
+  const normalizedBaseUrl = normalizeOllamaBaseUrl(baseUrl);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new Error('timeout')), timeoutMs);
+
+  try {
+    const response = await fetch(`${normalizedBaseUrl}/api/tags`, {
+      method: 'GET',
+      headers: {
+        accept: 'application/json'
+      },
+      signal: controller.signal
+    });
+
+    const payload = await response.json().catch(() => ({}));
+
+    if (!response.ok) {
+      const message = payload?.error || payload?.message || `HTTP ${response.status}`;
+      throw new Error(`Ollama respondio ${response.status}: ${message}`);
+    }
+
+    const rawModels = Array.isArray(payload?.models) ? payload.models : [];
+
+    return {
+      baseUrl: normalizedBaseUrl,
+      models: rawModels.map((model, index) => ({
+        id: model?.model || model?.name || `ollama-model-${index + 1}`,
+        name: model?.name || model?.model || `Modelo ${index + 1}`,
+        category: 'Ollama OpenAI-compatible',
+        contextWindow: 'Auto',
+        summary: summarizeOllamaModel(model),
+        upstreamModelId: model?.model || model?.name || `ollama-model-${index + 1}`,
+        transportMode: 'gateway',
+        apiStyle: 'openai-chat',
+        apiBaseUrl: normalizedBaseUrl,
+        apiPath: '/v1/chat/completions',
+        authEnvMode: 'auth_token',
+        sortOrder: index + 1,
+        isDefault: index === 0
+      }))
+    };
+  } catch (error) {
+    throw new Error(`No se pudo consultar ${normalizedBaseUrl}/api/tags: ${describeRequestError(error)}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/wizard.js

@@ -22,6 +22,7 @@ import {
   readManagedTokenSecret,
   saveManagedProviderTokenSecret
 } from './lib/secrets.js';
+import { fetchOllamaModels, normalizeOllamaBaseUrl } from './lib/ollama.js';
 import {
   assertInteractiveTerminal,
   buildFrame,
@@ -151,6 +152,13 @@ function buildTokenDetailLines(profile) {
     return [`Token file: ${profile.auth.oauth?.tokenFile ?? 'no encontrado'}`];
   }
 
+  if (profile.auth.method === 'server') {
+    return [
+      `Base URL: ${profile.endpoint?.baseUrl ?? 'sin definir'}`,
+      `Modelo upstream: ${profile.model?.upstreamModelId ?? profile.model?.id ?? 'sin definir'}`
+    ];
+  }
+
   if (profile.providerCredentialConfigured) {
     return [
       `Credencial compartida: ${profile.providerSecretRecord?.filePath ?? profile.auth.providerSecretFile ?? 'configurada'}`,
@@ -185,11 +193,6 @@ function profileActionItems(profile) {
     description: 'Borra solo el perfil. La API key compartida del proveedor se conserva.',
     value: 'delete'
   });
-  items.push({
-    label: 'Volver',
-    description: 'Regresa al menu principal.',
-    value: 'back'
-  });
 
   return items;
 }
@@ -233,7 +236,7 @@ function renderWelcome() {
         colorize('4. Guardar perfil y credenciales locales', colors.soft),
         '',
         colorize('Catalogo actual', colors.bold, colors.accentSoft),
-        colorize('OpenCode Go, Zen, Kimi, DeepSeek, OpenRouter y Qwen ya vienen almacenados en SQLite.', colors.soft),
+        colorize('OpenCode Go, Zen, Kimi, DeepSeek, Ollama, OpenAI, OpenRouter y Qwen ya vienen almacenados en SQLite.', colors.soft),
         '',
         colorize('Seguridad', colors.bold, colors.accentSoft),
         colorize('El token OAuth se guarda localmente y el modo Token puede guardarse una sola vez por proveedor.', colors.soft)
@@ -246,8 +249,12 @@ function renderWelcome() {
 function renderSummary({ profile, filePath }) {
   const authSummary = profile.auth.method === 'oauth'
     ? `Auth: oauth con token en ${profile.auth.oauth.tokenFile}`
-    : `Auth: ${profile.auth.method} con fallback en ${profile.auth.envVar}`;
-  const managedSecretSummary = profile.auth.method !== 'oauth' && profile.auth.providerSecretFile
+    : profile.auth.method === 'server'
+      ? 'Auth: servidor Ollama sin API key administrada por Claude Connect'
+      : `Auth: ${profile.auth.method} con fallback en ${profile.auth.envVar}`;
+  const managedSecretSummary = profile.auth.method === 'server'
+    ? colorize('Esta conexion usa solo la URL y el modelo descubiertos en el servidor Ollama.', colors.soft)
+    : profile.auth.method !== 'oauth' && profile.auth.providerSecretFile
     ? colorize(`API key compartida del proveedor en: ${profile.auth.providerSecretFile}`, colors.soft)
     : profile.auth.method !== 'oauth' && profile.auth.secretFile
       ? colorize(`API key antigua detectada en: ${profile.auth.secretFile}`, colors.soft)
@@ -279,12 +286,18 @@ function renderSummary({ profile, filePath }) {
               colorize(`export OPENAI_MODEL=${profile.model.id}`, colors.soft),
               colorize('El access token y refresh token ya quedaron guardados localmente.', colors.soft)
             ]
-          : [
-              colorize(`Fallback opcional: export ${profile.auth.envVar}=<tu_token>`, colors.soft),
-              colorize(`export OPENAI_BASE_URL=${profile.endpoint.baseUrl}`, colors.soft),
-              colorize(`export OPENAI_MODEL=${profile.model.id}`, colors.soft),
-              colorize('La API key puede guardarse una sola vez por proveedor en Claude Connect.', colors.soft)
-            ])
+          : profile.auth.method === 'server'
+            ? [
+                colorize(`export OPENAI_BASE_URL=${profile.endpoint.baseUrl}`, colors.soft),
+                colorize(`export OPENAI_MODEL=${profile.model.id}`, colors.soft),
+                colorize('La conexion usa el servidor Ollama descubierto y se valida antes de guardar.', colors.soft)
+              ]
+            : [
+                colorize(`Fallback opcional: export ${profile.auth.envVar}=<tu_token>`, colors.soft),
+                colorize(`export OPENAI_BASE_URL=${profile.endpoint.baseUrl}`, colors.soft),
+                colorize(`export OPENAI_MODEL=${profile.model.id}`, colors.soft),
+                colorize('La API key puede guardarse una sola vez por proveedor en Claude Connect.', colors.soft)
+              ])
       ],
       footer: [colorize('Presiona cualquier tecla para volver al menu', colors.dim, colors.muted)]
     })
@@ -420,7 +433,22 @@ async function activateClaudeFromSavedProfile() {
     return profile;
   }
 
-  const result = await activateClaudeProfile({ profile });
+  let result;
+
+  try {
+    result = await activateClaudeProfile({ profile });
+  } catch (error) {
+    renderInfoScreen({
+      title: 'No se pudo activar Claude',
+      subtitle: 'Claude Connect no pudo aplicar la conexion en Claude Code.',
+      lines: [
+        colorize(error instanceof Error ? error.message : String(error), colors.warning)
+      ],
+      footer: 'Presiona una tecla para volver'
+    });
+    return await waitForAnyKey();
+  }
+
   const gateway = result.connectionMode === 'gateway'
     ? await restartGatewayInBackground()
     : await stopGateway();
@@ -561,7 +589,7 @@ async function deleteSavedProfile(profile) {
     lines: [
       colorize(`Perfil: ${profile.profileName}`, colors.soft),
       colorize(`Archivo eliminado: ${profile.filePath}`, colors.soft),
-      ...(profile.auth?.method !== 'oauth'
+      ...(profile.auth?.method === 'token' || profile.auth?.method === 'api_key'
         ? [colorize('La API key compartida del proveedor se conserva para otros modelos.', colors.soft)]
         : [])
     ],
@@ -703,6 +731,143 @@ async function createNewConnection(store) {
     }
 
     const catalog = store.getProviderCatalog(provider.id);
+
+    if (catalog.id === 'ollama') {
+      const ollamaBaseUrlInput = await promptText({
+        step: 2,
+        totalSteps: 4,
+        title: 'URL del servidor Ollama',
+        subtitle: 'Puede ser local o remoto, por ejemplo http://127.0.0.1:11434 o https://mi-vps:11434.',
+        label: 'Base URL',
+        defaultValue: catalog.baseUrl,
+        placeholder: catalog.baseUrl,
+        allowBack: true
+      });
+
+      if (isExit(ollamaBaseUrlInput)) {
+        return ollamaBaseUrlInput;
+      }
+
+      if (isBack(ollamaBaseUrlInput)) {
+        continue;
+      }
+
+      let normalizedOllamaBaseUrl;
+
+      try {
+        normalizedOllamaBaseUrl = normalizeOllamaBaseUrl(ollamaBaseUrlInput);
+      } catch (error) {
+        renderInfoScreen({
+          title: 'URL invalida',
+          subtitle: 'La direccion del servidor Ollama no se pudo normalizar.',
+          lines: [
+            colorize(error instanceof Error ? error.message : String(error), colors.warning)
+          ],
+          footer: 'Presiona una tecla para volver'
+        });
+
+        const invalidUrlResult = await waitForAnyKey();
+
+        if (isExit(invalidUrlResult)) {
+          return invalidUrlResult;
+        }
+
+        continue;
+      }
+
+      let discovered;
+
+      try {
+        discovered = await fetchOllamaModels({ baseUrl: normalizedOllamaBaseUrl });
+      } catch (error) {
+        renderInfoScreen({
+          title: 'No se pudo conectar a Ollama',
+          subtitle: 'Claude Connect intento consultar /api/tags para descubrir modelos.',
+          lines: [
+            colorize(`Base URL: ${normalizedOllamaBaseUrl}`, colors.soft),
+            colorize(error instanceof Error ? error.message : String(error), colors.warning)
+          ],
+          footer: 'Presiona una tecla para volver'
+        });
+
+        const failedConnectionResult = await waitForAnyKey();
+
+        if (isExit(failedConnectionResult)) {
+          return failedConnectionResult;
+        }
+
+        continue;
+      }
+
+      if (discovered.models.length === 0) {
+        renderInfoScreen({
+          title: 'Sin modelos en Ollama',
+          subtitle: 'La conexion esta viva, pero /api/tags no devolvio modelos disponibles.',
+          lines: [
+            colorize(`Base URL: ${normalizedOllamaBaseUrl}`, colors.soft),
+            colorize('Carga al menos un modelo en ese servidor y vuelve a intentarlo.', colors.soft)
+          ],
+          footer: 'Presiona una tecla para volver'
+        });
+
+        const emptyModelsResult = await waitForAnyKey();
+
+        if (isExit(emptyModelsResult)) {
+          return emptyModelsResult;
+        }
+
+        continue;
+      }
+
+      const discoveredModel = await selectFromList({
+        step: 3,
+        totalSteps: 4,
+        title: 'Selecciona el modelo de Ollama',
+        subtitle: `Servidor: ${normalizedOllamaBaseUrl}.`,
+        items: modelItems(discovered.models),
+        allowBack: true,
+        detailBuilder: (selected) => [
+          `Modelo: ${selected.value.id}`,
+          `Categoria: ${selected.value.category}`,
+          `Contexto: ${selected.value.contextWindow}`,
+          selected.value.summary
+        ]
+      });
+
+      if (isExit(discoveredModel)) {
+        return discoveredModel;
+      }
+
+      if (isBack(discoveredModel)) {
+        continue;
+      }
+
+      const authMethod = catalog.authMethods[0];
+      const profileName = slugifyProfileName(`${provider.id}-${discoveredModel.id}-${authMethod.id}`);
+      const customProvider = {
+        ...catalog,
+        baseUrl: normalizedOllamaBaseUrl
+      };
+      const profile = buildProfile({
+        provider: customProvider,
+        model: {
+          ...discoveredModel,
+          apiBaseUrl: normalizedOllamaBaseUrl,
+          apiPath: '/api/chat',
+          transportMode: 'gateway',
+          apiStyle: 'ollama-chat',
+          authEnvMode: 'auth_token'
+        },
+        authMethod,
+        profileName,
+        apiKeyEnvVar: catalog.defaultApiKeyEnvVar
+      });
+
+      const filePath = await saveProfile(profile);
+      renderSummary({ profile, filePath });
+      return await waitForAnyKey();
+    }
+
     const totalSteps = catalog.models.length > 1 ? 3 : 2;
     let model = catalog.models[0];