GitHub - jhangyu/claude-code-router: Use Claude Code as the foundation for coding infrastructure, allowing you to decide how to interact with the model while enjoying updates from Anthropic.

Progressive Disclosure of Agent Tools from the Perspective of CLI Tool Style

A powerful tool to route Claude Code requests to different models and customize any request.

✨ Features

Model Routing: Route requests to different models based on scenario — default, background tasks, reasoning/thinking, long context, web search, and image tasks.
Agent Role Routing: Automatically detect agent roles (architect, planner, explorer, debugger, reviewer, implementer, tester) from system prompts and route each to a dedicated model.
Custom Router: Advanced routing with highest-priority explicit provider,model selection. Implement custom routing logic via a JavaScript module, with ordered priority: explicit model override, long context, subagent tags, background, agent role detection, web search, and thinking.
Subagent Model Tags: Specify models for subagent tasks using <CCR-SUBAGENT-MODEL>provider,model</CCR-SUBAGENT-MODEL> tags at the beginning of subagent prompts.
Multi-Provider Support: Supports various model providers like OpenRouter, DeepSeek, Ollama, Gemini, Volcengine, ModelScope, DashScope, and any OpenAI-compatible API.
Request/Response Transformation: Modular transformer pipeline to adapt requests and responses for different provider APIs. Transformers can be applied globally, per-model, or with custom options.
Prompt Cache Control Forwarding: Forward prompt cache control (cache_control) to upstream LLM providers that support it, reducing latency and cost for repeated prompts.
GLM 5.2 Reasoning Support: Built-in reasoning/thinking transformer for GLM 5.2 models, with interleaved thinking support.
Preset Management: Export, import, share, and reuse configurations via the preset system (ccr preset). Sensitive data is automatically sanitized on export.
Dynamic Model Switching: Switch models on-the-fly within Claude Code using the /model command, or manage models interactively via ccr model.
Plugin System: Extend functionality with custom transformers and plugins (e.g., token-speed monitoring, status line).
Agent SDK Integration: Use the ccr activate command to set environment variables for direct claude command usage and Agent SDK applications.
x-api-key Auth Passthrough: Support for providers that authenticate via x-api-key header passthrough (e.g., OpenCode Zen, local providers).
CI/CD Integration: Compatible with GitHub Actions, Docker, and other non-interactive environments via NON_INTERACTIVE_MODE.

🚀 Getting Started

1. Installation

First, ensure you have Claude Code installed:

npm install -g @anthropic-ai/claude-code

Then, install Claude Code Router:

npm install -g @jhangyu/claude-code-router

2. Configuration

Create and configure your ~/.claude-code-router/config.json file. For more details, you can refer to config.example.json.

The config.json file has several key sections:

PROXY_URL (optional): You can set a proxy for API requests, for example: "PROXY_URL": "http://127.0.0.1:7890".
LOG (optional): You can enable logging by setting it to true. When set to false, no log files will be created. Default is true.
LOG_LEVEL (optional): Set the logging level. Available options are: "fatal", "error", "warn", "info", "debug", "trace". Default is "debug".
Logging Systems: The Claude Code Router uses two separate logging systems:
- Server-level logs: HTTP requests, API calls, and server events are logged using pino in the ~/.claude-code-router/logs/ directory with filenames like ccr-*.log
- Application-level logs: Routing decisions and business logic events are logged in ~/.claude-code-router/claude-code-router.log
APIKEY (optional): You can set a secret key to authenticate requests. When set, clients must provide this key in the Authorization header (e.g., Bearer your-secret-key) or the x-api-key header. Example: "APIKEY": "your-secret-key".
HOST (optional): You can set the host address for the server. If APIKEY is not set, the host will be forced to 127.0.0.1 for security reasons to prevent unauthorized access. Example: "HOST": "0.0.0.0".
NON_INTERACTIVE_MODE (optional): When set to true, enables compatibility with non-interactive environments like GitHub Actions, Docker containers, or other CI/CD systems. This sets appropriate environment variables (CI=true, FORCE_COLOR=0, etc.) and configures stdin handling to prevent the process from hanging in automated environments. Example: "NON_INTERACTIVE_MODE": true.
Providers: Used to configure different model providers.
Router: Used to set up routing rules. default specifies the default model, which will be used for all requests if no other route is configured.
API_TIMEOUT_MS: Specifies the timeout for API calls in milliseconds.

