oc-go-cc

A Go CLI proxy that lets you use your OpenCode Go subscription with Claude Code.

oc-go-cc sits between Claude Code and OpenCode Go, intercepting Anthropic API requests, transforming them to OpenAI format, and forwarding them to OpenCode Go's endpoint. Claude Code thinks it's talking to Anthropic — but your requests go to affordable open models instead.

Why?

OpenCode Go gives you access to powerful open coding models for $5/month (then $10/month). This proxy makes those models work seamlessly with Claude Code's interface — no patches, no forks, just set two environment variables and go.

Features

• Transparent Proxy — Claude Code sends Anthropic-format requests, proxy transforms to OpenAI format and back
• Model Routing — Automatically routes to different models based on context (default, thinking, long context, background)
• Fallback Chains — If a model fails, automatically tries the next one in your configured chain
• Circuit Breaker — Tracks model health and skips failing models to avoid latency spikes
• Real-time Streaming — Full SSE streaming with live OpenAI → Anthropic format transformation
• Tool Calling — Proper Anthropic tool_use/tool_result ↔ OpenAI function calling translation
• Token Counting — Uses tiktoken (cl100k_base) for accurate token counting and context threshold detection
• JSON Configuration — Flexible config file with environment variable overrides and ${VAR} interpolation
• Background Mode — Run as daemon detached from terminal
• Auto-start on Login — Launch on system startup via launchd (macOS)

Installation

Homebrew (macOS & Linux)

brew tap samueltuyizere/tap
brew install oc-go-cc

Build from Source

git clone https://github.com/samueltuyizere/oc-go-cc.git
cd oc-go-cc
make build

# Binary is at bin/oc-go-cc
# Optionally install to $GOPATH/bin
make install

Download a Release Binary

Download the latest release for your platform from the Releases page:

# Example: macOS Apple Silicon
curl -L -o oc-go-cc https://github.com/samueltuyizere/oc-go-cc/releases/latest/download/oc-go-cc_darwin-arm64
chmod +x oc-go-cc
sudo mv oc-go-cc /usr/local/bin/

Requirements

• An OpenCode Go subscription and API key
• Go 1.21+ (only needed if building from source)

Quick Start

1. Initialize Configuration

oc-go-cc init

Creates a default config at ~/.config/oc-go-cc/config.json.

2. Set Your API Key

export OC_GO_CC_API_KEY=sk-opencode-your-key-here

3. Start the Proxy

oc-go-cc serve

You'll see output like:

Starting oc-go-cc v0.1.0
Listening on 127.0.0.1:3456
Forwarding to: https://opencode.ai/zen/go/v1/chat/completions

Configure Claude Code with:
  export ANTHROPIC_BASE_URL=http://127.0.0.1:3456
  export ANTHROPIC_AUTH_TOKEN=unused

Running in Background

To run the proxy in the background (detached from terminal):

oc-go-cc serve --background
# or
oc-go-cc serve -b

This starts the server as a background daemon and returns immediately. Logs are written to ~/.config/oc-go-cc/oc-go-cc.log.

Auto-start on Login

To start the proxy automatically when you log in:

oc-go-cc autostart enable

This creates a launchd plist on macOS. To disable:

oc-go-cc autostart disable

Check status:

oc-go-cc autostart status

4. Configure Claude Code

In a separate terminal (or the same one before running claude):

export ANTHROPIC_BASE_URL=http://127.0.0.1:3456
export ANTHROPIC_AUTH_TOKEN=unused

5. Run Claude Code

claude

That's it. Claude Code will now route all requests through oc-go-cc to OpenCode Go.

How It Works

┌─────────────┐     Anthropic API      ┌─────────────┐     OpenAI API       ┌─────────────┐
│  Claude Code ├──────────────────────►│  oc-go-cc    ├────────────────────►│  OpenCode Go │
│  (CLI)       │  POST /v1/messages   │  (Proxy)     │  /chat/completions  │  (Upstream)  │
│              │◄──────────────────────┤              │◄────────────────────┤              │
└─────────────┘   Anthropic SSE        └─────────────┘   OpenAI SSE          └─────────────┘

1. Claude Code sends a request in Anthropic Messages API format
2. oc-go-cc parses the request, counts tokens, and selects a model via routing rules
3. The request is transformed to OpenAI Chat Completions format
4. The transformed request is sent to OpenCode Go's endpoint
5. The response (streaming or non-streaming) is transformed back to Anthropic format
6. Claude Code receives the response as if it came from Anthropic directly

What Gets Transformed

Configuration

Config File

Location: ~/.config/oc-go-cc/config.json

Override with OC_GO_CC_CONFIG environment variable.

Full Config Reference

{
  "api_key": "${OC_GO_CC_API_KEY}",
  "host": "127.0.0.1",
  "port": 3456,

  "models": {
    "default": {
      "provider": "opencode-go",
      "model_id": "kimi-k2.6",
      "temperature": 0.7,
      "max_tokens": 4096
    },
    "background": {
      "provider": "opencode-go",
      "model_id": "qwen3.5-plus",
      "temperature": 0.5,
      "max_tokens": 2048
    },
    "think": {
      "provider": "opencode-go",
      "model_id": "glm-5.1",
      "temperature": 0.7,
      "max_tokens": 8192
    },
    "long_context": {
      "provider": "opencode-go",
      "model_id": "minimax-m2.7",
      "temperature": 0.7,
      "max_tokens": 16384,
      "context_threshold": 60000
    }
  },

  "fallbacks": {
    "default": [
      { "provider": "opencode-go", "model_id": "glm-5" },
      { "provider": "opencode-go", "model_id": "qwen3.6-plus" }
    ],
    "think": [
      { "provider": "opencode-go", "model_id": "glm-5" }
    ],
    "long_context": [
      { "provider": "opencode-go", "model_id": "minimax-m2.5" }
    ]
  },

  "opencode_go": {
    "base_url": "https://opencode.ai/zen/go/v1/chat/completions",
    "timeout_ms": 300000
  },

  "logging": {
    "level": "info",
    "requests": true
  }
}

