claudish 3.3.10 → 3.3.11

package/dist/index.js

@@ -56301,31 +56301,51 @@ var init_remote_provider_types = __esm(() => {
     "gemini-3.0-flash": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
     "gemini-2.0-flash": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
     "gemini-2.0-flash-thinking": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
-    default: { inputCostPer1M: 0.5, outputCostPer1M: 2 }
+    default: { inputCostPer1M: 0.5, outputCostPer1M: 2, isEstimate: true }
   };
   OPENAI_PRICING = {
-    "gpt-5": { inputCostPer1M: 2, outputCostPer1M: 8 },
-    "gpt-5.2": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
-    "gpt-5-turbo": { inputCostPer1M: 1.5, outputCostPer1M: 6 },
-    "gpt-5.1-codex": { inputCostPer1M: 3, outputCostPer1M: 12 },
+    "gpt-5.2": { inputCostPer1M: 1.75, outputCostPer1M: 14 },
+    "gpt-5.2-codex": { inputCostPer1M: 1.75, outputCostPer1M: 14 },
+    "gpt-5.2-chat-latest": { inputCostPer1M: 1.75, outputCostPer1M: 14 },
+    "gpt-5.2-pro": { inputCostPer1M: 21, outputCostPer1M: 168 },
+    "gpt-5.1": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5.1-codex": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5.1-codex-max": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5.1-codex-mini": { inputCostPer1M: 0.25, outputCostPer1M: 2 },
+    "gpt-5.1-chat-latest": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5-codex": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5-chat-latest": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5-mini": { inputCostPer1M: 0.25, outputCostPer1M: 2 },
+    "gpt-5-nano": { inputCostPer1M: 0.05, outputCostPer1M: 0.4 },
+    "gpt-5-pro": { inputCostPer1M: 15, outputCostPer1M: 120 },
+    "gpt-4.1": { inputCostPer1M: 2, outputCostPer1M: 8 },
+    "gpt-4.1-mini": { inputCostPer1M: 0.4, outputCostPer1M: 1.6 },
+    "gpt-4.1-nano": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
     "gpt-4o": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
+    "gpt-4o-2024-05-13": { inputCostPer1M: 5, outputCostPer1M: 15 },
     "gpt-4o-mini": { inputCostPer1M: 0.15, outputCostPer1M: 0.6 },
     "gpt-4o-audio": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
     o1: { inputCostPer1M: 15, outputCostPer1M: 60 },
-    "o1-mini": { inputCostPer1M: 3, outputCostPer1M: 12 },
-    "o1-preview": { inputCostPer1M: 15, outputCostPer1M: 60 },
-    o3: { inputCostPer1M: 15, outputCostPer1M: 60 },
-    "o3-mini": { inputCostPer1M: 3, outputCostPer1M: 12 },
+    "o1-mini": { inputCostPer1M: 1.1, outputCostPer1M: 4.4 },
+    "o1-pro": { inputCostPer1M: 150, outputCostPer1M: 600 },
+    o3: { inputCostPer1M: 2, outputCostPer1M: 8 },
+    "o3-mini": { inputCostPer1M: 1.1, outputCostPer1M: 4.4 },
+    "o3-pro": { inputCostPer1M: 20, outputCostPer1M: 80 },
+    "o3-deep-research": { inputCostPer1M: 10, outputCostPer1M: 40 },
+    "o4-mini": { inputCostPer1M: 1.1, outputCostPer1M: 4.4 },
+    "o4-mini-deep-research": { inputCostPer1M: 2, outputCostPer1M: 8 },
     "gpt-4-turbo": { inputCostPer1M: 10, outputCostPer1M: 30 },
     "gpt-4-turbo-preview": { inputCostPer1M: 10, outputCostPer1M: 30 },
     "gpt-4": { inputCostPer1M: 30, outputCostPer1M: 60 },
     "gpt-3.5-turbo": { inputCostPer1M: 0.5, outputCostPer1M: 1.5 },
-    default: { inputCostPer1M: 2, outputCostPer1M: 8 }
+    "codex-mini-latest": { inputCostPer1M: 1.5, outputCostPer1M: 6 },
+    default: { inputCostPer1M: 2, outputCostPer1M: 8, isEstimate: true }
   };
   MINIMAX_PRICING = {
     "minimax-m2.1": { inputCostPer1M: 0.12, outputCostPer1M: 0.48 },
     "minimax-m2": { inputCostPer1M: 0.12, outputCostPer1M: 0.48 },
-    default: { inputCostPer1M: 0.12, outputCostPer1M: 0.48 }
+    default: { inputCostPer1M: 0.12, outputCostPer1M: 0.48, isEstimate: true }
   };
   KIMI_PRICING = {
     "kimi-k2-thinking-turbo": { inputCostPer1M: 0.32, outputCostPer1M: 0.48 },
@@ -56333,13 +56353,13 @@ var init_remote_provider_types = __esm(() => {
     "kimi-k2-turbo-preview": { inputCostPer1M: 0.2, outputCostPer1M: 0.4 },
     "kimi-k2-0905-preview": { inputCostPer1M: 0.2, outputCostPer1M: 0.4 },
     "kimi-k2": { inputCostPer1M: 0.2, outputCostPer1M: 0.4 },
-    default: { inputCostPer1M: 0.32, outputCostPer1M: 0.48 }
+    default: { inputCostPer1M: 0.32, outputCostPer1M: 0.48, isEstimate: true }
   };
   GLM_PRICING = {
     "glm-4.7": { inputCostPer1M: 0.16, outputCostPer1M: 0.8 },
     "glm-4": { inputCostPer1M: 0.16, outputCostPer1M: 0.8 },
     "glm-4-plus": { inputCostPer1M: 0.5, outputCostPer1M: 2 },
-    default: { inputCostPer1M: 0.16, outputCostPer1M: 0.8 }
+    default: { inputCostPer1M: 0.16, outputCostPer1M: 0.8, isEstimate: true }
   };
 });
 
@@ -56980,7 +57000,7 @@ class OpenAIHandler {
     }
     return `${this.provider.baseUrl}${this.provider.apiPath}`;
   }