Environment Variable Interpolation

Claude Code Router supports environment variable interpolation for secure API key management. You can reference environment variables in your config.json using either $VAR_NAME or ${VAR_NAME} syntax:

{
  "OPENAI_API_KEY": "$OPENAI_API_KEY",
  "GEMINI_API_KEY": "${GEMINI_API_KEY}",
  "Providers": [
    {
      "name": "openai",
      "api_base_url": "https://api.openai.com/v1/chat/completions",
      "api_key": "$OPENAI_API_KEY",
      "models": ["gpt-5", "gpt-5-mini"]
    }
  ]
}

This allows you to keep sensitive API keys in environment variables instead of hardcoding them in configuration files. The interpolation works recursively through nested objects and arrays.

Here is a comprehensive example:

{
  "APIKEY": "your-secret-key",
  "PROXY_URL": "http://127.0.0.1:7890",
  "LOG": true,
  "API_TIMEOUT_MS": 600000,
  "NON_INTERACTIVE_MODE": false,
  "Providers": [
    {
      "name": "openrouter",
      "api_base_url": "https://openrouter.ai/api/v1/chat/completions",
      "api_key": "sk-xxx",
      "models": [
        "google/gemini-2.5-pro-preview",
        "anthropic/claude-sonnet-4",
        "anthropic/claude-3.5-sonnet",
        "anthropic/claude-3.7-sonnet:thinking"
      ],
      "transformer": {
        "use": ["openrouter"]
      }
    },
    {
      "name": "deepseek",
      "api_base_url": "https://api.deepseek.com/chat/completions",
      "api_key": "sk-xxx",
      "models": ["deepseek-chat", "deepseek-reasoner"],
      "transformer": {
        "use": ["deepseek"],
        "deepseek-chat": {
          "use": ["tooluse"]
        }
      }
    },
    {
      "name": "ollama",
      "api_base_url": "http://localhost:11434/v1/chat/completions",
      "api_key": "ollama",
      "models": ["qwen2.5-coder:latest"]
    },
    {
      "name": "gemini",
      "api_base_url": "https://generativelanguage.googleapis.com/v1beta/models/",
      "api_key": "sk-xxx",
      "models": ["gemini-2.5-flash", "gemini-2.5-pro"],
      "transformer": {
        "use": ["gemini"]
      }
    },
    {
      "name": "volcengine",
      "api_base_url": "https://ark.cn-beijing.volces.com/api/v3/chat/completions",
      "api_key": "sk-xxx",
      "models": ["deepseek-v3-250324", "deepseek-r1-250528"],
      "transformer": {
        "use": ["deepseek"]
      }
    },
    {
      "name": "modelscope",
      "api_base_url": "https://api-inference.modelscope.cn/v1/chat/completions",
      "api_key": "",
      "models": ["Qwen/Qwen3-Coder-480B-A35B-Instruct", "Qwen/Qwen3-235B-A22B-Thinking-2507"],
      "transformer": {
        "use": [
          [
            "maxtoken",
            {
              "max_tokens": 65536
            }
          ],
          "enhancetool"
        ],
        "Qwen/Qwen3-235B-A22B-Thinking-2507": {
          "use": ["reasoning"]
        }
      }
    },
    {
      "name": "dashscope",
      "api_base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
      "api_key": "",
      "models": ["qwen3-coder-plus"],
      "transformer": {
        "use": [
          [
            "maxtoken",
            {
              "max_tokens": 65536
            }
          ],
          "enhancetool"
        ]
      }
    },
    {
      "name": "aihubmix",
      "api_base_url": "https://aihubmix.com/v1/chat/completions",
      "api_key": "sk-",
      "models": [
        "Z/glm-4.5",
        "claude-opus-4-20250514",
        "gemini-2.5-pro"
      ]
    }
  ],
  "Router": {
    "default": "deepseek,deepseek-chat",
    "background": "ollama,qwen2.5-coder:latest",
    "think": "deepseek,deepseek-reasoner",
    "longContext": "openrouter,google/gemini-2.5-pro-preview",
    "longContextThreshold": 60000,
    "webSearch": "gemini,gemini-2.5-flash"
  }
}

3. Running Claude Code with the Router

Start Claude Code using the router:

ccr code