Environment Variables

Environment variables override config file values. Config values also support ${VAR} interpolation.

Model Routing

The proxy automatically detects the type of request and routes to the appropriate model based on context size and content analysis:

📖 See MODELS.md for detailed model capabilities, costs, and routing recommendations.

Routing in Detail:

Routing priority: Long Context → Think → Background → Default

Fallback Chains

When a model request fails (network error, rate limit, server error), the proxy tries the next model in the fallback chain:

Primary model → Fallback 1 → Fallback 2 → ... → Error (all failed)

Each model also has a circuit breaker that tracks consecutive failures. After 3 failures, the circuit opens and that model is skipped for 30 seconds, then tested again (half-open state).

Available Models

See MODELS.md for detailed model capabilities, costs, and routing recommendations.

Quick reference:

💡 Tip: The cost column shows approximate requests per 5-hour block ($12). Qwen3.5 Plus gives you ~10x more requests than GLM-5.1!

⚠️ Important: MiniMax M2.5 and M2.7 use the Anthropic-compatible /v1/messages endpoint natively. oc-go-cc automatically routes these models to the correct endpoint and skips the OpenAI transformation, so they work seamlessly with Claude Code. See MODELS.md for details.

CLI Commands

oc-go-cc serve              Start the proxy server
oc-go-cc serve -b          Start in background (detached from terminal)
oc-go-cc serve --port 8080  Start on a custom port
oc-go-cc serve --config /path/to/config.json  Use a custom config
oc-go-cc stop               Stop the running proxy server
oc-go-cc status             Check if the proxy is running
oc-go-cc autostart enable   Enable auto-start on login
oc-go-cc autostart disable  Disable auto-start on login
oc-go-cc autostart status   Check autostart status
oc-go-cc init               Create default configuration file
oc-go-cc validate           Validate configuration file
oc-go-cc models             List available OpenCode Go models
oc-go-cc --version          Show version

API Endpoints

The proxy exposes these endpoints that Claude Code expects:

Troubleshooting

"invalid request body" Error

This means the proxy couldn't parse the request from Claude Code. Enable debug logging to see the raw request:

{ "logging": { "level": "debug" } }

Or set the environment variable:

export OC_GO_CC_LOG_LEVEL=debug

"all models failed" Error

All models in the fallback chain returned errors. Check:

1. Your API key is valid: oc-go-cc validate
2. You haven't exceeded your usage limits
3. The OpenCode Go service is reachable: curl -H "Authorization: Bearer $OC_GO_CC_API_KEY" https://opencode.ai/zen/go/v1/models

Connection Refused

Make sure the proxy is running:

oc-go-cc status

And Claude Code is pointing to the right address:

echo $ANTHROPIC_BASE_URL  # Should be http://127.0.0.1:3456

Streaming Not Working

The proxy transforms OpenAI SSE to Anthropic SSE in real-time. If streaming appears broken:

1. Set log level to debug to see the raw SSE chunks
2. Check that no proxy or firewall is buffering the connection
3. Try a non-streaming request first to verify the model works

Debug Mode

For maximum logging, run with debug level:

OC_GO_CC_LOG_LEVEL=debug oc-go-cc serve

This logs:

• Raw Anthropic request body from Claude Code
• Transformed OpenAI request sent to OpenCode Go
• Raw OpenAI response received
• SSE stream events during streaming

Architecture

cmd/oc-go-cc/main.go           CLI entry point (cobra commands)
internal/
├── config/
│   ├── config.go               Config types
│   └── loader.go               JSON loading, env overrides, ${VAR} interpolation
├── router/
│   ├── model_router.go         Model selection based on scenario
│   ├── scenarios.go            Scenario detection (default/think/long_context/background)
│   └── fallback.go            Fallback handler with circuit breaker
├── server/
│   └── server.go               HTTP server setup, graceful shutdown, PID management
├── handlers/
│   ├── messages.go             POST /v1/messages handler (streaming + non-streaming)
│   └── health.go               Health check and token counting endpoints
├── transformer/
│   ├── request.go              Anthropic → OpenAI request transformation
│   ├── response.go             OpenAI → Anthropic response transformation
│   └── stream.go               Real-time SSE stream transformation
├── client/
│   └── opencode.go             OpenCode Go HTTP client
└── token/
    └── counter.go              Tiktoken token counter (cl100k_base)
pkg/types/
├── anthropic.go                Anthropic API types (polymorphic system/content fields)
└── openai.go                   OpenAI API types
configs/
└── config.example.json         Example configuration

Key Design Decisions

• Polymorphic field handling: Anthropic's system and content fields accept both strings and arrays. We use json.RawMessage with accessor methods (SystemText(), ContentBlocks()) to handle both formats correctly.
• Real-time stream proxying: SSE events are transformed in-flight, not buffered. This means Claude Code sees responses as they arrive from OpenCode Go.
• Circuit breaker per model: Each model gets its own circuit breaker. After 3 consecutive failures, the model is skipped for 30 seconds, then tested again.
• Environment variable interpolation: Config values like "${OC_GO_CC_API_KEY}" are resolved at load time, so you never need to put secrets in the config file.

Development

# Build (version auto-detected from git)
make build

# Run in development mode
make run

# Run tests with race detector
make test

# Run go vet
make vet

# Clean build artifacts
make clean

# Install to $GOPATH/bin
make install

# Build cross-platform release binaries
make dist

License

MIT