cc-hub-cli 1.1.15 → 1.1.17

package/dist/index.js

@@ -10,7 +10,7 @@ import { Command as Command2 } from "commander";
 // src/config.ts
 import fs4 from "fs";
 import path4 from "path";
-import os3 from "os";
+import os4 from "os";
 
 // src/platform/desktop-app.ts
 import fs2 from "fs";
@@ -266,16 +266,55 @@ function sanitizeToolId(id) {
   }
   return sanitized;
 }
+function buildSystemMessage(system) {
+  if (typeof system === "string") {
+    return { role: "system", content: system };
+  }
+  if (Array.isArray(system)) {
+    const textBlocks = system.filter((b) => b.type === "text" && b.text);
+    const hasCacheControl = textBlocks.some((b) => b.cache_control);
+    if (hasCacheControl) {
+      const parts = textBlocks.map((b) => {
+        const part = { type: "text", text: b.text };
+        if (b.cache_control) part.cache_control = b.cache_control;
+        return part;
+      });
+      if (parts.length > 0) return { role: "system", content: parts };
+    } else {
+      const text = textBlocks.map((b) => b.text).join("\n");
+      if (text) return { role: "system", content: text };
+    }
+  }
+  return null;
+}
+function convertAnthropicContentPart(part) {
+  let convertedPart = null;
+  if (part.type === "image") {
+    if (part.source?.type === "base64" && part.source.media_type && part.source.data) {
+      const url = `data:${part.source.media_type};base64,${part.source.data}`;
+      debug(`transform: converting base64 image (${part.source.media_type}, ${part.source.data.length} chars)`);
+      convertedPart = { type: "image_url", image_url: { url } };
+    } else if (part.source?.type === "url" && part.source.url) {
+      debug(`transform: converting image url (${part.source.url.slice(0, 80)}...)`);
+      convertedPart = { type: "image_url", image_url: { url: part.source.url } };
+    } else {
+      warn(`transform: skipping invalid image block (missing source fields)`);
+      return null;
+    }
+  } else if (part.type === "text") {
+    convertedPart = { type: "text", text: part.text };
+  }
+  if (convertedPart && part.cache_control) {
+    convertedPart.cache_control = part.cache_control;
+  }
+  return convertedPart;
+}
 function transformAnthropicToOpenAI(body) {
   debug(`transform: anthropic -> openai model=${body.model} messages=${(body.messages ?? []).length}`);
   const messages = [];
   if (body.system) {
-    if (typeof body.system === "string") {
-      messages.push({ role: "system", content: body.system });
-    } else if (Array.isArray(body.system)) {
-      const text = body.system.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
-      if (text) messages.push({ role: "system", content: text });
-    }
+    const systemMsg = buildSystemMessage(body.system);
+    if (systemMsg) messages.push(systemMsg);
   }
   for (const msg of body.messages ?? []) {
     if (typeof msg.content === "string") {
@@ -301,23 +340,9 @@ function transformAnthropicToOpenAI(body) {
         (b) => b.type === "text" && b.text || b.type === "image" && (b.source?.type === "base64" && b.source.media_type && b.source.data || b.source?.type === "url" && b.source.url)
       );
       if (contentParts.length > 0) {
-        const converted = contentParts.map((part) => {
-          if (part.type === "image") {
-            if (part.source?.type === "base64" && part.source.media_type && part.source.data) {
-              const url = `data:${part.source.media_type};base64,${part.source.data}`;
-              debug(`transform: converting base64 image (${part.source.media_type}, ${part.source.data.length} chars)`);
-              return { type: "image_url", image_url: { url } };
-            } else if (part.source?.type === "url" && part.source.url) {
-              debug(`transform: converting image url (${part.source.url.slice(0, 80)}...)`);
-              return { type: "image_url", image_url: { url: part.source.url } };
-            }
-            warn(`transform: skipping invalid image block (missing source fields)`);
-            return null;
-          }
-          return { type: "text", text: part.text };
-        }).filter(Boolean);
+        const converted = contentParts.map(convertAnthropicContentPart).filter(Boolean);
         if (converted.length === 0) {
-        } else if (converted.every((p) => p.type === "text")) {
+        } else if (converted.every((p) => p.type === "text") && !converted.some((p) => p.cache_control)) {
           messages.push({
             role: "user",
             content: converted.map((p) => p.text).join("")
@@ -334,6 +359,12 @@ function transformAnthropicToOpenAI(body) {
       if (textParts.length > 0) {
         assistantMsg.content = textParts.map((b) => b.text).join("\n");
       }
+      const thinkingParts = msg.content.filter(
+        (b) => b.type === "thinking" && b.thinking
+      );
+      if (thinkingParts.length > 0) {
+        assistantMsg.reasoning_content = thinkingParts.map((b) => b.thinking).join("\n");
+      }
       const toolUseParts = msg.content.filter(
         (b) => b.type === "tool_use" && b.id
       );
@@ -386,6 +417,13 @@ function transformOpenAIResponseToAnthropic(openaiResponse, originalModel) {
   const choice = openaiResponse.choices?.[0];
   if (!choice) throw new Error("No choices in OpenAI response");
   const content = [];
+  if (choice.message?.reasoning_content) {
+    content.push({
+      type: "thinking",
+      thinking: choice.message.reasoning_content,
+      signature: ""
+    });
+  }
   if (choice.message?.content) {
     content.push({ type: "text", text: choice.message.content });
   }
@@ -422,7 +460,8 @@ function transformOpenAIResponseToAnthropic(openaiResponse, originalModel) {
     usage: {
       input_tokens: (openaiResponse.usage?.prompt_tokens ?? 0) - (openaiResponse.usage?.prompt_tokens_details?.cached_tokens ?? 0),
       output_tokens: openaiResponse.usage?.completion_tokens ?? 0,
-      cache_read_input_tokens: openaiResponse.usage?.prompt_tokens_details?.cached_tokens ?? 0
+      cache_read_input_tokens: openaiResponse.usage?.prompt_tokens_details?.cached_tokens ?? 0,
+      cache_creation_input_tokens: openaiResponse.usage?.prompt_tokens_details?.cache_creation_tokens ?? 0
     }
   };
 }
@@ -445,7 +484,8 @@ data: ${JSON.stringify(data)}
       usage: {
         input_tokens: usage.input_tokens ?? 0,
         output_tokens: 0,
-        cache_read_input_tokens: usage.cache_read_input_tokens ?? 0
+        cache_read_input_tokens: usage.cache_read_input_tokens ?? 0,
+        cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0
       }
     }
   });
@@ -454,7 +494,7 @@ data: ${JSON.stringify(data)}
     yield sse("content_block_start", {
       type: "content_block_start",
       index: i,
-      content_block: block.type === "tool_use" ? { type: "tool_use", id: block.id, name: block.name, input: {} } : { type: "text", text: "" }
+      content_block: block.type === "tool_use" ? { type: "tool_use", id: block.id, name: block.name, input: {} } : block.type === "thinking" ? { type: "thinking", thinking: "", signature: block.signature ?? "" } : { type: "text", text: "" }
     });
     if (block.type === "text" && block.text) {
       yield sse("content_block_delta", {
@@ -462,6 +502,12 @@ data: ${JSON.stringify(data)}
         index: i,
         delta: { type: "text_delta", text: block.text }
       });
+    } else if (block.type === "thinking" && block.thinking) {
+      yield sse("content_block_delta", {
+        type: "content_block_delta",
+        index: i,
+        delta: { type: "thinking_delta", thinking: block.thinking }
+      });
     } else if (block.type === "tool_use" && block.input) {
       yield sse("content_block_delta", {
         type: "content_block_delta",
@@ -482,9 +528,184 @@ data: ${JSON.stringify(data)}
   yield sse("message_stop", { type: "message_stop" });
 }
 
+// src/provider/kimi.ts
+function transformAnthropicToKimi(body) {
+  debug(`transform: anthropic -> kimi model=${body.model} messages=${(body.messages ?? []).length}`);
+  const messages = [];
+  debug(`transform: anthropic -> kimi messageCount=${(body.messages ?? []).length}`);
+  if (body.system) {
+    const systemMsg = buildSystemMessage(body.system);
+    if (systemMsg) messages.push(systemMsg);
+  }
+  for (const msg of body.messages ?? []) {
+    if (typeof msg.content === "string") {
+      messages.push({ role: msg.role, content: msg.content });
+      continue;
+    }
+    if (!Array.isArray(msg.content)) {
+      messages.push({ role: msg.role, content: JSON.stringify(msg.content) });
+      continue;
+    }
+    if (msg.role === "user") {
+      const toolResults = msg.content.filter(
+        (b) => b.type === "tool_result" && b.tool_use_id
+      );
+      for (const tr of toolResults) {
+        messages.push({
+          role: "tool",
+          tool_call_id: sanitizeToolId(tr.tool_use_id),
+          content: typeof tr.content === "string" ? tr.content : Array.isArray(tr.content) ? tr.content.filter((b) => b.type === "text").map((b) => b.text).join("") : JSON.stringify(tr.content)
+        });
+      }
+      const contentParts = msg.content.filter(
+        (b) => b.type === "text" && b.text || b.type === "image" && (b.source?.type === "base64" && b.source.media_type && b.source.data || b.source?.type === "url" && b.source.url)
+      );
+      if (contentParts.length > 0) {
+        const converted = contentParts.map(convertAnthropicContentPart).filter(Boolean);
+        if (converted.length === 0) {
+        } else if (converted.every((p) => p.type === "text") && !converted.some((p) => p.cache_control)) {
+          messages.push({
+            role: "user",
+            content: converted.map((p) => p.text).join("")
+          });
+        } else {
+          messages.push({ role: "user", content: converted });
+        }
+      }
+    } else if (msg.role === "assistant") {
+      const assistantMsg = { role: "assistant", content: null };
+      const textParts = msg.content.filter(
+        (b) => b.type === "text" && b.text
+      );
+      if (textParts.length > 0) {
+        assistantMsg.content = textParts.map((b) => b.text).join("\n");
+      }
+      const thinkingParts = msg.content.filter(
+        (b) => b.type === "thinking" && b.thinking
+      );
+      const toolUseParts = msg.content.filter(
+        (b) => b.type === "tool_use" && b.id
+      );
+      if (toolUseParts.length > 0) {
+        assistantMsg.tool_calls = toolUseParts.map((b) => ({
+          id: sanitizeToolId(b.id),
+          type: "function",
+          function: {
+            name: b.name,
+            arguments: JSON.stringify(b.input ?? {})
+          }
+        }));
+        if (thinkingParts.length > 0) {
+          assistantMsg.reasoning_content = thinkingParts.map((b) => b.thinking).join("\n");
+        } else {
+          assistantMsg.reasoning_content = " ";
+        }
+      } else if (thinkingParts.length > 0) {
+        assistantMsg.reasoning_content = thinkingParts.map((b) => b.thinking).join("\n");
+      }
+      messages.push(assistantMsg);
+    }
+  }
+  const result = {
+    model: body.model,
+    messages,
+    stream: body.stream ?? false
+  };
+  if (body.max_tokens != null) result.max_tokens = body.max_tokens;
+  if (body.temperature != null) result.temperature = body.temperature;
+  if (body.tools?.length) {
+    debug(`transform: mapping ${body.tools.length} tool(s)`);
+    result.tools = body.tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description ?? "",
+        parameters: t.input_schema
+      }
+    }));
+    if (body.tool_choice) {
+      const tc = body.tool_choice;
+      if (tc.type === "auto" || tc.type === "none" || tc.type === "required") {
+        result.tool_choice = tc.type;
+      } else if (tc.type === "tool") {
+        result.tool_choice = {
+          type: "function",
+          function: { name: tc.name }
+        };
+      }
+    }
+  }
+  return result;
+}
+function transformKimiResponseToAnthropic(kimiResponse, originalModel) {
+  debug(`transform: kimi -> anthropic model=${kimiResponse.model ?? originalModel} choices=${kimiResponse.choices?.length ?? 0}`);
+  const choice = kimiResponse.choices?.[0];
+  if (!choice) throw new Error("No choices in Kimi response");
+  const content = [];
+  if (choice.message?.reasoning_content) {
+    content.push({
+      type: "thinking",
+      thinking: choice.message.reasoning_content,
+      signature: ""
+    });
+  }
+  if (choice.message?.content) {
+    content.push({ type: "text", text: choice.message.content });
+  }
+  if (choice.message?.tool_calls?.length) {
+    for (const tc of choice.message.tool_calls) {
+      let input = {};
+      try {
+        input = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
+      } catch {
+        input = { text: tc.function.arguments ?? "" };
+      }
+      content.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.function.name,
+        input
+      });
+    }
+  }
+  const finishMap = {
+    stop: "end_turn",
+    length: "max_tokens",
+    tool_calls: "tool_use",
+    content_filter: "stop_sequence"
+  };
+  const cachedTokens = kimiResponse.usage?.prompt_tokens_details?.cached_tokens ?? kimiResponse.usage?.cached_tokens ?? 0;
+  return {
+    id: kimiResponse.id ?? `msg_${Date.now()}`,
+    type: "message",
+    role: "assistant",
+    model: originalModel,
+    content,
+    stop_reason: finishMap[choice.finish_reason] ?? "end_turn",
+    stop_sequence: null,
+    usage: {
+      input_tokens: (kimiResponse.usage?.prompt_tokens ?? 0) - cachedTokens,
+      output_tokens: kimiResponse.usage?.completion_tokens ?? 0,
+      cache_read_input_tokens: cachedTokens,
+      cache_creation_input_tokens: kimiResponse.usage?.prompt_tokens_details?.cache_creation_tokens ?? 0
+    }
+  };
+}
+
 // src/provider/server.ts
 import http from "http";
-async function startOpenAIProxy(targetUrl, apiKey, model, models = [], modelMappings = {}) {
+import os3 from "os";
+function getKimiHeaders(claudeVersion) {
+  const platform = os3.platform();
+  const stainlessOS = platform === "darwin" ? "MacOS" : platform === "win32" ? "Windows" : "Linux";
+  return {
+    "X-Stainless-OS": stainlessOS,
+    "X-Stainless-Package-Version": "1.1.17",
+    "X-Stainless-Runtime": "node",
+    "User-Agent": `claude-code/${claudeVersion}`
+  };
+}
+async function startOpenAIProxy(targetUrl, apiKey, model, models = [], modelMappings = {}, provider = "openai", claudeVersion = "0.0.0") {
   const base = targetUrl.replace(/\/+$/, "");
   const server = http.createServer(async (req, res) => {
     debug(`Proxy request: ${req.method} ${req.url}`);
@@ -512,7 +733,8 @@ async function startOpenAIProxy(targetUrl, apiKey, model, models = [], modelMapp
         const isStream = !!parsed.stream;
         const requestModel = parsed.model ?? model;
         const actualModel = modelMappings[requestModel] || requestModel;
-        const openaiBody = transformAnthropicToOpenAI({ ...parsed, model: actualModel, stream: false });
+        const transformBody = provider === "kimi" ? transformAnthropicToKimi : transformAnthropicToOpenAI;
+        const openaiBody = transformBody({ ...parsed, model: actualModel, stream: false });
         if (isStream) {
           res.writeHead(200, {
             "Content-Type": "text/event-stream",
@@ -525,7 +747,8 @@ async function startOpenAIProxy(targetUrl, apiKey, model, models = [], modelMapp
               method: "POST",
               headers: {
                 "Content-Type": "application/json",
-                "Authorization": `Bearer ${apiKey}`
+                "Authorization": `Bearer ${apiKey}`,
+                ...provider === "kimi" ? getKimiHeaders(claudeVersion) : {}
               },
               body: JSON.stringify(openaiBody)
             });
@@ -540,7 +763,8 @@ data: ${errText}
               return;
             }
             const data2 = await upstream2.json();
-            const anthropicResponse2 = transformOpenAIResponseToAnthropic(data2, parsed.model ?? model);
+            const transformResponse2 = provider === "kimi" ? transformKimiResponseToAnthropic : transformOpenAIResponseToAnthropic;
+            const anthropicResponse2 = transformResponse2(data2, parsed.model ?? model);
             for (const chunk of synthesizeAnthropicSSE(anthropicResponse2)) {
               res.write(chunk);
             }
@@ -554,7 +778,8 @@ data: ${errText}
           method: "POST",
           headers: {
             "Content-Type": "application/json",
-            "Authorization": `Bearer ${apiKey}`
+            "Authorization": `Bearer ${apiKey}`,
+            ...provider === "kimi" ? getKimiHeaders(claudeVersion) : {}
           },
           body: JSON.stringify(openaiBody)
         });
@@ -566,7 +791,8 @@ data: ${errText}
           return;
         }
         const data = await upstream.json();
-        const anthropicResponse = transformOpenAIResponseToAnthropic(data, parsed.model ?? model);
+        const transformResponse = provider === "kimi" ? transformKimiResponseToAnthropic : transformOpenAIResponseToAnthropic;
+        const anthropicResponse = transformResponse(data, parsed.model ?? model);
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify(anthropicResponse));
         return;
@@ -615,6 +841,10 @@ var PROVIDERS = [
   {
     name: "openai",
     description: "Embedded proxy \u2014 translates Anthropic requests to OpenAI Chat Completions format"
+  },
+  {
+    name: "kimi",
+    description: "Embedded proxy \u2014 translates Anthropic requests to Kimi API format (handles reasoning_content compatibility)"
   }
 ];
 var ANTHROPIC_ALIASES = ["claude-sonnet-4-6", "claude-opus-4-7", "claude-haiku-4-5"];
@@ -763,6 +993,29 @@ var DesktopProfileSyncer = class {
 
 // src/platform/binary-resolver.ts
 import { spawnSync } from "child_process";
+var cachedVersion;
+function getClaudeVersion() {
+  if (cachedVersion) return cachedVersion;
+  debug("binary-resolver: detecting Claude version");
+  try {
+    const result = spawnSync("claude", ["--version"], {
+      shell: process.platform === "win32",
+      encoding: "utf-8"
+    });
+    if (result.status === 0 && result.stdout) {
+      const match = result.stdout.trim().match(/^(\d+\.\d+\.\d+)/);
+      if (match) {
+        cachedVersion = match[1];
+        debug(`binary-resolver: detected Claude version ${cachedVersion}`);
+        return cachedVersion;
+      }
+    }
+  } catch {
+  }
+  cachedVersion = "0.0.0";
+  debug("binary-resolver: could not detect Claude version, using default");
+  return cachedVersion;
+}
 var SystemBinaryResolver = class {
   constructor(app) {
     this.app = app;
@@ -831,10 +1084,10 @@ function createPathCodec() {
 }
 
 // src/config.ts
-var CLAUDE_DIR = process.env.CLAUDE_DIR || path4.join(os3.homedir(), ".claude");
+var CLAUDE_DIR = process.env.CLAUDE_DIR || path4.join(os4.homedir(), ".claude");
 var PROFILES_FILE = process.env.CLAUDE_PROFILES_FILE || path4.join(CLAUDE_DIR, "profiles.json");
 var SETTINGS_FILE = process.env.CLAUDE_SETTINGS_FILE || path4.join(CLAUDE_DIR, "settings.json");
-var CLAUDE_JSON = path4.join(os3.homedir(), ".claude.json");
+var CLAUDE_JSON = path4.join(os4.homedir(), ".claude.json");
 var PROJECTS_DIR = path4.join(CLAUDE_DIR, "projects");
 var SESSIONS_DIR = path4.join(CLAUDE_DIR, "sessions");
 var desktopApp = createDesktopApp();
@@ -996,15 +1249,17 @@ function execClaude(profileName, p, extraArgs) {
   }
   delete env.ANTHROPIC_API_KEY;
   info(`Launching Claude with profile '${profileName}': model=${firstModel || "(default)"} url=${p.url || "(default)"} provider=${p.provider || "anthropic"} binary=${binary}`);
-  if (p.provider === "openai") {
+  if (p.provider === "openai" || p.provider === "kimi") {
     const allModels = p.models || (p.model ? [p.model] : []);
-    debug(`execClaude: starting OpenAI proxy for ${allModels.length} model(s)`);
+    debug(`execClaude: starting ${p.provider} proxy for ${allModels.length} model(s)`);
     startOpenAIProxy(
       p.url || "https://api.openai.com",
       p.token || "",
       firstModel || "gpt-4o",
       allModels,
-      {}
+      {},
+      p.provider,
+      getClaudeVersion()
     ).then(({ baseUrl, stop }) => {
       env.ANTHROPIC_BASE_URL = baseUrl;
       debug(`execClaude: proxy running at ${baseUrl}`);
@@ -2566,7 +2821,15 @@ function proxyCommand() {
       }
       models = [defaultModel];
     }
-    const { baseUrl, stop } = await startOpenAIProxy(targetUrl, apiKey, defaultModel, models, modelMappings);
+    const { baseUrl, stop } = await startOpenAIProxy(
+      targetUrl,
+      apiKey,
+      defaultModel,
+      models,
+      modelMappings,
+      "openai",
+      getClaudeVersion()
+    );
     console.log(`Proxy running at ${baseUrl}`);
     console.log("Press Ctrl+C to stop");
     process.on("SIGINT", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-hub-cli",
-  "version": "1.1.15",
+  "version": "1.1.17",
   "description": "Manage Claude CLI profiles, hooks, and sessions",
   "type": "module",
   "bin": {