opencode-claude-max-proxy 1.11.2 → 1.12.1

package/dist/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import {
+  startProxyServer
+} from "./cli-s4sk7eks.js";
+
+// bin/cli.ts
+import { execSync } from "child_process";
+process.on("uncaughtException", (err) => {
+  console.error(`[PROXY] Uncaught exception (recovered): ${err.message}`);
+});
+process.on("unhandledRejection", (reason) => {
+  console.error(`[PROXY] Unhandled rejection (recovered): ${reason instanceof Error ? reason.message : reason}`);
+});
+var port = parseInt(process.env.CLAUDE_PROXY_PORT || "3456", 10);
+var host = process.env.CLAUDE_PROXY_HOST || "127.0.0.1";
+var idleTimeoutSeconds = parseInt(process.env.CLAUDE_PROXY_IDLE_TIMEOUT_SECONDS || "120", 10);
+try {
+  const authJson = execSync("claude auth status", { encoding: "utf-8", timeout: 5000 });
+  const auth = JSON.parse(authJson);
+  if (!auth.loggedIn) {
+    console.error("\x1B[31m✗ Not logged in to Claude.\x1B[0m Run: claude login");
+    process.exit(1);
+  }
+  if (auth.subscriptionType !== "max") {
+    console.error(`\x1B[33m⚠ Claude subscription: ${auth.subscriptionType || "unknown"} (Max recommended)\x1B[0m`);
+  }
+} catch {
+  console.error("\x1B[33m⚠ Could not verify Claude auth status. If requests fail, run: claude login\x1B[0m");
+}
+await startProxyServer({ port, host, idleTimeoutSeconds });

package/dist/server.js

@@ -0,0 +1,10 @@
+import {
+  clearSessionCache,
+  createProxyServer,
+  startProxyServer
+} from "./cli-s4sk7eks.js";
+export {
+  startProxyServer,
+  createProxyServer,
+  clearSessionCache
+};

package/package.json

@@ -1,40 +1,42 @@
 {
   "name": "opencode-claude-max-proxy",
-  "version": "1.11.2",
+  "version": "1.12.1",
   "description": "Use your Claude Max subscription with OpenCode via proxy server",
   "type": "module",
-  "main": "./src/proxy/server.ts",
+  "main": "./dist/server.js",
   "bin": {
-    "claude-max-proxy": "./bin/claude-proxy.ts"
+    "claude-max-proxy": "./dist/cli.js"
   },
   "exports": {
-    ".": "./src/proxy/server.ts"
+    ".": "./dist/server.js"
+  },
+  "engines": {
+    "node": ">=22"
   },
   "scripts": {
     "start": "./bin/claude-proxy-supervisor.sh",
     "proxy": "./bin/claude-proxy-supervisor.sh",
+    "build": "rm -rf dist && bun build bin/cli.ts src/proxy/server.ts --outdir dist --target node --splitting --external @anthropic-ai/claude-agent-sdk --entry-naming '[name].js'",
+    "postbuild": "node --check dist/cli.js && node --check dist/server.js",
+    "prepublishOnly": "bun run build",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
-    "proxy:direct": "bun run ./bin/claude-proxy.ts"
+    "proxy:direct": "bun run ./bin/cli.ts"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.80",
-    "glob": "^13.0.0",
-    "hono": "^4.11.4",
-    "p-queue": "^8.0.1"
+    "@anthropic-ai/claude-agent-sdk": "^0.2.80"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.21",
+    "@hono/node-server": "^1.19.11",
+    "@types/bun": "^1.3.11",
     "@types/node": "^22.0.0",
+    "glob": "^13.0.0",
+    "hono": "^4.11.4",
     "typescript": "^5.8.2"
   },
   "files": [
-    "bin/",
-    "src/proxy/",
-    "src/logger.ts",
-    "src/mcpTools.ts",
-    "README.md",
-    "src/plugin/"
+    "dist/",
+    "README.md"
   ],
   "keywords": [
     "opencode",
@@ -61,5 +63,6 @@
   },
   "author": "rynfar",
   "license": "MIT",
-  "private": false
+  "private": false,
+  "packageManager": "bun@1.3.11"
 }