Note: After modifying the configuration file, you need to restart the service for the changes to take effect:
ccr restart

4. UI Mode

For a more intuitive experience, you can use the UI mode to manage your configuration:

ccr ui

This will open a web-based interface where you can easily view and edit your config.json file.

5. CLI Model Management

For users who prefer terminal-based workflows, you can use the interactive CLI model selector:

ccr model

This command provides an interactive interface to:

View current configuration:
See all configured models (default, background, think, longContext, webSearch, image)
Switch models: Quickly change which model is used for each router type
Add new models: Add models to existing providers
Create new providers: Set up complete provider configurations including:
- Provider name and API endpoint
- API key
- Available models
- Transformer configuration with support for:
  - Multiple transformers (openrouter, deepseek, gemini, etc.)
  - Transformer options (e.g., maxtoken with custom limits)
  - Provider-specific routing (e.g., OpenRouter provider preferences)

The CLI tool validates all inputs and provides helpful prompts to guide you through the configuration process, making it easy to manage complex setups without editing JSON files manually.

6. Presets Management

Presets allow you to save, share, and reuse configurations easily. You can export your current configuration as a preset and install presets from files or URLs.

# Export current configuration as a preset
ccr preset export my-preset

# Export with metadata
ccr preset export my-preset --description "My OpenAI config" --author "Your Name" --tags "openai,production"

# Install a preset from local directory
ccr preset install /path/to/preset

# List all installed presets
ccr preset list

# Show preset information
ccr preset info my-preset

# Delete a preset
ccr preset delete my-preset

Preset Features:

Export: Save your current configuration as a preset directory (with manifest.json)
Install: Install presets from local directories
Sensitive Data Handling: API keys and other sensitive data are automatically sanitized during export (marked as {{field}} placeholders)
Dynamic Configuration: Presets can include input schemas for collecting required information during installation
Version Control: Each preset includes version metadata for tracking updates

Preset File Structure:

~/.claude-code-router/presets/
├── my-preset/
│   └── manifest.json    # Contains configuration and metadata

7. Activate Command (Environment Variables Setup)

The activate command allows you to set up environment variables globally in your shell, enabling you to use the claude command directly or integrate Claude Code Router with applications built using the Agent SDK.

To activate the environment variables, run:

eval "$(ccr activate)"

This command outputs the necessary environment variables in shell-friendly format, which are then set in your current shell session. After activation, you can:

Use claude command directly: Run claude commands without needing to use ccr code. The claude command will automatically route requests through Claude Code Router.
Integrate with Agent SDK applications: Applications built with the Anthropic Agent SDK will automatically use the configured router and models.

The activate command sets the following environment variables:

