claude-connect 0.1.4 → 0.1.6

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`, `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%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`, `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,8 @@ 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`
 - `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 +91,8 @@ 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 |
 | `OpenRouter` | `openrouter/free` | `Token` | Gateway local |
 | `Qwen` | `qwen3-coder-plus` | `OAuth`, `Token` | Gateway local |
 
@@ -103,6 +107,28 @@ 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 `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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-connect",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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

@@ -521,6 +521,158 @@ 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: 'openrouter',
     name: 'OpenRouter',

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/index.js

@@ -1,3 +1,4 @@
+import packageJson from '../package.json' with { type: 'json' };
 import { getCatalogStore } from './data/catalog-store.js';
 import { gatewayBaseUrl } from './gateway/constants.js';
 import { getGatewayStatus } from './gateway/state.js';
@@ -18,6 +19,10 @@ function printGatewayStatus(status) {
   process.stdout.write(`${lines.join('\n')}\n`);
 }
 
+function printVersion() {
+  process.stdout.write(`${packageJson.version}\n`);
+}
+
 async function runGatewayCommand(args) {
   const action = args[0] ?? 'status';
 
@@ -51,6 +56,11 @@ async function runGatewayCommand(args) {
 }
 
 export async function run(argv = process.argv.slice(2)) {
+  if (argv[0] === '--version' || argv[0] === '-v' || argv[0] === 'version') {
+    printVersion();
+    return;
+  }
+
   if (argv[0] === 'gateway') {
     await runGatewayCommand(argv.slice(1));
     return;

package/src/lib/claude-settings.js

@@ -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;

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)]
     })
@@ -561,7 +574,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 +716,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];