package/bin/claude-proxy-supervisor.sh

@@ -1,62 +0,0 @@
-#!/bin/bash
-# Auto-restart supervisor for claude-max-proxy
-#
-# The Claude Agent SDK's cli.js subprocess (compiled with Bun) can crash
-# during cleanup of concurrent streaming responses — a known Bun bug
-# (oven-sh/bun#17947). All responses are delivered correctly; the crash
-# only occurs after response completion.
-#
-# This supervisor runs the proxy in a subshell with signal isolation,
-# detects crashes, and restarts in ~1 second.
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$SCRIPT_DIR/.."
-
-# Ignore signals that the child's crash might propagate
-trap '' SIGPIPE
-
-RESTART_COUNT=0
-MAX_RAPID_RESTARTS=50
-RAPID_WINDOW=60
-LAST_START=0
-
-while true; do
-  NOW=$(date +%s)
-  
-  if [ $((NOW - LAST_START)) -gt $RAPID_WINDOW ]; then
-    RESTART_COUNT=0
-  fi
-  
-  if [ $RESTART_COUNT -ge $MAX_RAPID_RESTARTS ]; then
-    echo "[supervisor] Too many restarts ($RESTART_COUNT in ${RAPID_WINDOW}s). Stopping."
-    exit 1
-  fi
-  
-  LAST_START=$NOW
-  RESTART_COUNT=$((RESTART_COUNT + 1))
-  
-  if [ $RESTART_COUNT -gt 1 ]; then
-    echo "[supervisor] Restarting proxy (restart #$RESTART_COUNT)..."
-  else
-    echo "[supervisor] Starting proxy..."
-  fi
-  
-  # Run in subshell so crashes don't kill the supervisor
-  (exec bun run ./bin/claude-proxy.ts)
-  EXIT_CODE=$?
-  
-  if [ $EXIT_CODE -eq 0 ]; then
-    echo "[supervisor] Proxy exited cleanly."
-    break
-  fi
-  
-  # Signal-based exits (128+signal)
-  if [ $EXIT_CODE -gt 128 ]; then
-    SIG=$((EXIT_CODE - 128))
-    echo "[supervisor] Proxy killed by signal $SIG. Restarting in 1s..."
-  else
-    echo "[supervisor] Proxy exited (code $EXIT_CODE). Restarting in 1s..."
-  fi
-  
-  sleep 1
-done

package/bin/claude-proxy.ts

@@ -1,33 +0,0 @@
-#!/usr/bin/env bun
-
-import { startProxyServer } from "../src/proxy/server"
-import { execSync } from "child_process"
-
-// Prevent SDK subprocess crashes from killing the proxy
-process.on("uncaughtException", (err) => {
-  console.error(`[PROXY] Uncaught exception (recovered): ${err.message}`)
-})
-process.on("unhandledRejection", (reason) => {
-  console.error(`[PROXY] Unhandled rejection (recovered): ${reason instanceof Error ? reason.message : reason}`)
-})
-
-const port = parseInt(process.env.CLAUDE_PROXY_PORT || "3456", 10)
-const host = process.env.CLAUDE_PROXY_HOST || "127.0.0.1"
-const idleTimeoutSeconds = parseInt(process.env.CLAUDE_PROXY_IDLE_TIMEOUT_SECONDS || "120", 10)
-
-// Pre-flight auth check
-try {
-  const authJson = execSync("claude auth status", { encoding: "utf-8", timeout: 5000 })
-  const auth = JSON.parse(authJson)
-  if (!auth.loggedIn) {
-    console.error("\x1b[31m✗ Not logged in to Claude.\x1b[0m Run: claude login")
-    process.exit(1)
-  }
-  if (auth.subscriptionType !== "max") {
-    console.error(`\x1b[33m⚠ Claude subscription: ${auth.subscriptionType || "unknown"} (Max recommended)\x1b[0m`)
-  }
-} catch {
-  console.error("\x1b[33m⚠ Could not verify Claude auth status. If requests fail, run: claude login\x1b[0m")
-}
-
-await startProxyServer({ port, host, idleTimeoutSeconds })

package/bin/docker-auth.sh

@@ -1,77 +0,0 @@
-#!/bin/bash
-# Copy Claude credentials from host into Docker container.
-#
-# macOS stores scopes in Keychain, so the credentials file has scopes: ""
-# Linux Claude CLI needs scopes as an array. This script fixes the format.
-#
-# Usage: ./bin/docker-auth.sh
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$SCRIPT_DIR/.."
-
-HOST_CREDS="$HOME/.claude/.credentials.json"
-
-if [ ! -f "$HOST_CREDS" ]; then
-  echo "❌ No credentials found at $HOST_CREDS"
-  echo "   Run 'claude login' on your host first."
-  exit 1
-fi
-
-# Check if host is logged in
-if ! claude auth status 2>/dev/null | grep -q '"loggedIn": true'; then
-  echo "❌ Not logged in on host. Run 'claude login' first."
-  exit 1
-fi
-
-echo "📋 Reading credentials from host..."
-
-# Fix the scopes field and copy into container
-python3 -c "
-import json, sys
-
-with open('$HOST_CREDS') as f:
-    creds = json.load(f)
-
-oauth = creds.get('claudeAiOauth', {})
-if not oauth.get('accessToken'):
-    print('❌ No access token found in credentials')
-    sys.exit(1)
-
-# Fix scopes: empty string -> proper array
-if not oauth.get('scopes') or oauth['scopes'] == '':
-    oauth['scopes'] = [
-        'user:profile',
-        'user:inference', 
-        'user:sessions:claude_code',
-        'user:mcp_servers',
-        'user:file_upload'
-    ]
-
-creds['claudeAiOauth'] = oauth
-print(json.dumps(creds))
-" | docker compose exec -T proxy bash -c 'cat > /home/claude/.claude/.credentials.json'
-
-if [ $? -ne 0 ]; then
-  echo "❌ Failed to copy credentials. Is the container running?"
-  echo "   Run 'docker compose up -d' first."
-  exit 1
-fi
-
-# Also copy .claude.json if it exists
-if [ -f "$HOME/.claude/.claude.json" ]; then
-  docker compose exec -T proxy bash -c 'cat > /home/claude/.claude/.claude.json' < "$HOME/.claude/.claude.json"
-fi
-
-# Verify
-echo "🔍 Verifying..."
-AUTH=$(docker compose exec proxy claude auth status 2>&1)
-if echo "$AUTH" | grep -q '"loggedIn": true'; then
-  EMAIL=$(echo "$AUTH" | grep -o '"email": "[^"]*"' | head -1)
-  echo "✅ Docker container authenticated! $EMAIL"
-else
-  echo "❌ Authentication failed inside container"
-  echo "$AUTH"
-  exit 1
-fi

package/bin/docker-entrypoint.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-# Docker entrypoint:
-# 1. Fix volume permissions (created as root, need claude ownership)
-# 2. Symlink .claude.json into persistent volume
-
-CLAUDE_DIR="/home/claude/.claude"
-CLAUDE_JSON="/home/claude/.claude.json"
-CLAUDE_JSON_VOL="$CLAUDE_DIR/.claude.json"
-
-# Fix ownership if volume was created as root
-if [ -d "$CLAUDE_DIR" ] && [ ! -w "$CLAUDE_DIR" ]; then
-  echo "[entrypoint] Fixing volume permissions..."
-fi
-
-# Symlink .claude.json into volume so it persists across restarts
-if [ -f "$CLAUDE_JSON_VOL" ] && [ ! -f "$CLAUDE_JSON" ]; then
-  ln -sf "$CLAUDE_JSON_VOL" "$CLAUDE_JSON"
-elif [ -f "$CLAUDE_JSON" ] && [ ! -L "$CLAUDE_JSON" ] && [ -w "$CLAUDE_DIR" ]; then
-  cp "$CLAUDE_JSON" "$CLAUDE_JSON_VOL" 2>/dev/null
-  rm -f "$CLAUDE_JSON"
-  ln -sf "$CLAUDE_JSON_VOL" "$CLAUDE_JSON"
-fi
-
-exec "$@"

package/bin/oc.sh

