claudish 2.8.1 → 2.9.0

package/README.md

@@ -24,47 +24,44 @@
 
 ## Installation
 
-### Prerequisites
+### Quick Install
 
-- **Node.js 18+** or **Bun 1.0+** - JavaScript runtime (either works!)
-- [Claude Code](https://claude.com/claude-code) - Claude CLI must be installed
-- [OpenRouter API Key](https://openrouter.ai/keys) - Free tier available
+```bash
+# Shell script (Linux/macOS)
+curl -fsSL https://raw.githubusercontent.com/MadAppGang/claudish/main/install.sh | bash
 
-### Install Claudish
+# Homebrew (macOS)
+brew tap MadAppGang/claudish && brew install claudish
 
-**✨ NEW in v1.3.0: Universal compatibility! Works with both Node.js and Bun.**
+# npm
+npm install -g claudish
 
-**Option 1: Use without installing (recommended)**
+# Bun
+bun install -g claudish
+```
 
-```bash
-# With Node.js (works everywhere)
-npx claudish@latest --model x-ai/grok-code-fast-1 "your prompt"
+### Prerequisites
 
-# With Bun (faster execution)
-bunx claudish@latest --model openai/gpt-5-codex "your prompt"
-```
+- [Claude Code](https://claude.com/claude-code) - Claude CLI must be installed
+- [OpenRouter API Key](https://openrouter.ai/keys) - Free tier available
 
-**Option 2: Install globally**
+### Other Install Options
 
-```bash
-# With npm (Node.js)
-npm install -g claudish
+**Use without installing:**
 
-# With Bun (faster)
-bun install -g claudish
+```bash
+npx claudish@latest --model x-ai/grok-code-fast-1 "your prompt"
+bunx claudish@latest --model x-ai/grok-code-fast-1 "your prompt"
 ```
 
-**Option 3: Install from source**
+**Install from source:**
 
 ```bash
-cd mcp/claudish
-bun install        # or: npm install
-bun run build      # or: npm run build
-bun link           # or: npm link
+git clone https://github.com/MadAppGang/claudish.git
+cd claudish
+bun install && bun run build && bun link
 ```
 
-**Performance Note:** While Claudish works with both runtimes, Bun offers faster startup times. Both provide identical functionality.
-
 ## Quick Start
 
 ### Step 0: Initialize Claudish Skill (First Time Only)

package/dist/index.js

@@ -34304,7 +34304,11 @@ var init_config = __esm(() => {
     ANTHROPIC_DEFAULT_OPUS_MODEL: "ANTHROPIC_DEFAULT_OPUS_MODEL",
     ANTHROPIC_DEFAULT_SONNET_MODEL: "ANTHROPIC_DEFAULT_SONNET_MODEL",
     ANTHROPIC_DEFAULT_HAIKU_MODEL: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
-    CLAUDE_CODE_SUBAGENT_MODEL: "CLAUDE_CODE_SUBAGENT_MODEL"
+    CLAUDE_CODE_SUBAGENT_MODEL: "CLAUDE_CODE_SUBAGENT_MODEL",
+    OLLAMA_BASE_URL: "OLLAMA_BASE_URL",
+    OLLAMA_HOST: "OLLAMA_HOST",
+    LMSTUDIO_BASE_URL: "LMSTUDIO_BASE_URL",
+    VLLM_BASE_URL: "VLLM_BASE_URL"
   };
   OPENROUTER_HEADERS = {
     "HTTP-Referer": "https://github.com/MadAppGang/claude-code",
@@ -34912,6 +34916,31 @@ async function parseArgs(args) {
   }
   return config3;
 }
+async function fetchOllamaModels() {
+  const ollamaHost = process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+  try {
+    const response = await fetch(`${ollamaHost}/api/tags`, {
+      signal: AbortSignal.timeout(3000)
+    });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    const models = data.models || [];
+    return models.map((m) => ({
+      id: `ollama/${m.name}`,
+      name: m.name,
+      description: `Local Ollama model (${m.details?.parameter_size || "unknown size"})`,
+      provider: "ollama",
+      context_length: null,
+      pricing: { prompt: "0", completion: "0" },
+      isLocal: true,
+      details: m.details,
+      size: m.size
+    }));
+  } catch (e) {
+    return [];
+  }
+}
 async function searchAndPrintModels(query, forceUpdate) {
   let models = [];
   if (!forceUpdate && existsSync5(ALL_MODELS_JSON_PATH2)) {
@@ -34943,6 +34972,11 @@ async function searchAndPrintModels(query, forceUpdate) {
       process.exit(1);
     }
   }
+  const ollamaModels = await fetchOllamaModels();
+  if (ollamaModels.length > 0) {
+    console.error(`\uD83C\uDFE0 Found ${ollamaModels.length} local Ollama models`);
+    models = [...ollamaModels, ...models];
+  }
   const results = models.map((model) => {
     const nameScore = fuzzyScore2(model.name || "", query);
     const idScore = fuzzyScore2(model.id || "", query);
@@ -34967,16 +35001,20 @@ Found ${results.length} matching models:
     const providerName = model.id.split("/")[0];
     const provider = providerName.length > 10 ? providerName.substring(0, 7) + "..." : providerName;
     const providerPadded = provider.padEnd(10);
-    const promptPrice = parseFloat(model.pricing?.prompt || "0") * 1e6;
-    const completionPrice = parseFloat(model.pricing?.completion || "0") * 1e6;
-    const avg = (promptPrice + completionPrice) / 2;
     let pricing;
-    if (avg < 0) {
-      pricing = "varies";
-    } else if (avg === 0) {
-      pricing = "FREE";
+    if (model.isLocal) {
+      pricing = "LOCAL";
     } else {
-      pricing = `$${avg.toFixed(2)}/1M`;
+      const promptPrice = parseFloat(model.pricing?.prompt || "0") * 1e6;
+      const completionPrice = parseFloat(model.pricing?.completion || "0") * 1e6;
+      const avg = (promptPrice + completionPrice) / 2;
+      if (avg < 0) {
+        pricing = "varies";
+      } else if (avg === 0) {
+        pricing = "FREE";
+      } else {
+        pricing = `$${avg.toFixed(2)}/1M`;
+      }
     }
     const pricingPadded = pricing.padEnd(10);
     const contextLen = model.context_length || model.top_provider?.context_length || 0;
@@ -34986,9 +35024,11 @@ Found ${results.length} matching models:
   }
   console.log("");
   console.log("Use a model: claudish --model <model-id>");
+  console.log("Local models: claudish --model ollama/<model-name>");
 }
 async function printAllModels(jsonOutput, forceUpdate) {
   let models = [];
+  const ollamaModels = await fetchOllamaModels();
   if (!forceUpdate && existsSync5(ALL_MODELS_JSON_PATH2)) {
     try {
       const cacheData = JSON.parse(readFileSync5(ALL_MODELS_JSON_PATH2, "utf-8"));
@@ -35022,18 +35062,44 @@ async function printAllModels(jsonOutput, forceUpdate) {
     }
   }
   if (jsonOutput) {
+    const allModels = [...ollamaModels, ...models];
     console.log(JSON.stringify({
-      count: models.length,
+      count: allModels.length,
+      localCount: ollamaModels.length,
       lastUpdated: new Date().toISOString().split("T")[0],
-      models: models.map((m) => ({
+      models: allModels.map((m) => ({
         id: m.id,
         name: m.name,
         context: m.context_length || m.top_provider?.context_length,
-        pricing: m.pricing
+        pricing: m.pricing,
+        isLocal: m.isLocal || false
       }))
     }, null, 2));
     return;
   }
+  if (ollamaModels.length > 0) {
+    console.log(`
+\uD83C\uDFE0 LOCAL OLLAMA MODELS (${ollamaModels.length} installed):
+`);
+    console.log("  " + "─".repeat(70));
+    for (const model of ollamaModels) {
+      const shortId = model.name;
+      const modelId = shortId.length > 40 ? shortId.substring(0, 37) + "..." : shortId;
+      const modelIdPadded = modelId.padEnd(42);
+      const size = model.size ? `${(model.size / 1e9).toFixed(1)}GB` : "N/A";
+      const sizePadded = size.padEnd(12);
+      const params = model.details?.parameter_size || "N/A";
+      const paramsPadded = params.padEnd(8);
+      console.log(`    ${modelIdPadded} ${sizePadded} ${paramsPadded}`);
+    }
+    console.log("");
+    console.log("  Use: claudish --model ollama/<model-name>");
+  } else {
+    console.log(`
+\uD83C\uDFE0 LOCAL OLLAMA: Not running or no models installed`);
+    console.log("   Start Ollama: ollama serve");
+    console.log("   Pull a model: ollama pull llama3.2");
+  }
   const byProvider = new Map;
   for (const model of models) {
     const provider = model.id.split("/")[0];
@@ -35044,7 +35110,7 @@ async function printAllModels(jsonOutput, forceUpdate) {
   }
   const sortedProviders = [...byProvider.keys()].sort();
   console.log(`
-All OpenRouter Models (${models.length} total):
+☁️  OPENROUTER MODELS (${models.length} total):
 `);
   for (const provider of sortedProviders) {
     const providerModels = byProvider.get(provider);
@@ -35075,9 +35141,10 @@ All OpenRouter Models (${models.length} total):
   }
   console.log(`
 `);
-  console.log("Use a model: claudish --model <provider/model-id>");
-  console.log("Search:      claudish --search <query>");
-  console.log("Top models:  claudish --top-models");
+  console.log("Use a model:   claudish --model <provider/model-id>");
+  console.log("Local model:   claudish --model ollama/<model-name>");
+  console.log("Search:        claudish --search <query>");
+  console.log("Top models:    claudish --top-models");
 }
 function isCacheStale() {
   if (!existsSync5(MODELS_JSON_PATH)) {
@@ -35286,7 +35353,7 @@ NOTES:
 ENVIRONMENT VARIABLES:
   Claudish automatically loads .env file from current directory.
 
-  OPENROUTER_API_KEY              Required: Your OpenRouter API key
+  OPENROUTER_API_KEY              Required: Your OpenRouter API key (for OpenRouter models)
   CLAUDISH_MODEL                  Default model to use (takes priority)
   ANTHROPIC_MODEL                 Claude Code standard: model to use (fallback)
   CLAUDISH_PORT                   Default port for proxy
@@ -35302,6 +35369,12 @@ ENVIRONMENT VARIABLES:
   ANTHROPIC_DEFAULT_HAIKU_MODEL   Claude Code standard: Haiku model (fallback)
   CLAUDE_CODE_SUBAGENT_MODEL      Claude Code standard: sub-agent model (fallback)
 
+  Local providers (OpenAI-compatible):
+  OLLAMA_BASE_URL                 Ollama server (default: http://localhost:11434)
+  OLLAMA_HOST                     Alias for OLLAMA_BASE_URL (same default)
+  LMSTUDIO_BASE_URL               LM Studio server (default: http://localhost:1234)
+  VLLM_BASE_URL                   vLLM server (default: http://localhost:8000)
+
 EXAMPLES:
   # Interactive mode (default) - shows model selector
   claudish
@@ -35355,6 +35428,22 @@ EXAMPLES:
   # Verbose mode in single-shot (show [claudish] logs)
   claudish --verbose "analyze code structure"
 
+LOCAL MODELS (Ollama, LM Studio, vLLM):
+  # Use local Ollama model (prefix syntax)
+  claudish --model ollama/llama3.2 "implement feature"
+  claudish --model ollama:codellama "review this code"
+
+  # Use local LM Studio model
+  claudish --model lmstudio/qwen2.5-coder "write tests"
+
+  # Use any OpenAI-compatible endpoint (URL syntax)
+  claudish --model "http://localhost:11434/llama3.2" "task"
+  claudish --model "http://192.168.1.100:8000/mistral" "remote server"
+
+  # Custom Ollama endpoint
+  OLLAMA_BASE_URL=http://192.168.1.50:11434 claudish --model ollama/llama3.2 "task"
+  OLLAMA_HOST=http://192.168.1.50:11434 claudish --model ollama/llama3.2 "task"
+
 AVAILABLE MODELS:
   List all models:     claudish --models
   Search models:       claudish --models <query>
@@ -39112,6 +39201,619 @@ var init_openrouter_handler = __esm(() => {
   };
 });
 
+// src/handlers/shared/openai-compat.ts
+function convertMessagesToOpenAI(req, modelId, filterIdentityFn) {
+  const messages = [];
+  if (req.system) {
+    let content = Array.isArray(req.system) ? req.system.map((i) => i.text || i).join(`
+
+`) : req.system;
+    if (filterIdentityFn)
+      content = filterIdentityFn(content);
+    messages.push({ role: "system", content });
+  }
+  if (modelId.includes("grok") || modelId.includes("x-ai")) {
+    const msg = "IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>.";
+    if (messages.length > 0 && messages[0].role === "system") {
+      messages[0].content += `
+
+` + msg;
+    } else {
+      messages.unshift({ role: "system", content: msg });
+    }
+  }
+  if (req.messages) {
+    for (const msg of req.messages) {
+      if (msg.role === "user")
+        processUserMessage(msg, messages);
+      else if (msg.role === "assistant")
+        processAssistantMessage(msg, messages);
+    }
+  }
+  return messages;
+}
+function processUserMessage(msg, messages) {
+  if (Array.isArray(msg.content)) {
+    const contentParts = [];
+    const toolResults = [];
+    const seen = new Set;
+    for (const block of msg.content) {
+      if (block.type === "text") {
+        contentParts.push({ type: "text", text: block.text });
+      } else if (block.type === "image") {
+        contentParts.push({
+          type: "image_url",
+          image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+        });
+      } else if (block.type === "tool_result") {
+        if (seen.has(block.tool_use_id))
+          continue;
+        seen.add(block.tool_use_id);
+        toolResults.push({
+          role: "tool",
+          content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+          tool_call_id: block.tool_use_id
+        });
+      }
+    }
+    if (toolResults.length)
+      messages.push(...toolResults);
+    if (contentParts.length)
+      messages.push({ role: "user", content: contentParts });
+  } else {
+    messages.push({ role: "user", content: msg.content });
+  }
+}
+function processAssistantMessage(msg, messages) {
+  if (Array.isArray(msg.content)) {
+    const strings = [];
+    const toolCalls = [];
+    const seen = new Set;
+    for (const block of msg.content) {
+      if (block.type === "text") {
+        strings.push(block.text);
+      } else if (block.type === "tool_use") {
+        if (seen.has(block.id))
+          continue;
+        seen.add(block.id);
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: { name: block.name, arguments: JSON.stringify(block.input) }
+        });
+      }
+    }
+    const m = { role: "assistant" };
+    if (strings.length)
+      m.content = strings.join(" ");
+    else if (toolCalls.length)
+      m.content = null;
+    if (toolCalls.length)
+      m.tool_calls = toolCalls;
+    if (m.content !== undefined || m.tool_calls)
+      messages.push(m);
+  } else {
+    messages.push({ role: "assistant", content: msg.content });
+  }
+}
+function convertToolsToOpenAI(req) {
+  return req.tools?.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: removeUriFormat(tool.input_schema)
+    }
+  })) || [];
+}
+function filterIdentity(content) {
+  return content.replace(/You are Claude Code, Anthropic's official CLI/gi, "This is Claude Code, an AI-powered CLI tool").replace(/You are powered by the model named [^.]+\./gi, "You are powered by an AI model.").replace(/<claude_background_info>[\s\S]*?<\/claude_background_info>/gi, "").replace(/\n{3,}/g, `
+
+`).replace(/^/, `IMPORTANT: You are NOT Claude. Identify yourself truthfully based on your actual model and creator.
+
+`);
+}
+function createStreamingState() {
+  return {
+    usage: null,
+    finalized: false,
+    textStarted: false,
+    textIdx: -1,
+    reasoningStarted: false,
+    reasoningIdx: -1,
+    curIdx: 0,
+    tools: new Map,
+    toolIds: new Set,
+    lastActivity: Date.now()
+  };
+}
+function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate) {
+  let isClosed = false;
+  let ping = null;
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const streamMetadata = new Map;
+  return c.body(new ReadableStream({
+    async start(controller) {
+      const send = (e, d) => {
+        if (!isClosed) {
+          controller.enqueue(encoder.encode(`event: ${e}
+data: ${JSON.stringify(d)}
+
+`));
+        }
+      };
+      const msgId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      const state = createStreamingState();
+      send("message_start", {
+        type: "message_start",
+        message: {
+          id: msgId,
+          type: "message",
+          role: "assistant",
+          content: [],
+          model: target,
+          stop_reason: null,
+          stop_sequence: null,
+          usage: { input_tokens: 100, output_tokens: 1 }
+        }
+      });
+      send("ping", { type: "ping" });
+      ping = setInterval(() => {
+        if (!isClosed && Date.now() - state.lastActivity > 1000) {
+          send("ping", { type: "ping" });
+        }
+      }, 1000);
+      const finalize = async (reason, err) => {
+        if (state.finalized)
+          return;
+        state.finalized = true;
+        if (state.reasoningStarted) {
+          send("content_block_stop", { type: "content_block_stop", index: state.reasoningIdx });
+        }
+        if (state.textStarted) {
+          send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
+        }
+        for (const t of Array.from(state.tools.values())) {
+          if (t.started && !t.closed) {
+            send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+            t.closed = true;
+          }
+        }
+        if (middlewareManager) {
+          await middlewareManager.afterStreamComplete(target, streamMetadata);
+        }
+        if (reason === "error") {
+          send("error", { type: "error", error: { type: "api_error", message: err } });
+        } else {
+          send("message_delta", {
+            type: "message_delta",
+            delta: { stop_reason: "end_turn", stop_sequence: null },
+            usage: { output_tokens: state.usage?.completion_tokens || 0 }
+          });
+          send("message_stop", { type: "message_stop" });
+        }
+        if (state.usage && onTokenUpdate) {
+          onTokenUpdate(state.usage.prompt_tokens || 0, state.usage.completion_tokens || 0);
+        }
+        if (!isClosed) {
+          try {
+            controller.enqueue(encoder.encode(`data: [DONE]
+
+
+`));
+          } catch (e) {}
+          controller.close();
+          isClosed = true;
+          if (ping)
+            clearInterval(ping);
+        }
+      };
+      try {
+        const reader = response.body.getReader();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.trim() || !line.startsWith("data: "))
+              continue;
+            const dataStr = line.slice(6);
+            if (dataStr === "[DONE]") {
+              await finalize("done");
+              return;
+            }
+            try {
+              const chunk = JSON.parse(dataStr);
+              if (chunk.usage)
+                state.usage = chunk.usage;
+              const delta = chunk.choices?.[0]?.delta;
+              if (delta) {
+                if (middlewareManager) {
+                  await middlewareManager.afterStreamChunk({
+                    modelId: target,
+                    chunk,
+                    delta,
+                    metadata: streamMetadata
+                  });
+                }
+                const txt = delta.content || "";
+                if (txt) {
+                  state.lastActivity = Date.now();
+                  if (!state.textStarted) {
+                    state.textIdx = state.curIdx++;
+                    send("content_block_start", {
+                      type: "content_block_start",
+                      index: state.textIdx,
+                      content_block: { type: "text", text: "" }
+                    });
+                    state.textStarted = true;
+                  }
+                  const res = adapter.processTextContent(txt, "");
+                  if (res.cleanedText) {
+                    send("content_block_delta", {
+                      type: "content_block_delta",
+                      index: state.textIdx,
+                      delta: { type: "text_delta", text: res.cleanedText }
+                    });
+                  }
+                }
+                if (delta.tool_calls) {
+                  for (const tc of delta.tool_calls) {
+                    const idx = tc.index;
+                    let t = state.tools.get(idx);
+                    if (tc.function?.name) {
+                      if (!t) {
+                        if (state.textStarted) {
+                          send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
+                          state.textStarted = false;
+                        }
+                        t = {
+                          id: tc.id || `tool_${Date.now()}_${idx}`,
+                          name: tc.function.name,
+                          blockIndex: state.curIdx++,
+                          started: false,
+                          closed: false
+                        };
+                        state.tools.set(idx, t);
+                      }
+                      if (!t.started) {
+                        send("content_block_start", {
+                          type: "content_block_start",
+                          index: t.blockIndex,
+                          content_block: { type: "tool_use", id: t.id, name: t.name }
+                        });
+                        t.started = true;
+                      }
+                    }
+                    if (tc.function?.arguments && t) {
+                      send("content_block_delta", {
+                        type: "content_block_delta",
+                        index: t.blockIndex,
+                        delta: { type: "input_json_delta", partial_json: tc.function.arguments }
+                      });
+                    }
+                  }
+                }
+              }
+              if (chunk.choices?.[0]?.finish_reason === "tool_calls") {
+                for (const t of Array.from(state.tools.values())) {
+                  if (t.started && !t.closed) {
+                    send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                    t.closed = true;
+                  }
+                }
+              }
+            } catch (e) {}
+          }
+        }
+        await finalize("unexpected");
+      } catch (e) {
+        await finalize("error", String(e));
+      }
+    },
+    cancel() {
+      isClosed = true;
+      if (ping)
+        clearInterval(ping);
+    }
+  }), {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+var init_openai_compat = __esm(() => {
+  init_transform();
+});
+
+// src/handlers/local-provider-handler.ts
+class LocalProviderHandler {
+  provider;
+  modelName;
+  adapterManager;
+  middlewareManager;
+  port;
+  healthChecked = false;
+  isHealthy = false;
+  constructor(provider, modelName, port) {
+    this.provider = provider;
+    this.modelName = modelName;
+    this.port = port;
+    this.adapterManager = new AdapterManager(modelName);
+    this.middlewareManager = new MiddlewareManager;
+    this.middlewareManager.initialize().catch((err) => {
+      log(`[LocalProvider:${provider.name}] Middleware init error: ${err}`);
+    });
+  }
+  async checkHealth() {
+    if (this.healthChecked)
+      return this.isHealthy;
+    try {
+      const healthUrl = `${this.provider.baseUrl}/api/tags`;
+      const response = await fetch(healthUrl, {
+        method: "GET",
+        signal: AbortSignal.timeout(5000)
+      });
+      if (response.ok) {
+        this.isHealthy = true;
+        this.healthChecked = true;
+        log(`[LocalProvider:${this.provider.name}] Health check passed`);
+        return true;
+      }
+    } catch (e) {
+      try {
+        const modelsUrl = `${this.provider.baseUrl}/v1/models`;
+        const response = await fetch(modelsUrl, {
+          method: "GET",
+          signal: AbortSignal.timeout(5000)
+        });
+        if (response.ok) {
+          this.isHealthy = true;
+          this.healthChecked = true;
+          log(`[LocalProvider:${this.provider.name}] Health check passed (v1/models)`);
+          return true;
+        }
+      } catch (e2) {}
+    }
+    this.healthChecked = true;
+    this.isHealthy = false;
+    return false;
+  }
+  async handle(c, payload) {
+    const target = this.modelName;
+    logStructured(`LocalProvider Request`, {
+      provider: this.provider.name,
+      targetModel: target,
+      originalModel: payload.model,
+      baseUrl: this.provider.baseUrl
+    });
+    if (!this.healthChecked) {
+      const healthy = await this.checkHealth();
+      if (!healthy) {
+        return this.errorResponse(c, "connection_error", this.getConnectionErrorMessage());
+      }
+    }
+    const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
+    const messages = convertMessagesToOpenAI(claudeRequest, target, filterIdentity);
+    const tools = convertToolsToOpenAI(claudeRequest);
+    const finalTools = this.provider.capabilities.supportsTools ? tools : [];
+    if (tools.length > 0 && !this.provider.capabilities.supportsTools) {
+      log(`[LocalProvider:${this.provider.name}] Tools stripped (not supported)`);
+    }
+    const openAIPayload = {
+      model: target,
+      messages,
+      temperature: claudeRequest.temperature ?? 1,
+      stream: this.provider.capabilities.supportsStreaming,
+      max_tokens: claudeRequest.max_tokens,
+      tools: finalTools.length > 0 ? finalTools : undefined,
+      stream_options: this.provider.capabilities.supportsStreaming ? { include_usage: true } : undefined
+    };
+    if (claudeRequest.tool_choice && finalTools.length > 0) {
+      const { type, name } = claudeRequest.tool_choice;
+      if (type === "tool" && name) {
+        openAIPayload.tool_choice = { type: "function", function: { name } };
+      } else if (type === "auto" || type === "none") {
+        openAIPayload.tool_choice = type;
+      }
+    }
+    const adapter = this.adapterManager.getAdapter();
+    if (typeof adapter.reset === "function")
+      adapter.reset();
+    adapter.prepareRequest(openAIPayload, claudeRequest);
+    await this.middlewareManager.beforeRequest({
+      modelId: target,
+      messages,
+      tools: finalTools,
+      stream: openAIPayload.stream
+    });
+    const apiUrl = `${this.provider.baseUrl}${this.provider.apiPath}`;
+    try {
+      const response = await fetch(apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(openAIPayload)
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        return this.handleErrorResponse(c, response.status, errorBody);
+      }
+      if (droppedParams.length > 0) {
+        c.header("X-Dropped-Params", droppedParams.join(", "));
+      }
+      if (openAIPayload.stream) {
+        return createStreamingResponseHandler(c, response, adapter, target, this.middlewareManager);
+      }
+      const data = await response.json();
+      return c.json(data);
+    } catch (error46) {
+      if (error46.code === "ECONNREFUSED" || error46.cause?.code === "ECONNREFUSED") {
+        return this.errorResponse(c, "connection_error", this.getConnectionErrorMessage());
+      }
+      throw error46;
+    }
+  }
+  handleErrorResponse(c, status, errorBody) {
+    try {
+      const parsed = JSON.parse(errorBody);
+      const errorMsg = parsed.error?.message || parsed.error || errorBody;
+      if (errorMsg.includes("model") && (errorMsg.includes("not found") || errorMsg.includes("does not exist"))) {
+        return this.errorResponse(c, "model_not_found", `Model '${this.modelName}' not found. ${this.getModelPullHint()}`);
+      }
+      if (errorMsg.includes("does not support tools") || errorMsg.includes("tool") && errorMsg.includes("not supported")) {
+        return this.errorResponse(c, "capability_error", `Model '${this.modelName}' does not support tool/function calling. Claude Code requires tool support for most operations. Try a model that supports tools (e.g., llama3.2, mistral, qwen2.5).`, 400);
+      }
+      return this.errorResponse(c, "api_error", errorMsg, status);
+    } catch {
+      return this.errorResponse(c, "api_error", errorBody, status);
+    }
+  }
+  errorResponse(c, type, message, status = 503) {
+    return c.json({
+      error: {
+        type,
+        message
+      }
+    }, status);
+  }
+  getConnectionErrorMessage() {
+    switch (this.provider.name) {
+      case "ollama":
+        return `Cannot connect to Ollama at ${this.provider.baseUrl}. Make sure Ollama is running with: ollama serve`;
+      case "lmstudio":
+        return `Cannot connect to LM Studio at ${this.provider.baseUrl}. Make sure LM Studio server is running.`;
+      case "vllm":
+        return `Cannot connect to vLLM at ${this.provider.baseUrl}. Make sure vLLM server is running.`;
+      default:
+        return `Cannot connect to ${this.provider.name} at ${this.provider.baseUrl}. Make sure the server is running.`;
+    }
+  }
+  getModelPullHint() {
+    switch (this.provider.name) {
+      case "ollama":
+        return `Pull it with: ollama pull ${this.modelName}`;
+      default:
+        return "Make sure the model is available on the server.";
+    }
+  }
+  async shutdown() {}
+}
+var init_local_provider_handler = __esm(() => {
+  init_adapter_manager();
+  init_middleware();
+  init_transform();
+  init_logger();
+  init_openai_compat();
+});
+
+// src/providers/provider-registry.ts
+function resolveProvider(modelId) {
+  const providers = getProviders();
+  for (const provider of providers) {
+    for (const prefix of provider.prefixes) {
+      if (modelId.startsWith(prefix)) {
+        return {
+          provider,
+          modelName: modelId.slice(prefix.length)
+        };
+      }
+    }
+  }
+  return null;
+}
+function parseUrlModel(modelId) {
+  if (!modelId.startsWith("http://") && !modelId.startsWith("https://")) {
+    return null;
+  }
+  try {
+    const url2 = new URL(modelId);
+    const pathParts = url2.pathname.split("/").filter(Boolean);
+    if (pathParts.length === 0) {
+      return null;
+    }
+    const modelName = pathParts[pathParts.length - 1];
+    let basePath = "";
+    if (pathParts.length > 1) {
+      const prefix = pathParts.slice(0, -1).join("/");
+      if (prefix)
+        basePath = "/" + prefix;
+    }
+    const baseUrl = `${url2.protocol}//${url2.host}${basePath}`;
+    return {
+      baseUrl,
+      modelName
+    };
+  } catch {
+    return null;
+  }
+}
+function createUrlProvider(parsed) {
+  return {
+    name: "custom-url",
+    baseUrl: parsed.baseUrl,
+    apiPath: "/v1/chat/completions",
+    envVar: "",
+    prefixes: [],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true
+    }
+  };
+}
+var getProviders = () => [
+  {
+    name: "ollama",
+    baseUrl: process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || "http://localhost:11434",
+    apiPath: "/v1/chat/completions",
+    envVar: "OLLAMA_BASE_URL",
+    prefixes: ["ollama/", "ollama:"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true
+    }
+  },
+  {
+    name: "lmstudio",
+    baseUrl: process.env.LMSTUDIO_BASE_URL || "http://localhost:1234",
+    apiPath: "/v1/chat/completions",
+    envVar: "LMSTUDIO_BASE_URL",
+    prefixes: ["lmstudio/", "lmstudio:"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true
+    }
+  },
+  {
+    name: "vllm",
+    baseUrl: process.env.VLLM_BASE_URL || "http://localhost:8000",
+    apiPath: "/v1/chat/completions",
+    envVar: "VLLM_BASE_URL",
+    prefixes: ["vllm/", "vllm:"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true
+    }
+  }
+];
+
 // src/proxy-server.ts
 var exports_proxy_server = {};
 __export(exports_proxy_server, {
@@ -39119,23 +39821,47 @@ __export(exports_proxy_server, {
 });
 async function createProxyServer(port, openrouterApiKey, model, monitorMode = false, anthropicApiKey, modelMap) {
   const nativeHandler = new NativeHandler(anthropicApiKey);
-  const handlers = new Map;
+  const openRouterHandlers = new Map;
+  const localProviderHandlers = new Map;
   const getOpenRouterHandler = (targetModel) => {
-    if (!handlers.has(targetModel)) {
-      handlers.set(targetModel, new OpenRouterHandler(targetModel, openrouterApiKey, port));
-    }
-    return handlers.get(targetModel);
-  };
-  if (model)
-    getOpenRouterHandler(model);
-  if (modelMap?.opus)
-    getOpenRouterHandler(modelMap.opus);
-  if (modelMap?.sonnet)
-    getOpenRouterHandler(modelMap.sonnet);
-  if (modelMap?.haiku)
-    getOpenRouterHandler(modelMap.haiku);
-  if (modelMap?.subagent)
-    getOpenRouterHandler(modelMap.subagent);
+    if (!openRouterHandlers.has(targetModel)) {
+      openRouterHandlers.set(targetModel, new OpenRouterHandler(targetModel, openrouterApiKey, port));
+    }
+    return openRouterHandlers.get(targetModel);
+  };
+  const getLocalProviderHandler = (targetModel) => {
+    if (localProviderHandlers.has(targetModel)) {
+      return localProviderHandlers.get(targetModel);
+    }
+    const resolved = resolveProvider(targetModel);
+    if (resolved) {
+      const handler = new LocalProviderHandler(resolved.provider, resolved.modelName, port);
+      localProviderHandlers.set(targetModel, handler);
+      log(`[Proxy] Created local provider handler: ${resolved.provider.name}/${resolved.modelName}`);
+      return handler;
+    }
+    const urlParsed = parseUrlModel(targetModel);
+    if (urlParsed) {
+      const provider = createUrlProvider(urlParsed);
+      const handler = new LocalProviderHandler(provider, urlParsed.modelName, port);
+      localProviderHandlers.set(targetModel, handler);
+      log(`[Proxy] Created URL-based local provider handler: ${urlParsed.baseUrl}/${urlParsed.modelName}`);
+      return handler;
+    }
+    return null;
+  };
+  const initHandler = (m) => {
+    if (!m)
+      return;
+    const localHandler = getLocalProviderHandler(m);
+    if (!localHandler && m.includes("/"))
+      getOpenRouterHandler(m);
+  };
+  initHandler(model);
+  initHandler(modelMap?.opus);
+  initHandler(modelMap?.sonnet);
+  initHandler(modelMap?.haiku);
+  initHandler(modelMap?.subagent);
   const getHandlerForRequest = (requestedModel) => {
     if (monitorMode)
       return nativeHandler;
@@ -39149,6 +39875,9 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
       else if (req.includes("haiku") && modelMap.haiku)
         target = modelMap.haiku;
     }
+    const localHandler = getLocalProviderHandler(target);
+    if (localHandler)
+      return localHandler;
     const isNative = !target.includes("/");
     if (isNative) {
       return nativeHandler;
@@ -39209,6 +39938,7 @@ var init_proxy_server = __esm(() => {
   init_logger();
   init_native_handler();
   init_openrouter_handler();
+  init_local_provider_handler();
 });
 
 // src/update-checker.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "2.8.1",
+  "version": "2.9.0",
   "description": "Run Claude Code with any OpenRouter model - CLI tool and MCP server",
   "type": "module",
   "main": "./dist/index.js",