-  writeTokenFile(input, output) {
+  writeTokenFile(input, output, isEstimate) {
     try {
       const total = input + output;
       const leftPct = this.contextWindow > 0 ? Math.max(0, Math.min(100, Math.round((this.contextWindow - total) / this.contextWindow * 100))) : 100;
@@ -56993,6 +57013,9 @@ class OpenAIHandler {
         context_left_percent: leftPct,
         updated_at: Date.now()
       };
+      if (isEstimate) {
+        data.cost_is_estimate = true;
+      }
       const claudishDir = join9(homedir5(), ".claudish");
       mkdirSync6(claudishDir, { recursive: true });
       writeFileSync8(join9(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
@@ -57001,13 +57024,23 @@ class OpenAIHandler {
     }
   }
   updateTokenTracking(inputTokens, outputTokens) {
-    const incrementalInputTokens = Math.max(0, inputTokens - this.sessionInputTokens);
-    this.sessionInputTokens = inputTokens;
+    let incrementalInputTokens;
+    if (inputTokens >= this.sessionInputTokens) {
+      incrementalInputTokens = inputTokens - this.sessionInputTokens;
+      this.sessionInputTokens = inputTokens;
+    } else if (inputTokens < this.sessionInputTokens * 0.5) {
+      incrementalInputTokens = inputTokens;
+      log(`[OpenAIHandler] Token tracking: detected concurrent conversation (${inputTokens} < ${this.sessionInputTokens}), charging full input`);
+    } else {
+      incrementalInputTokens = inputTokens;
+      this.sessionInputTokens = inputTokens;
+      log(`[OpenAIHandler] Token tracking: ambiguous token decrease (${inputTokens} vs ${this.sessionInputTokens}), charging full input`);
+    }
     this.sessionOutputTokens += outputTokens;
     const pricing = this.getPricing();
     const cost = incrementalInputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
     this.sessionTotalCost += cost;
-    this.writeTokenFile(inputTokens, this.sessionOutputTokens);
+    this.writeTokenFile(Math.max(inputTokens, this.sessionInputTokens), this.sessionOutputTokens, pricing.isEstimate);
   }
   convertMessages(claudeRequest) {
     return convertMessagesToOpenAI(claudeRequest, `openai/${this.modelName}`, filterIdentity);
@@ -57158,7 +57191,7 @@ class OpenAIHandler {
       payload.instructions = claudeRequest.system;
     }
     if (claudeRequest.max_tokens) {
-      payload.max_output_tokens = claudeRequest.max_tokens;
+      payload.max_output_tokens = Math.max(16, claudeRequest.max_tokens);
     }
     if (tools.length > 0) {
       payload.tools = tools.map((tool) => {
@@ -57188,11 +57221,22 @@ class OpenAIHandler {
     let outputTokens = 0;
     let hasTextContent = false;
     let hasToolUse = false;
+    let lastActivity = Date.now();
+    let pingInterval = null;
+    let isClosed = false;
     const functionCalls = new Map;
     const stream = new ReadableStream({
       start: async (controller) => {
+        const send = (event, data) => {
+          if (!isClosed) {
+            controller.enqueue(encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`));
+          }
+        };
         log(`[OpenAIHandler] Sending message_start with placeholder tokens`);
-        const messageStart = {
+        send("message_start", {
           type: "message_start",
           message: {
             id: `msg_${Date.now()}`,
@@ -57204,20 +57248,19 @@ class OpenAIHandler {
             stop_sequence: null,
             usage: { input_tokens: 100, output_tokens: 1 }
           }
-        };
-        controller.enqueue(encoder.encode(`event: message_start
-data: ${JSON.stringify(messageStart)}
-
-`));
-        controller.enqueue(encoder.encode(`event: ping
-data: {"type":"ping"}
-
-`));
+        });
+        send("ping", { type: "ping" });
+        pingInterval = setInterval(() => {
+          if (!isClosed && Date.now() - lastActivity > 1000) {
+            send("ping", { type: "ping" });
+          }
+        }, 1000);
         try {
           while (true) {
             const { done, value } = await reader.read();
             if (done)
               break;
+            lastActivity = Date.now();
             buffer += decoder.decode(value, { stream: true });
             const lines = buffer.split(`
 `);
@@ -57241,86 +57284,99 @@ data: {"type":"ping"}
                 }
                 if (event.type === "response.output_text.delta") {
                   if (!hasTextContent) {
-                    const blockStart = {
+                    send("content_block_start", {
                       type: "content_block_start",
                       index: blockIndex,
                       content_block: { type: "text", text: "" }
-                    };
-                    controller.enqueue(encoder.encode(`event: content_block_start
-data: ${JSON.stringify(blockStart)}
-
-`));
+                    });
                     hasTextContent = true;
                   }
-                  const delta = {
+                  send("content_block_delta", {
                     type: "content_block_delta",
                     index: blockIndex,
                     delta: { type: "text_delta", text: event.delta || "" }
-                  };
-                  controller.enqueue(encoder.encode(`event: content_block_delta
-data: ${JSON.stringify(delta)}
-
-`));
+                  });
                 } else if (event.type === "response.output_item.added") {
+                  if (getLogLevel() === "debug" && event.item?.type) {
+                    log(`[OpenAIHandler] Output item added: type=${event.item.type}, id=${event.item.id || event.item.call_id || "unknown"}`);
+                  }
                   if (event.item?.type === "function_call") {
-                    const callId = event.item.call_id || event.item.id;
+                    const itemId = event.item.id;
+                    const openaiCallId = event.item.call_id || itemId;
+                    const callId = openaiCallId.startsWith("toolu_") ? openaiCallId : `toolu_${openaiCallId.replace(/^fc_/, "")}`;
+                    const fnName = event.item.name || "";
                     const fnIndex = blockIndex + functionCalls.size + (hasTextContent ? 1 : 0);
-                    functionCalls.set(callId, {
-                      name: event.item.name || "",
+                    log(`[OpenAIHandler] Function call: itemId=${itemId}, openaiCallId=${openaiCallId}, claudeId=${callId}, name=${fnName}, index=${fnIndex}`);
+                    const fnCallData = {
+                      name: fnName,
                       arguments: "",
-                      index: fnIndex
-                    });
+                      index: fnIndex,
+                      claudeId: callId
+                    };
+                    functionCalls.set(openaiCallId, fnCallData);
+                    if (itemId && itemId !== openaiCallId) {
+                      functionCalls.set(itemId, fnCallData);
+                    }
                     if (hasTextContent && !hasToolUse) {
-                      const blockStop = { type: "content_block_stop", index: blockIndex };
-                      controller.enqueue(encoder.encode(`event: content_block_stop
-data: ${JSON.stringify(blockStop)}
-
-`));
+                      send("content_block_stop", { type: "content_block_stop", index: blockIndex });
                       blockIndex++;
                     }
-                    const toolStart = {
+                    send("content_block_start", {
                       type: "content_block_start",
                       index: fnIndex,
                       content_block: {
                         type: "tool_use",
                         id: callId,
-                        name: event.item.name || "",
+                        name: fnName,
                         input: {}
                       }
-                    };
-                    controller.enqueue(encoder.encode(`event: content_block_start
-data: ${JSON.stringify(toolStart)}
-
-`));
+                    });
                     hasToolUse = true;
+                  } else if (event.item?.type === "reasoning") {
+                    log(`[OpenAIHandler] Reasoning block started`);
                   }
+                } else if (event.type === "response.reasoning_summary_text.delta") {
+                  if (!hasTextContent) {
+                    send("content_block_start", {
+                      type: "content_block_start",
+                      index: blockIndex,
+                      content_block: { type: "text", text: "" }
+                    });
+                    hasTextContent = true;
+                  }
+                  send("content_block_delta", {
+                    type: "content_block_delta",
+                    index: blockIndex,
+                    delta: { type: "text_delta", text: event.delta || "" }
+                  });
                 } else if (event.type === "response.function_call_arguments.delta") {
                   const callId = event.call_id || event.item_id;
+                  if (getLogLevel() === "debug" && !functionCalls.has(callId)) {
+                    log(`[OpenAIHandler] Argument delta lookup failed: callId=${callId}, stored keys=[${Array.from(functionCalls.keys()).join(", ")}]`);
+                  }
                   const fnCall = functionCalls.get(callId);
                   if (fnCall) {
                     fnCall.arguments += event.delta || "";
-                    const delta = {
+                    send("content_block_delta", {
                       type: "content_block_delta",
                       index: fnCall.index,
                       delta: { type: "input_json_delta", partial_json: event.delta || "" }
-                    };
-                    controller.enqueue(encoder.encode(`event: content_block_delta
-data: ${JSON.stringify(delta)}
-
-`));
+                    });
                   }
                 } else if (event.type === "response.output_item.done") {
                   if (event.item?.type === "function_call") {
                     const callId = event.item.call_id || event.item.id;
-                    const fnCall = functionCalls.get(callId);
+                    const fnCall = functionCalls.get(callId) || functionCalls.get(event.item.id);
                     if (fnCall) {
-                      const blockStop = { type: "content_block_stop", index: fnCall.index };
-                      controller.enqueue(encoder.encode(`event: content_block_stop
-data: ${JSON.stringify(blockStop)}
-
-`));
+                      send("content_block_stop", { type: "content_block_stop", index: fnCall.index });
                     }
                   }
+                } else if (event.type === "response.incomplete") {
+                  log(`[OpenAIHandler] Response incomplete: ${event.reason || "unknown reason"}`);
+                  if (event.response?.usage) {
+                    inputTokens = event.response.usage.input_tokens || inputTokens;
+                    outputTokens = event.response.usage.output_tokens || outputTokens;
+                  }
                 } else if (event.type === "response.completed" || event.type === "response.done") {
                   if (event.response?.usage) {
                     inputTokens = event.response.usage.input_tokens || 0;
@@ -57337,31 +57393,29 @@ data: ${JSON.stringify(blockStop)}
               }
             }
           }
-          if (hasTextContent && !hasToolUse) {
-            const blockStop = { type: "content_block_stop", index: blockIndex };
-            controller.enqueue(encoder.encode(`event: content_block_stop
-data: ${JSON.stringify(blockStop)}
-
-`));
+          if (pingInterval) {
+            clearInterval(pingInterval);
+            pingInterval = null;
+          }
+          if (hasTextContent) {
+            send("content_block_stop", { type: "content_block_stop", index: blockIndex });
           }
           const stopReason = hasToolUse ? "tool_use" : "end_turn";
-          const messageDelta = {
+          send("message_delta", {
             type: "message_delta",
             delta: { stop_reason: stopReason, stop_sequence: null },
             usage: { input_tokens: inputTokens, output_tokens: outputTokens }
-          };
-          controller.enqueue(encoder.encode(`event: message_delta
-data: ${JSON.stringify(messageDelta)}
-
-`));
-          const messageStop = { type: "message_stop" };
-          controller.enqueue(encoder.encode(`event: message_stop
-data: ${JSON.stringify(messageStop)}
-
-`));
+          });
+          send("message_stop", { type: "message_stop" });
+          isClosed = true;
           this.updateTokenTracking(inputTokens, outputTokens);
           controller.close();
         } catch (error46) {
+          if (pingInterval) {
+            clearInterval(pingInterval);
+            pingInterval = null;
+          }
+          isClosed = true;
           log(`[OpenAIHandler] Responses streaming error: ${error46}`);
           controller.error(error46);
         }
@@ -58207,7 +58261,7 @@ function createTempSettingsFile(modelDisplay, port) {
     const DIM2 = "\\033[2m";
     const RESET2 = "\\033[0m";
     const BOLD2 = "\\033[1m";
-    statusCommand = `JSON=$(cat) && DIR=$(basename "$(pwd)") && [ \${#DIR} -gt 15 ] && DIR="\${DIR:0:12}..." || true && CTX=100 && COST="0" && if [ -f "${tokenFilePath}" ]; then TOKENS=$(cat "${tokenFilePath}" 2>/dev/null) && REAL_CTX=$(echo "$TOKENS" | grep -o '"context_left_percent":[0-9]*' | grep -o '[0-9]*') && if [ ! -z "$REAL_CTX" ]; then CTX="$REAL_CTX"; fi; fi && COST=$(echo "$JSON" | grep -o '"total_cost_usd":[0-9.]*' | cut -d: -f2) && [ -z "$COST" ] && COST="0" || true && if [ "$CLAUDISH_IS_LOCAL" = "true" ]; then COST_DISPLAY="LOCAL"; else COST_DISPLAY=$(printf "\\$%.3f" "$COST"); fi && printf "${CYAN2}${BOLD2}%s${RESET2} ${DIM2}•${RESET2} ${YELLOW2}%s${RESET2} ${DIM2}•${RESET2} ${GREEN2}%s${RESET2} ${DIM2}•${RESET2} ${MAGENTA}%s%%${RESET2}\\n" "$DIR" "$CLAUDISH_ACTIVE_MODEL_NAME" "$COST_DISPLAY" "$CTX"`;
+    statusCommand = `JSON=$(cat) && DIR=$(basename "$(pwd)") && [ \${#DIR} -gt 15 ] && DIR="\${DIR:0:12}..." || true && CTX=100 && COST="0" && if [ -f "${tokenFilePath}" ]; then TOKENS=$(cat "${tokenFilePath}" 2>/dev/null) && REAL_CTX=$(echo "$TOKENS" | grep -o '"context_left_percent":[0-9]*' | grep -o '[0-9]*') && if [ ! -z "$REAL_CTX" ]; then CTX="$REAL_CTX"; fi && REAL_COST=$(echo "$TOKENS" | grep -o '"total_cost":[0-9.]*' | cut -d: -f2) && if [ ! -z "$REAL_COST" ]; then COST="$REAL_COST"; fi; fi && if [ "$CLAUDISH_IS_LOCAL" = "true" ]; then COST_DISPLAY="LOCAL"; else COST_DISPLAY=$(printf "\\$%.3f" "$COST"); fi && printf "${CYAN2}${BOLD2}%s${RESET2} ${DIM2}•${RESET2} ${YELLOW2}%s${RESET2} ${DIM2}•${RESET2} ${GREEN2}%s${RESET2} ${DIM2}•${RESET2} ${MAGENTA}%s%%${RESET2}\\n" "$DIR" "$CLAUDISH_ACTIVE_MODEL_NAME" "$COST_DISPLAY" "$CTX"`;
   }
   const settings = {
     statusLine: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "3.3.10",
+  "version": "3.3.11",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",