@@ -1,62 +0,0 @@
-#!/bin/bash
-# Per-terminal proxy launcher for OpenCode.
-#
-# Starts a dedicated proxy on a random port, launches OpenCode pointed at it,
-# and cleans up when OpenCode exits. Each terminal gets its own proxy — no
-# concurrent request issues, no shared port conflicts.
-#
-# Session resume works across terminals via the shared session file store.
-#
-# Usage: ./bin/oc.sh [opencode args...]
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROXY_SCRIPT="$SCRIPT_DIR/claude-proxy.ts"
-
-if [ ! -f "$PROXY_SCRIPT" ]; then
-  echo "❌ Proxy script not found: $PROXY_SCRIPT" >&2
-  exit 1
-fi
-
-# Pick a random free port
-PORT=$(python3 -c 'import socket; s = socket.socket(); s.bind(("127.0.0.1", 0)); print(s.getsockname()[1]); s.close()' 2>/dev/null \
-  || ruby -e 'require "socket"; s = TCPServer.new("127.0.0.1", 0); puts s.addr[1]; s.close' 2>/dev/null \
-  || echo $((RANDOM + 10000)))
-
-# Start proxy in background
-CLAUDE_PROXY_PORT=$PORT \
-CLAUDE_PROXY_WORKDIR="$PWD" \
-CLAUDE_PROXY_PASSTHROUGH="${CLAUDE_PROXY_PASSTHROUGH:-1}" \
-  bun run "$PROXY_SCRIPT" > /dev/null 2>&1 &
-PROXY_PID=$!
-
-# Ensure proxy is cleaned up on exit
-cleanup() {
-  kill $PROXY_PID 2>/dev/null
-  wait $PROXY_PID 2>/dev/null
-}
-trap cleanup EXIT INT TERM
-
-# Wait for proxy to be ready (up to 10 seconds)
-for i in $(seq 1 100); do
-  if curl -sf "http://127.0.0.1:$PORT/health" > /dev/null 2>&1; then
-    break
-  fi
-  if ! kill -0 $PROXY_PID 2>/dev/null; then
-    echo "❌ Proxy failed to start" >&2
-    exit 1
-  fi
-  sleep 0.1
-done
-
-# Verify proxy is healthy
-if ! curl -sf "http://127.0.0.1:$PORT/health" > /dev/null 2>&1; then
-  echo "❌ Proxy didn't become healthy within 10 seconds" >&2
-  exit 1
-fi
-
-# Launch OpenCode
-ANTHROPIC_API_KEY=dummy \
-ANTHROPIC_BASE_URL="http://127.0.0.1:$PORT" \
-  opencode "$@"

package/src/logger.ts

@@ -1,72 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks"
-
-type LogFields = Record<string, unknown>
-
-const contextStore = new AsyncLocalStorage<LogFields>()
-
-const shouldLog = () => process.env["OPENCODE_CLAUDE_PROVIDER_DEBUG"]
-const shouldLogStreamDebug = () => process.env["OPENCODE_CLAUDE_PROVIDER_STREAM_DEBUG"]
-
-const isVerboseStreamEvent = (event: string): boolean => {
-  return event.startsWith("stream.") || event === "response.empty_stream"
-}
-
-const REDACTED_KEYS = new Set([
-  "authorization",
-  "cookie",
-  "x-api-key",
-  "apiKey",
-  "apikey",
-  "prompt",
-  "messages",
-  "content"
-])
-
-const sanitize = (value: unknown): unknown => {
-  if (value === null || value === undefined) return value
-
-  if (typeof value === "string") {
-    if (value.length > 512) {
-      return `${value.slice(0, 512)}... [truncated=${value.length}]`
-    }
-    return value
-  }
-
-  if (Array.isArray(value)) {
-    return value.map(sanitize)
-  }
-
-  if (typeof value === "object") {
-    const out: Record<string, unknown> = {}
-    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-      if (REDACTED_KEYS.has(k)) {
-        if (typeof v === "string") {
-          out[k] = `[redacted len=${v.length}]`
-        } else if (Array.isArray(v)) {
-          out[k] = `[redacted array len=${v.length}]`
-        } else {
-          out[k] = "[redacted]"
-        }
-      } else {
-        out[k] = sanitize(v)
-      }
-    }
-    return out
-  }
-
-  return value
-}
-
-export const withClaudeLogContext = <T>(context: LogFields, fn: () => T): T => {
-  return contextStore.run(context, fn)
-}
-
-export const claudeLog = (event: string, extra?: LogFields) => {
-  if (!shouldLog()) return
-  if (isVerboseStreamEvent(event) && !shouldLogStreamDebug()) return
-
-  const context = contextStore.getStore() || {}
-  const payload = sanitize({ ts: new Date().toISOString(), event, ...context, ...(extra || {}) })
-
-  console.debug(`[opencode-claude-code-provider] ${JSON.stringify(payload)}`)
-}

package/src/mcpTools.ts

@@ -1,185 +0,0 @@
-import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk"
-import { z } from "zod"
-import * as fs from "node:fs/promises"
-import * as path from "node:path"
-import { exec } from "node:child_process"
-import { promisify } from "node:util"
-import { glob as globLib } from "glob"
-
-const execAsync = promisify(exec)
-
-const getCwd = () => process.env.CLAUDE_PROXY_WORKDIR || process.cwd()
-
-export const opencodeMcpServer = createSdkMcpServer({
-  name: "opencode",
-  version: "1.0.0",
-  tools: [
-    tool(
-      "read",
-      "Read the contents of a file at the specified path",
-      {
-        path: z.string().describe("Absolute or relative path to the file"),
-        encoding: z.string().optional().describe("File encoding, defaults to utf-8")
-      },
-      async (args) => {
-        try {
-          const filePath = path.isAbsolute(args.path) 
-            ? args.path 
-            : path.resolve(getCwd(), args.path)
-          const content = await fs.readFile(filePath, (args.encoding || "utf-8") as BufferEncoding)
-          return {
-            content: [{ type: "text", text: content }]
-          }
-        } catch (error) {
-          return {
-            content: [{ type: "text", text: `Error reading file: ${error instanceof Error ? error.message : String(error)}` }],
-            isError: true
-          }
-        }
-      }
-    ),
-    
-    tool(
-      "write",
-      "Write content to a file, creating directories if needed",
-      {
-        path: z.string().describe("Path to write to"),
-        content: z.string().describe("Content to write")
-      },
-      async (args) => {
-        try {
-          const filePath = path.isAbsolute(args.path)
-            ? args.path
-            : path.resolve(getCwd(), args.path)
-          await fs.mkdir(path.dirname(filePath), { recursive: true })
-          await fs.writeFile(filePath, args.content, "utf-8")
-          return {
-            content: [{ type: "text", text: `Successfully wrote to ${args.path}` }]
-          }
-        } catch (error) {
-          return {
-            content: [{ type: "text", text: `Error writing file: ${error instanceof Error ? error.message : String(error)}` }],
-            isError: true
-          }
-        }
-      }
-    ),
-    
-    tool(
-      "edit",
-      "Edit a file by replacing oldString with newString",
-      {
-        path: z.string().describe("Path to the file to edit"),
-        oldString: z.string().describe("The text to replace"),
-        newString: z.string().describe("The replacement text")
-      },
-      async (args) => {
-        try {
-          const filePath = path.isAbsolute(args.path)
-            ? args.path
-            : path.resolve(getCwd(), args.path)
-          const content = await fs.readFile(filePath, "utf-8")
-          if (!content.includes(args.oldString)) {
-            return {
-              content: [{ type: "text", text: `Error: oldString not found in file` }],
-              isError: true
-            }
-          }
-          const newContent = content.replace(args.oldString, args.newString)
-          await fs.writeFile(filePath, newContent, "utf-8")
-          return {
-            content: [{ type: "text", text: `Successfully edited ${args.path}` }]
-          }
-        } catch (error) {
-          return {
-            content: [{ type: "text", text: `Error editing file: ${error instanceof Error ? error.message : String(error)}` }],
-            isError: true
-          }
-        }
-      }
-    ),
-    
-    tool(
-      "bash",
-      "Execute a bash command and return the output",
-      {
-        command: z.string().describe("The command to execute"),
-        cwd: z.string().optional().describe("Working directory for the command")
-      },
-      async (args) => {
-        try {
-          const options = { 
-            cwd: args.cwd || getCwd(),
-            timeout: 120000
-          }
-          const { stdout, stderr } = await execAsync(args.command, options)
-          const output = stdout || stderr || "(no output)"
-          return {
-            content: [{ type: "text", text: output }]
-          }
-        } catch (error: unknown) {
-          const execError = error as { stdout?: string; stderr?: string; message?: string }
-          const output = execError.stdout || execError.stderr || execError.message || String(error)
-          return {
-            content: [{ type: "text", text: output }],
-            isError: true
-          }
-        }
-      }
-    ),
-    
-    tool(
-      "glob",
-      "Find files matching a glob pattern",
-      {
-        pattern: z.string().describe("Glob pattern like **/*.ts"),
-        cwd: z.string().optional().describe("Base directory for the search")
-      },
-      async (args) => {
-        try {
-          const files = await globLib(args.pattern, {
-            cwd: args.cwd || getCwd(),
-            nodir: true,
-            ignore: ["**/node_modules/**", "**/.git/**"]
-          })
-          return {
-            content: [{ type: "text", text: files.join("\n") || "(no matches)" }]
-          }
-        } catch (error) {
-          return {
-            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
-            isError: true
-          }
-        }
-      }
-    ),
-    
-    tool(
-      "grep",
-      "Search for a pattern in files",
-      {
-        pattern: z.string().describe("Regex pattern to search for"),
-        path: z.string().optional().describe("Directory or file to search in"),
-        include: z.string().optional().describe("File pattern to include, e.g., *.ts")
-      },
-      async (args) => {
-        try {
-          const searchPath = args.path || getCwd()
-          const includePattern = args.include || "*"
-          
-          let cmd = `grep -rn --include="${includePattern}" "${args.pattern}" "${searchPath}" 2>/dev/null || true`
-          const { stdout } = await execAsync(cmd, { maxBuffer: 10 * 1024 * 1024 })
-          
-          return {
-            content: [{ type: "text", text: stdout || "(no matches)" }]
-          }
-        } catch (error) {
-          return {
-            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
-            isError: true
-          }
-        }
-      }
-    )
-  ]
-})