ANTHROPIC_AUTH_TOKEN: API key from your configuration
ANTHROPIC_BASE_URL: The local router endpoint (default: http://127.0.0.1:3456)
NO_PROXY: Set to 127.0.0.1 to prevent proxy interference
DISABLE_TELEMETRY: Disables telemetry
DISABLE_COST_WARNINGS: Disables cost warnings
API_TIMEOUT_MS: API timeout from your configuration

Note: Make sure the Claude Code Router service is running (ccr start) before using the activated environment variables. The environment variables are only valid for the current shell session. To make them persistent, you can add eval "$(ccr activate)" to your shell configuration file (e.g., ~/.zshrc or ~/.bashrc).

Providers

The Providers array is where you define the different model providers you want to use. Each provider object requires:

name: A unique name for the provider.
api_base_url: The full API endpoint for chat completions.
api_key: Your API key for the provider.
models: A list of model names available from this provider.
transformer (optional): Specifies transformers to process requests and responses.

For providers that authenticate via x-api-key header instead of Authorization: Bearer, the router supports passthrough authentication — set the api_key field and requests will be forwarded with the appropriate header.

Transformers

Transformers allow you to modify the request and response payloads to ensure compatibility with different provider APIs.

Global Transformer: Apply a transformer to all models from a provider. In this example, the openrouter transformer is applied to all models under the openrouter provider.

{
  "name": "openrouter",
  "api_base_url": "https://openrouter.ai/api/v1/chat/completions",
  "api_key": "sk-xxx",
  "models": [
    "google/gemini-2.5-pro-preview",
    "anthropic/claude-sonnet-4",
    "anthropic/claude-3.5-sonnet"
  ],
  "transformer": { "use": ["openrouter"] }
}

Model-Specific Transformer: Apply a transformer to a specific model. In this example, the deepseek transformer is applied to all models, and an additional tooluse transformer is applied only to the deepseek-chat model.

{
  "name": "deepseek",
  "api_base_url": "https://api.deepseek.com/chat/completions",
  "api_key": "sk-xxx",
  "models": ["deepseek-chat", "deepseek-reasoner"],
  "transformer": {
    "use": ["deepseek"],
    "deepseek-chat": { "use": ["tooluse"] }
  }
}

Passing Options to a Transformer: Some transformers, like maxtoken, accept options. To pass options, use a nested array where the first element is the transformer name and the second is an options object.

{
  "name": "siliconflow",
  "api_base_url": "https://api.siliconflow.cn/v1/chat/completions",
  "api_key": "sk-xxx",
  "models": ["moonshotai/Kimi-K2-Instruct"],
  "transformer": {
    "use": [
      [
        "maxtoken",
        {
          "max_tokens": 16384
        }
      ]
    ]
  }
}

Available Built-in Transformers:

Anthropic: If you use only the Anthropic transformer, it will preserve the original request and response parameters (you can use it to connect directly to an Anthropic endpoint).
deepseek: Adapts requests/responses for DeepSeek API.
gemini: Adapts requests/responses for Gemini API.

openrouter: Adapts requests/responses for OpenRouter API. It can also accept a provider routing parameter to specify which underlying providers OpenRouter should use. For more details, refer to the OpenRouter documentation. See an example below:

  "transformer": {
    "use": ["openrouter"],
    "moonshotai/kimi-k2": {
      "use": [
        [
          "openrouter",
          {
            "provider": {
              "only": ["moonshotai/fp8"]
            }
          }
        ]
      ]
    }
  }

groq: Adapts requests/responses for groq API.
maxtoken: Sets a specific max_tokens value.
tooluse: Optimizes tool usage for certain models via tool_choice.
gemini-cli (experimental): Unofficial support for Gemini via Gemini CLI gemini-cli.js.
reasoning: Used to process the reasoning_content field. Supports GLM 5.2 and other models with reasoning/thinking capabilities, including interleaved thinking.
sampling: Used to process sampling information fields such as temperature, top_p, top_k, and repetition_penalty.
enhancetool: Adds a layer of error tolerance to the tool call parameters returned by the LLM (this will cause the tool call information to no longer be streamed).
cleancache: Clears the cache_control field from requests. By default, the router forwards prompt cache control headers to upstream providers that support it. Use this transformer if you need to strip cache control instead.
vertex-gemini: Handles the Gemini API using Vertex authentication.
chutes-glm: Unofficial support for GLM 4.5 model via Chutes chutes-glm-transformer.js.
qwen-cli (experimental): Unofficial support for qwen3-coder-plus model via Qwen CLI qwen-cli.js.
rovo-cli (experimental): Unofficial support for gpt-5 via Atlassian Rovo Dev CLI rovo-cli.js.

Custom Transformers:

You can also create your own transformers and load them via the transformers field in config.json.

{
  "transformers": [
    {
      "path": "/User/xxx/.claude-code-router/plugins/gemini-cli.js",
      "options": {
        "project": "xxx"
      }
    }
  ]
}

Router

The Router object defines which model to use for different scenarios:

default: The default model for general tasks.
background: A model for background tasks. This can be a smaller, local model to save costs.
think: A model for reasoning-heavy tasks, like Plan Mode.
longContext: A model for handling long contexts (e.g., > 60K tokens).
longContextThreshold (optional): The token count threshold for triggering the long context model. Defaults to 60000 if not specified.
webSearch: Used for handling web search tasks and this requires the model itself to support the feature. If you're using openrouter, you need to add the :online suffix after the model name.
image (beta): Used for handling image-related tasks (supported by CCR's built-in agent). If the model does not support tool calling, you need to set the config.forceUseImageAgent property to true.

Agent Role Routing

In addition to the scenario-based routing above, the custom router supports routing based on agent roles detected from system prompts. When enabled via CUSTOM_ROUTER_PATH, the following role-based routes are available:

architect: For system architecture, API design, microservices patterns.
planner: For implementation planning, software design, turning vague requirements into plans.
explorer: For codebase exploration, feature discovery, and read-only code search.
debugger: For root cause investigation, error analysis, and hypothesis-driven debugging.
reviewer: For code review, security auditing, and static analysis.
implementer: For feature implementation, code building, and parallel feature work.
tester: For test automation, TDD workflows, and test suite creation.

Configure these routes in your Router alongside other scenarios:

{
  "Router": {
    "default": "openrouter,anthropic/claude-sonnet-4",
    "background": "ollama,qwen2.5-coder:latest",
    "think": "deepseek,deepseek-reasoner",
    "architect": "openrouter,anthropic/claude-opus-4-20250514",
    "planner": "openrouter,anthropic/claude-opus-4-20250514",
    "explorer": "openrouter,anthropic/claude-haiku-4-5-20251001",
    "debugger": "deepseek,deepseek-reasoner",
    "reviewer": "openrouter,anthropic/claude-sonnet-4",
    "implementer": "deepseek,deepseek-chat",
    "tester": "openrouter,anthropic/claude-haiku-4-5-20251001",
    "longContext": "openrouter,google/gemini-2.5-pro-preview",
    "longContextThreshold": 60000,
    "webSearch": "gemini,gemini-2.5-flash"
  }
}

You can also switch models dynamically in Claude Code with the /model command: /model provider_name,model_name Example: /model openrouter,anthropic/claude-3.5-sonnet

Custom Router

For more advanced routing logic, you can specify a custom router script via the CUSTOM_ROUTER_PATH in your config.json. This allows you to implement complex routing rules beyond the default scenarios.

In your config.json:

{
  "CUSTOM_ROUTER_PATH": "/User/xxx/.claude-code-router/custom-router.js"
}

The custom router file must be a JavaScript module that exports an async function. This function receives the request object and the config object as arguments and should return the provider and model name as a string (e.g., "provider_name,model_name"), or null to fall back to the default router.

Routing Priority

The custom router evaluates scenarios in strict priority order:

Explicit Model (highest): If req.body.model contains a valid "provider,model" string that exists in your config, it is used directly. This gives you explicit control over which model handles a request.
Long Context: When the request token count exceeds longContextThreshold, the longContext model is used.
Subagent Model Tag: Extracts <CCR-SUBAGENT-MODEL>provider,model</CCR-SUBAGENT-MODEL> tags from subagent prompts.
Background: Detects Claude Haiku requests and routes to the background model.
Agent Roles: Detects agent role from system prompts (architect, planner, explorer, debugger, reviewer, implementer, tester).
Web Search: When the request includes web search tools.
Think: When the request includes thinking mode (req.body.thinking).
Default (fallback): Uses the default model from Router.

Here is an example of a custom-router.js based on custom-router.example.js:

// /User/xxx/.claude-code-router/custom-router.js

/**
 * A custom router function to determine which model to use based on the request.
 *
 * @param {object} req - The request object from Claude Code, containing the request body.
 * @param {object} config - The application's config object.
 * @returns {Promise<string|null>} - A promise that resolves to the "provider,model_name" string, or null to use the default router.
 */
module.exports = async function router(req, config) {
  const userMessage = req.body.messages.find((m) => m.role === "user")?.content;

  if (userMessage && userMessage.includes("explain this code")) {
    // Use a powerful model for code explanation
    return "openrouter,anthropic/claude-3.5-sonnet";
  }

  // Fallback to the default router configuration
  return null;
};

For the full implementation including all scenario detectors, agent role matching, and explicit model resolution, refer to the bundled custom-router.js in the repository.

Subagent Routing

For routing within subagents, you must specify a particular provider and model by including <CCR-SUBAGENT-MODEL>provider,model</CCR-SUBAGENT-MODEL> at the beginning of the subagent's prompt. This allows you to direct specific subagent tasks to designated models.

Example:

<CCR-SUBAGENT-MODEL>openrouter,anthropic/claude-3.5-sonnet</CCR-SUBAGENT-MODEL>
Please help me analyze this code snippet for potential optimizations...

The tag is automatically stripped from the prompt before the request is forwarded to the upstream provider.

Status Line (Beta)

To better monitor the status of claude-code-router at runtime, version v1.0.40 includes a built-in statusline tool, which you can enable in the UI.

The effect is as follows:

🤖 GitHub Actions

Integrate Claude Code Router into your CI/CD pipeline. After setting up Claude Code Actions, modify your .github/workflows/claude.yaml to use the router:

name: Claude Code

on:
  issue_comment:
    types: [created]
  # ... other triggers

jobs:
  claude:
    if: |
      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
      # ... other conditions
    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,
            "NON_INTERACTIVE_MODE": 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 @jhangyu/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: "any-string-is-ok"

Note: When running in GitHub Actions or other automation environments, make sure to set "NON_INTERACTIVE_MODE": true in your configuration to prevent the process from hanging due to stdin handling issues.

This setup allows for interesting automations, like running tasks during off-peak hours to reduce API costs.

📝 Further Reading

🐳 Docker Deployment

Using Docker Compose (Recommended)

Create a docker-compose.yml:

services:
  claude-code-router:
    container_name: claude-code-router
    image: jhangyu/claude-code-router:latest
    ports:
      - "3456:3456"
    volumes:
      - ~/.claude-code-router:/root/.claude-code-router
    restart: unless-stopped

# Start the service
docker compose up -d

# Check logs
docker compose logs -f

# Stop the service
docker compose down

Using Docker Run

docker run -d \
  --name claude-code-router \
  -p 3456:3456 \
  -v ~/.claude-code-router:/root/.claude-code-router \
  --restart unless-stopped \
  jhangyu/claude-code-router:latest

Configuration

Place your config.json at ~/.claude-code-router/config.json before starting the container. The configuration directory is mounted as a volume, so changes take effect on restart:

# Restart after config changes
docker restart claude-code-router

You can also pass configuration via environment variables using the interpolation feature (see Environment Variable Interpolation above).

Building from Source

Multi-arch build (amd64 + arm64):

docker build -f Dockerfile.multiarch -t claude-code-router .

Server-only build:

docker build -f packages/server/Dockerfile -t claude-code-router .

Health Check

The container exposes a health check endpoint at port 3456. Verify it's running:

curl http://localhost:3456/health

Environment Variables

Variable	Description	Default
`PORT`	Server listen port	`3456`
`LOG_LEVEL`	Log verbosity (`fatal`/`error`/`warn`/`info`/`debug`/`trace`)	`debug`
`API_TIMEOUT_MS`	API request timeout in ms	`600000`

These can be set in docker-compose.yml:

services:
  claude-code-router:
    # ...
    environment:
      - LOG_LEVEL=info
      - API_TIMEOUT_MS=300000

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
blog		blog
docs		docs
examples		examples
packages		packages
scripts		scripts
.dockerignore		.dockerignore
.gitignore		.gitignore
.npmignore		.npmignore
AGENTS.md		AGENTS.md
CLAUDE.md		CLAUDE.md
Dockerfile.multiarch		Dockerfile.multiarch
LICENSE		LICENSE
README.md		README.md
README_zh.md		README_zh.md
custom-router.example.js		custom-router.example.js
custom-router.js		custom-router.js
docker-compose.yml		docker-compose.yml
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
pnpm-workspace.yaml		pnpm-workspace.yaml
tsconfig.base.json		tsconfig.base.json
tsconfig.json		tsconfig.json

Navigation Menu

Repository files navigation

✨ Features

🚀 Getting Started

1. Installation

2. Configuration

Environment Variable Interpolation

3. Running Claude Code with the Router

4. UI Mode

5. CLI Model Management

6. Presets Management

7. Activate Command (Environment Variables Setup)

Providers

Transformers

Router

Agent Role Routing

Custom Router

Routing Priority

Subagent Routing

Status Line (Beta)

🤖 GitHub Actions

📝 Further Reading

🐳 Docker Deployment

Using Docker Compose (Recommended)

Using Docker Run

Configuration

Building from Source

Health Check

Environment Variables

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

✨ Features

🚀 Getting Started

1. Installation

2. Configuration

Environment Variable Interpolation

3. Running Claude Code with the Router

4. UI Mode

5. CLI Model Management

6. Presets Management

7. Activate Command (Environment Variables Setup)

Providers

Transformers

Router

Agent Role Routing

Custom Router

Routing Priority

Subagent Routing

Status Line (Beta)

🤖 GitHub Actions

📝 Further Reading

🐳 Docker Deployment

Using Docker Compose (Recommended)

Using Docker Run

Configuration

Building from Source

Health Check

Environment Variables

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages