@musistudio/claude-code-router 1.0.7 → 1.0.9

package/README.md

@@ -2,7 +2,6 @@
 
 > This is a tool for routing Claude Code requests to different models, and you can customize any request.
 
-
 ![](screenshoots/claude-code.png)
 
 ## Usage
@@ -25,8 +24,9 @@ npm install -g @musistudio/claude-code-router
 ccr code
 ```
 
-4. Configure routing[optional]    
-Set up your `~/.claude-code-router/config.json` file like this:
+4. Configure routing[optional]  
+   Set up your `~/.claude-code-router/config.json` file like this:
+
 ```json
 {
   "OPENAI_API_KEY": "sk-xxx",
@@ -64,33 +64,135 @@ Set up your `~/.claude-code-router/config.json` file like this:
   }
 }
 ```
-- `background`    
-This model will be used to handle some background tasks([background-token-usage](https://docs.anthropic.com/en/docs/claude-code/costs#background-token-usage)). Based on my tests, it doesn’t require high intelligence. I’m using the qwen-coder-2.5:7b model running locally on my MacBook Pro M1 (32GB) via Ollama.
-If your computer can’t run Ollama, you can also use some free models, such as qwen-coder-2.5:3b.
-
-
-- `think`    
-This model will be used when enabling Claude Code to perform reasoning. However, reasoning budget control has not yet been implemented (since the DeepSeek-R1 model does not support it), so there is currently no difference between using UltraThink and Think modes.
-It is worth noting that Plan Mode also use this model to achieve better planning results.    
-Note: The reasoning process via the official DeepSeek API may be very slow, so you may need to wait for an extended period of time.
 
+- `background`  
+  This model will be used to handle some background tasks([background-token-usage](https://docs.anthropic.com/en/docs/claude-code/costs#background-token-usage)). Based on my tests, it doesn’t require high intelligence. I’m using the qwen-coder-2.5:7b model running locally on my MacBook Pro M1 (32GB) via Ollama.
+  If your computer can’t run Ollama, you can also use some free models, such as qwen-coder-2.5:3b.
 
-- `longContext`   
-This model will be used when the context length exceeds 32K (this value may be modified in the future). You can route the request to a model that performs well with long contexts (I’ve chosen google/gemini-2.5-pro-preview). This scenario has not been thoroughly tested yet, so if you encounter any issues, please submit an issue.
+- `think`  
+  This model will be used when enabling Claude Code to perform reasoning. However, reasoning budget control has not yet been implemented (since the DeepSeek-R1 model does not support it), so there is currently no difference between using UltraThink and Think modes.
+  It is worth noting that Plan Mode also use this model to achieve better planning results.  
+  Note: The reasoning process via the official DeepSeek API may be very slow, so you may need to wait for an extended period of time.
 
+- `longContext`  
+  This model will be used when the context length exceeds 32K (this value may be modified in the future). You can route the request to a model that performs well with long contexts (I’ve chosen google/gemini-2.5-pro-preview). This scenario has not been thoroughly tested yet, so if you encounter any issues, please submit an issue.
 
-- model command   
-You can also switch models within Claude Code by using the `/model` command. The format is: `provider,model`, like this:     
-`/model openrouter,anthropic/claude-3.5-sonnet`    
-This will use the anthropic/claude-3.5-sonnet model provided by OpenRouter to handle all subsequent tasks.
+- model command  
+  You can also switch models within Claude Code by using the `/model` command. The format is: `provider,model`, like this:  
+  `/model openrouter,anthropic/claude-3.5-sonnet`  
+  This will use the anthropic/claude-3.5-sonnet model provided by OpenRouter to handle all subsequent tasks.
 
 ## Features
-- [x] Plugins
+
 - [x] Support change models
-- [ ] Support scheduled tasks
+- [x] Github Actions
+- [ ] More robust plugin support
+- [ ] More detailed logs
+
+## Plugins
+You can modify or enhance Claude Code’s functionality by installing plugins. The mechanism works by using middleware to modify request parameters — this allows you to rewrite prompts or add/remove tools.
+
+To use a plugin, place it in the ~/.claude-code-router/plugins/ directory and specify the plugin name in config.js using the `usePlugins` option.like this
+```json
+// ~/.claud-code-router/config.json
+{
+  ...,
+  "usePlugins": ["notebook-tools-filter", "toolcall-improvement"]
+}
+```
+
+Currently, the following plugins are available:
+
+
+- **notebook-tools-filter**    
+This plugin filters out tool calls related to Jupyter notebooks (.ipynb files). You can use it if your work does not involve Jupyter.
+
+
+- **toolcall-improvement**    
+If your LLM doesn’t handle tool usage well (for example, always returning code as plain text instead of modifying files — such as with deepseek-v3), you can use this plugin.    
+This plugin simply adds the following system prompt. If you have a better prompt, you can modify it.
+```markdown
+## **Important Instruction:**  
+You must use tools as frequently and accurately as possible to help the user solve their problem.  
+Prioritize tool usage whenever it can enhance accuracy, efficiency, or the quality of the response.
+```
+
+
+## Github Actions
+You just need to install `Claude Code Actions` in your repository according to the [official documentation](https://docs.anthropic.com/en/docs/claude-code/github-actions). For `ANTHROPIC_API_KEY`, you can use any string. Then, modify your `.github/workflows/claude.yaml` file to include claude-code-router, like this:
+```yaml
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+      
+      - name: Prepare Environment
+        run: |
+          curl -fsSL https://bun.sh/install | bash
+          mkdir -p $HOME/.claude-code-router
+          cat << 'EOF' > $HOME/.claude-code-router/config.json
+          {
+            "log": true,
+            "OPENAI_API_KEY": "${{ secrets.OPENAI_API_KEY }}",
+            "OPENAI_BASE_URL": "https://api.deepseek.com",
+            "OPENAI_MODEL": "deepseek-chat"
+          }
+          EOF
+        shell: bash
+        
+      - name: Start Claude Code Router
+        run: |
+          nohup ~/.bun/bin/bunx @musistudio/claude-code-router@1.0.8 start &
+        shell: bash
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@beta
+        env:
+          ANTHROPIC_BASE_URL: http://localhost:3456
+        with:
+          anthropic_api_key: "test"
+```
+You can modify the contents of `$HOME/.claude-code-router/config.json` as needed.
+GitHub Actions support allows you to trigger Claude Code at specific times, which opens up some interesting possibilities.
+
+For example, between 00:30 and 08:30 Beijing Time, using the official DeepSeek API:
+
+- The cost of the `deepseek-v3` model is only 50% of the normal time.
+
+- The `deepseek-r1` model is just 25% of the normal time.
+
+So maybe in the future, I’ll describe detailed tasks for Claude Code ahead of time and let it run during these discounted hours to reduce costs?
 
 
 ## Some tips:
+
 Now you can use deepseek-v3 models directly without using any plugins.
 
 If you’re using the DeepSeek API provided by the official website, you might encounter an “exceeding context” error after several rounds of conversation (since the official API only supports a 64K context window). In this case, you’ll need to discard the previous context and start fresh. Alternatively, you can use ByteDance’s DeepSeek API, which offers a 128K context window and supports KV cache.
@@ -102,8 +204,23 @@ Note: claude code consumes a huge amount of tokens, but thanks to DeepSeek’s l
 Some interesting points: Based on my testing, including a lot of context information can help narrow the performance gap between these LLM models. For instance, when I used Claude-4 in VSCode Copilot to handle a Flutter issue, it messed up the files in three rounds of conversation, and I had to roll everything back. However, when I used claude code with DeepSeek, after three or four rounds of conversation, I finally managed to complete my task—and the cost was less than 1 RMB!
 
 ## Some articles:
-1. [Project Motivation and Principles](blog/en/project-motivation-and-how-it-works.md)  ([中文版看这里](blog/zh/项目初衷及原理.md))
+
+1. [Project Motivation and Principles](blog/en/project-motivation-and-how-it-works.md) ([中文版看这里](blog/zh/项目初衷及原理.md))
 
 ## Buy me a coffee
-If you find this project helpful, you can choose to sponsor the author with a cup of coffee.
-[Buy me a coffee](http://paypal.me/musistudio1999)
+
+If you find this project helpful, you can choose to sponsor the author with a cup of coffee. Please provide your GitHub information so I can add you to the sponsor list below.  
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/F1F31GN2GM)
+
+| ![alipay](/blog/images/alipay.jpg) | ![wechat](/blog/images/wechat.jpg) |
+|----------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------|
+
+## Sponsors
+
+Thanks to the following sponsors:
+
+@Simon Leischnig (If you see this, feel free to contact me and I can update it with your GitHub information)    
+[@duanshuaimin](https://github.com/duanshuaimin)     
+[@vrgitadmin](https://github.com/vrgitadmin)     
+@*o(看到后可通过主页邮箱联系我修改github用户名)

package/dist/cli.js

@@ -37041,28 +37041,36 @@ async function streamOpenAIResponse(res, completion, model, body) {
   };
   const messageId = "msg_" + Date.now();
   if (!body.stream) {
-    res.json({
-      id: messageId,
-      type: "message",
-      role: "assistant",
-      // @ts-ignore
-      content: completion.choices[0].message.content || completion.choices[0].message.tool_calls?.map((item) => {
+    let content = [];
+    if (completion.choices[0].message.content) {
+      content = [{ text: completion.choices[0].message.content, type: "text" }];
+    } else if (completion.choices[0].message.tool_calls) {
+      content = completion.choices[0].message.tool_calls.map((item) => {
         return {
           type: "tool_use",
           id: item.id,
           name: item.function?.name,
           input: item.function?.arguments ? JSON.parse(item.function.arguments) : {}
         };
-      }) || "",
+      });
+    }
+    const result = {
+      id: messageId,
+      type: "message",
+      role: "assistant",
+      // @ts-ignore
+      content,
       stop_reason: completion.choices[0].finish_reason === "tool_calls" ? "tool_use" : "end_turn",
-      stop_sequence: null,
-      usage: {
-        input_tokens: 100,
-        output_tokens: 50
-      }
-    });
-    res.end();
-    return;
+      stop_sequence: null
+    };
+    try {
+      res.json(result);
+      res.end();
+      return;
+    } catch (error) {
+      log("Error sending response:", error);
+      res.status(500).send("Internal Server Error");
+    }
   }
   let contentBlockIndex = 0;
   let currentContentBlocks = [];
@@ -37086,76 +37094,100 @@ data: ${JSON.stringify(messageStart)}
   let isToolUse = false;
   let toolUseJson = "";
   let hasStartedTextBlock = false;
+  let currentToolCallId = null;
+  let toolCallJsonMap = /* @__PURE__ */ new Map();
   try {
     for await (const chunk of completion) {
       log("Processing chunk:", chunk);
       const delta = chunk.choices[0].delta;
       if (delta.tool_calls && delta.tool_calls.length > 0) {
-        const toolCall = delta.tool_calls[0];
-        if (!isToolUse) {
-          isToolUse = true;
-          const toolBlock = {
-            type: "tool_use",
-            id: `toolu_${Date.now()}`,
-            name: toolCall.function?.name,
-            input: {}
-          };
-          const toolBlockStart = {
-            type: "content_block_start",
-            index: contentBlockIndex,
-            content_block: toolBlock
-          };
-          currentContentBlocks.push(toolBlock);
-          write(
-            `event: content_block_start
+        for (const toolCall of delta.tool_calls) {
+          const toolCallId = toolCall.id;
+          if (toolCallId && toolCallId !== currentToolCallId) {
+            if (isToolUse && currentToolCallId) {
+              const contentBlockStop = {
+                type: "content_block_stop",
+                index: contentBlockIndex
+              };
+              write(
+                `event: content_block_stop
 data: ${JSON.stringify(
-              toolBlockStart
-            )}
+                  contentBlockStop
+                )}
 
 `
-          );
-          toolUseJson = "";
-        }
-        if (toolCall.function?.arguments) {
-          const jsonDelta = {
-            type: "content_block_delta",
-            index: contentBlockIndex,
-            delta: {
-              type: "input_json_delta",
-              partial_json: toolCall.function?.arguments
+              );
             }
-          };
-          toolUseJson += toolCall.function.arguments;
-          try {
-            const parsedJson = JSON.parse(toolUseJson);
-            currentContentBlocks[contentBlockIndex].input = parsedJson;
-          } catch (e2) {
-            log(e2);
+            isToolUse = true;
+            currentToolCallId = toolCallId;
+            contentBlockIndex++;
+            toolCallJsonMap.set(toolCallId, "");
+            const toolBlock = {
+              type: "tool_use",
+              id: toolCallId,
+              name: toolCall.function?.name,
+              input: {}
+            };
+            const toolBlockStart = {
+              type: "content_block_start",
+              index: contentBlockIndex,
+              content_block: toolBlock
+            };
+            currentContentBlocks.push(toolBlock);
+            write(
+              `event: content_block_start
+data: ${JSON.stringify(
+                toolBlockStart
+              )}
+
+`
+            );
           }
-          write(
-            `event: content_block_delta
+          if (toolCall.function?.arguments && currentToolCallId) {
+            const jsonDelta = {
+              type: "content_block_delta",
+              index: contentBlockIndex,
+              delta: {
+                type: "input_json_delta",
+                partial_json: toolCall.function.arguments
+              }
+            };
+            const currentJson = toolCallJsonMap.get(currentToolCallId) || "";
+            toolCallJsonMap.set(currentToolCallId, currentJson + toolCall.function.arguments);
+            toolUseJson = toolCallJsonMap.get(currentToolCallId) || "";
+            try {
+              const parsedJson = JSON.parse(toolUseJson);
+              currentContentBlocks[contentBlockIndex].input = parsedJson;
+            } catch (e2) {
+              log("JSON parsing error (continuing to accumulate):", e2);
+            }
+            write(
+              `event: content_block_delta
 data: ${JSON.stringify(jsonDelta)}
 
 `
-          );
+            );
+          }
         }
       } else if (delta.content) {
         if (isToolUse) {
           log("Tool call ended here:", delta);
-          const contentBlockStop2 = {
+          const contentBlockStop = {
             type: "content_block_stop",
             index: contentBlockIndex
           };
           write(
             `event: content_block_stop
 data: ${JSON.stringify(
-              contentBlockStop2
+              contentBlockStop
             )}
 
 `
           );
           contentBlockIndex++;
           isToolUse = false;
+          currentToolCallId = null;
+          toolUseJson = "";
         }
         if (!delta.content) continue;
         if (!hasStartedTextBlock) {
@@ -37240,16 +37272,18 @@ data: ${JSON.stringify(contentDelta)}
 `
     );
   }
-  const contentBlockStop = {
-    type: "content_block_stop",
-    index: contentBlockIndex
-  };
-  write(
-    `event: content_block_stop
+  if (isToolUse || hasStartedTextBlock) {
+    const contentBlockStop = {
+      type: "content_block_stop",
+      index: contentBlockIndex
+    };
+    write(
+      `event: content_block_stop
 data: ${JSON.stringify(contentBlockStop)}
 
 `
-  );
+    );
+  }
   const messageDelta = {
     type: "message_delta",
     delta: {
@@ -37469,6 +37503,13 @@ var rewriteBody = async (req, res, next) => {
 var import_tiktoken = __toESM(require_tiktoken());
 var enc = (0, import_tiktoken.get_encoding)("cl100k_base");
 var getUseModel = (req, tokenCount) => {
+  const [provider, model] = req.body.model.split(",");
+  if (provider && model) {
+    return {
+      provider,
+      model
+    };
+  }
   if (tokenCount > 1e3 * 32) {
     log("Using long context model due to token count:", tokenCount);
     const [provider2, model2] = req.config.Router.longContext.split(",");
@@ -37493,13 +37534,6 @@ var getUseModel = (req, tokenCount) => {
       model: model2
     };
   }
-  const [provider, model] = req.body.model.split(",");
-  if (provider && model) {
-    return {
-      provider,
-      model
-    };
-  }
   return {
     provider: "default",
     model: req.config.OPENAI_MODEL
@@ -37522,7 +37556,9 @@ var router = async (req, res, next) => {
                 JSON.stringify(contentPart.input)
               ).length;
             } else if (contentPart.type === "tool_result") {
-              tokenCount += enc.encode(contentPart.content || "").length;
+              tokenCount += enc.encode(
+                typeof contentPart.content === "string" ? contentPart.content : JSON.stringify(contentPart.content)
+              ).length;
             }
           });
         }
@@ -39108,7 +39144,6 @@ async function run(options = {}) {
   const servicePort = process.env.SERVICE_PORT ? parseInt(process.env.SERVICE_PORT) : port;
   const server = await createServer(servicePort);
   server.useMiddleware((req, res, next) => {
-    console.log("Middleware triggered for request:", req.body.model);
     req.config = config;
     next();
   });
@@ -39129,7 +39164,7 @@ async function run(options = {}) {
       const completion = await provider.chat.completions.create(req.body);
       await streamOpenAIResponse(res, completion, req.body.model, req.body);
     } catch (e2) {
-      console.error("Error in OpenAI API call:", e2);
+      log("Error in OpenAI API call:", e2);
     }
   });
   server.start();
@@ -39224,7 +39259,7 @@ async function executeCodeCommand(args = []) {
 }
 
 // package.json
-var version = "1.0.6";
+var version = "1.0.9";
 
 // src/cli.ts
 var import_child_process2 = require("child_process");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@musistudio/claude-code-router",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Use Claude Code without an Anthropics account and route it to another LLM provider",
   "bin": {
     "ccr": "./dist/cli.js"

package/plugins/notebook-tools-filter.js

@@ -0,0 +1,7 @@
+module.exports = async function handle(req, res) {
+  if (req?.body?.tools?.length) {
+    req.body.tools = req.body.tools.filter(
+      (tool) => !["NotebookRead", "NotebookEdit", "mcp__ide__executeCode"].includes(tool.name)
+    );
+  }
+};

package/plugins/toolcall-improvement.js

@@ -0,0 +1,8 @@
+module.exports = async function handle(req, res) {
+  if (req?.body?.tools?.length) {
+    req.body.system.push({
+        type: "text",
+        text: `## **Important Instruction:**  \nYou must use tools as frequently and accurately as possible to help the user solve their problem.\nPrioritize tool usage whenever it can enhance accuracy, efficiency, or the quality of the response.`
+    })
+  }
+};