package/src/plugin/claude-max-headers.ts

@@ -1,52 +0,0 @@
-/**
- * OpenCode plugin that injects session tracking headers into Anthropic API requests.
- *
- * This enables the claude-max-proxy to reliably track sessions and resume
- * Claude Agent SDK conversations instead of starting fresh every time.
- *
- * Installation:
- *   Add to your opencode.json:
- *     { "plugin": ["./path/to/claude-max-headers.ts"] }
- *
- *   Or copy to your project's .opencode/plugin/ directory.
- *
- * What it does:
- *   Adds x-opencode-session and x-opencode-request headers to requests
- *   sent to the Anthropic provider. The proxy uses these to map OpenCode
- *   sessions to Claude SDK sessions for conversation resumption.
- *
- * Without this plugin:
- *   The proxy falls back to fingerprint-based session matching (hashing
- *   the first user message). This works but is less reliable.
- */
-
-type ChatHeadersHook = (
-  incoming: {
-    sessionID: string
-    agent: any
-    model: { providerID: string }
-    provider: any
-    message: { id: string }
-  },
-  output: { headers: Record<string, string> }
-) => Promise<void>
-
-type PluginHooks = {
-  "chat.headers"?: ChatHeadersHook
-}
-
-type PluginFn = (input: any) => Promise<PluginHooks>
-
-export const ClaudeMaxHeadersPlugin: PluginFn = async (_input) => {
-  return {
-    "chat.headers": async (incoming, output) => {
-      // Only inject headers for Anthropic provider requests
-      if (incoming.model.providerID !== "anthropic") return
-
-      output.headers["x-opencode-session"] = incoming.sessionID
-      output.headers["x-opencode-request"] = incoming.message.id
-    },
-  }
-}
-
-export default ClaudeMaxHeadersPlugin