panrouter 1.0.1

package/cli.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+/**
+ * Pan Router CLI — 一键安装 + 启动
+ *
+ * 用法:
+ *   npx pan-router              # 一键安装 + 启动
+ *   npx pan-router --install    # 只安装配置
+ *   npx pan-router --server     # 只启动代理
+ */
+
+import { execSync, spawn } from "node:child_process";
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const HOME = process.env.USERPROFILE || process.env.HOME;
+const CLAUDE_DIR = path.join(HOME, ".claude");
+const SETTINGS_PATH = path.join(CLAUDE_DIR, "settings.json");
+const BACKUP_PATH = path.join(CLAUDE_DIR, "settings.json.panrouter.backup");
+
+function log(label, msg, color = "") {
+  const colors = { green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m", reset: "\x1b[0m" };
+  const c = colors[color] || "";
+  console.log(`${c}[${label}]${colors.reset} ${msg}`);
+}
+
+function run(cmd) {
+  try {
+    execSync(cmd, { stdio: "inherit" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runSilent(cmd) {
+  try {
+    execSync(cmd, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── 1. 检查 / 安装 Claude Code ──────────────────────────────────────────
+
+function installClaudeCode() {
+  log("..", "正在检查 Claude Code...", "yellow");
+  if (runSilent("claude --version")) {
+    log("OK", "Claude Code 已就绪", "green");
+    return true;
+  }
+
+  log("..", "正在安装 Claude Code...", "yellow");
+  if (!run("npm install -g @anthropic-ai/claude-code")) {
+    log("!!", "Claude Code 安装失败", "red");
+    return false;
+  }
+  log("OK", "Claude Code 安装成功", "green");
+  return true;
+}
+
+// ─── 2. 写入配置文件 ─────────────────────────────────────────────────────
+
+function writeConfig() {
+  log("..", "正在写入配置...", "yellow");
+
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+  }
+
+  // 备份
+  if (fs.existsSync(SETTINGS_PATH)) {
+    fs.copyFileSync(SETTINGS_PATH, BACKUP_PATH);
+    log("OK", "原配置已备份", "green");
+  }
+
+  const config = {
+    env: {
+      ANTHROPIC_BASE_URL: "http://127.0.0.1:50816",
+      ANTHROPIC_AUTH_TOKEN: "public",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: "combo",
+      ANTHROPIC_DEFAULT_SONNET_MODEL: "combo",
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "combo",
+    },
+    hasCompletedOnboarding: true,
+  };
+
+  fs.writeFileSync(SETTINGS_PATH, JSON.stringify(config, null, 2), "utf-8");
+  log("OK", "配置文件已写入 ~/.claude/settings.json", "green");
+}
+
+// ─── 3. 启动代理服务器（后台运行） ───────────────────────────────────────
+
+function startServer() {
+  const serverPath = path.join(__dirname, "server.mjs");
+
+  // 关掉旧的 Pan Router
+  try {
+    if (process.platform === "win32") {
+      execSync('taskkill /f /fi "WINDOWTITLE eq Pan Router*" >nul 2>&1', { stdio: "pipe" });
+    } else {
+      execSync("pkill -f 'node.*server.mjs' 2>/dev/null", { stdio: "pipe" });
+    }
+  } catch {}
+
+  log("..", "正在启动 Pan Router（端口 50816）...", "yellow");
+
+  // 后台启动，不阻塞终端
+  const child = spawn("node", [serverPath], {
+    cwd: __dirname,
+    stdio: "ignore",
+    detached: true,
+  });
+  child.unref();
+
+  // 等 2 秒确认启动
+  setTimeout(() => {
+    try {
+      const req = http.get("http://127.0.0.1:50816/health", () => {});
+      req.on("error", () => {});
+    } catch {}
+    log("OK", "Pan Router 已启动（端口 50816）", "green");
+    console.log("\n  现在可以运行: \x1b[33mclaude \"你好\"\x1b[0m\n");
+  }, 2000);
+}
+
+// ─── 主流程 ──────────────────────────────────────────────────────────────
+
+function printBanner() {
+  console.log(`
+\x1b[36m============================================\x1b[0m
+\x1b[36m  Pan Router - Claude Code 一键安装\x1b[0m
+\x1b[36m  无需 API Key，开箱即用\x1b[0m
+\x1b[36m============================================\x1b[0m
+  `);
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+  pan-router — Claude Code 免费 AI 路由代理
+
+  \x1b[33m用法:\x1b[0m
+    panrouter              一键安装 + 启动
+    panrouter --install    只安装配置
+    panrouter --server     只启动代理
+    panrouter --help       显示帮助
+
+  \x1b[33m配置:\x1b[0m
+    代理运行在 http://127.0.0.1:50816
+    Claude Code 自动使用，无需额外设置
+    `);
+    return;
+  }
+
+  if (args.includes("--install") || args.includes("-i")) {
+    printBanner();
+    if (!installClaudeCode()) process.exit(1);
+    writeConfig();
+    console.log("\n  ✓ 安装完成，运行 \x1b[33mpanrouter --server\x1b[0m 启动代理\n");
+    return;
+  }
+
+  if (args.includes("--server") || args.includes("-s")) {
+    startServer();
+    return;
+  }
+
+  // 默认：全流程
+  printBanner();
+  if (!installClaudeCode()) process.exit(1);
+  writeConfig();
+  startServer();
+}
+
+main();

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "panrouter",
+  "version": "1.0.1",
+  "description": "让 Claude Code 免费使用 DeepSeek 等模型，无需 API Key",
+  "type": "module",
+  "bin": {
+    "panrouter": "cli.js"
+  },
+  "files": [
+    "cli.js",
+    "server.mjs"
+  ],
+  "license": "MIT"
+}

package/server.mjs

@@ -0,0 +1,429 @@
+/**
+ * Pan Router
+ *
+ * 将 Claude Code 的 Anthropic 格式请求转发到 OpenCode Free，
+ * 自动完成格式翻译 (Anthropic ↔ OpenAI)。
+ *
+ * 照抄 9Router 的 openaiToClaudeResponse + formatSSE 逻辑
+ *
+ * 用法:
+ *   node pan-router.mjs
+ *   # ~/.claude/settings.json 的 env 设:
+ *   #   ANTHROPIC_BASE_URL: http://127.0.0.1:50816
+ *   #   ANTHROPIC_AUTH_TOKEN: public
+ */
+
+import http from "node:http";
+import https from "node:https";
+
+const PORT = 50816;
+const OPENCODE_BASE = "opencode.ai";
+const AUTH_TOKEN = "public";
+
+const MODEL_MAP = { "combo": "deepseek-v4-flash-free" };
+const DEFAULT_MODEL = "deepseek-v4-flash-free";
+
+function json(s) { try { return JSON.parse(s); } catch { return null; } }
+
+// ─── 请求翻译: Anthropic → OpenAI ────────────────────────────────────────────
+
+function claudeToOpenAI(body) {
+  const result = { messages: [], stream: true };
+  const raw = body.model || "";
+  const name = raw.includes("/") ? raw.split("/").pop() : raw;
+  result.model = MODEL_MAP[name] || MODEL_MAP[raw] || DEFAULT_MODEL;
+
+  if (body.max_tokens) result.max_tokens = body.max_tokens;
+  if (body.temperature !== undefined) result.temperature = body.temperature;
+  if (body.top_p !== undefined) result.top_p = body.top_p;
+  if (body.system) {
+    const txt = Array.isArray(body.system)
+      ? body.system.map(s => s.text || "").filter(Boolean).join("\n")
+      : String(body.system);
+    if (txt) result.messages.push({ role: "system", content: txt });
+  }
+  if (Array.isArray(body.messages)) {
+    for (const m of body.messages) {
+      const c = convertMsg(m);
+      if (Array.isArray(c)) result.messages.push(...c);
+      else if (c) result.messages.push(c);
+    }
+  }
+  if (Array.isArray(body.tools)) {
+    result.tools = body.tools.map(t => ({
+      type: "function",
+      function: { name: t.name, description: String(t.description || ""), parameters: t.input_schema || { type: "object", properties: {} } },
+    }));
+  }
+  if (body.tool_choice) {
+    const tc = body.tool_choice;
+    if (tc.type === "tool") result.tool_choice = { type: "function", function: { name: tc.name } };
+    else result.tool_choice = tc.type === "any" ? "required" : tc.type;
+  }
+  if (body.stop_sequences) result.stop = Array.isArray(body.stop_sequences) ? body.stop_sequences : [body.stop_sequences];
+  return result;
+}
+
+function convertMsg(m) {
+  if (m.role === "user") return convertUser(m);
+  if (m.role === "assistant") return convertAssistant(m);
+  if (m.role === "tool") return { role: "tool", tool_call_id: m.tool_use_id, content: flatText(m.content) };
+  return null;
+}
+
+function convertUser(m) {
+  if (typeof m.content === "string") return { role: "user", content: m.content };
+  if (!Array.isArray(m.content)) return { role: "user", content: "" };
+  const parts = [], toolResults = [];
+  for (const b of m.content) {
+    if (b.type === "text") parts.push(b.text);
+    if (b.type === "tool_result") toolResults.push({ role: "tool", tool_call_id: b.tool_use_id, content: flatText(b.content) });
+  }
+  if (toolResults.length > 0) {
+    if (parts.length) toolResults.push({ role: "user", content: parts.join("") });
+    return toolResults;
+  }
+  return { role: "user", content: parts.join("") };
+}
+
+function convertAssistant(m) {
+  if (typeof m.content === "string") return m.content ? { role: "assistant", content: m.content } : null;
+  if (!Array.isArray(m.content)) return null;
+  const texts = [], calls = [];
+  for (const b of m.content) {
+    if (b.type === "text") texts.push(b.text);
+    if (b.type === "thinking") texts.push(b.thinking || "");
+    if (b.type === "tool_use") calls.push({ id: b.id, type: "function", function: { name: b.name, arguments: JSON.stringify(b.input || {}) } });
+  }
+  const r = { role: "assistant" };
+  if (texts.length && calls.length === 0) r.content = texts.join("");
+  if (calls.length > 0) r.tool_calls = calls;
+  if (calls.length === 0 && texts.length === 0) r.content = "";
+  return r;
+}
+
+function flatText(c) {
+  if (typeof c === "string") return c;
+  if (Array.isArray(c)) return c.filter(x => x.type === "text").map(x => x.text).join("\n");
+  return "";
+}
+
+// ─── 照抄 9Router: extractReasoningText ─────────────────────────────────────
+
+function extractReasoningText(delta) {
+  if (!delta || typeof delta !== "object") return "";
+  if (typeof delta.reasoning_content === "string" && delta.reasoning_content) return delta.reasoning_content;
+  if (typeof delta.reasoning === "string" && delta.reasoning) return delta.reasoning;
+  const details = delta.reasoning_details;
+  if (Array.isArray(details)) return details.map(d => (typeof d === "string" ? d : d?.text || d?.content || "")).join("");
+  return "";
+}
+
+// ─── 照抄 9Router: openaiToClaudeResponse (流式) ────────────────────────────
+// 来源: 9router/open-sse/translator/response/openai-to-claude.js
+
+function convertFinishReason(reason) {
+  const map = { stop: "end_turn", tool_calls: "tool_use", length: "max_tokens", content_filter: "content_filter" };
+  return map[reason] || reason;
+}
+
+function openaiToClaudeResponse(chunk, state) {
+  if (!chunk || !chunk.choices?.[0]) return null;
+  const results = [];
+  const choice = chunk.choices[0];
+  const delta = choice.delta;
+
+  // Track usage
+  if (chunk.usage && typeof chunk.usage === "object") {
+    const pt = typeof chunk.usage.prompt_tokens === "number" ? chunk.usage.prompt_tokens : 0;
+    const ot = typeof chunk.usage.completion_tokens === "number" ? chunk.usage.completion_tokens : 0;
+    state.usage = { input_tokens: pt, output_tokens: ot };
+  }
+
+  // First chunk - message_start
+  if (!state.messageStartSent) {
+    state.messageStartSent = true;
+    state.messageId = chunk.id?.replace("chatcmpl-", "") || `msg_${Date.now()}`;
+    state.model = chunk.model || "unknown";
+    state.nextBlockIndex = 0;
+    results.push({
+      type: "message_start",
+      message: {
+        id: state.messageId, type: "message", role: "assistant",
+        model: state.model, content: [],
+        stop_reason: null, stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+      },
+    });
+  }
+
+  // Handle reasoning (thinking)
+  const reasoningContent = extractReasoningText(delta);
+  if (reasoningContent) {
+    // Stop text block if running
+    if (state.textBlockStarted) { stopTextBlock(state, results); }
+    if (!state.thinkingBlockStarted) {
+      state.thinkingBlockIndex = state.nextBlockIndex++;
+      state.thinkingBlockStarted = true;
+      results.push({ type: "content_block_start", index: state.thinkingBlockIndex, content_block: { type: "thinking", thinking: "" } });
+    }
+    results.push({ type: "content_block_delta", index: state.thinkingBlockIndex, delta: { type: "thinking_delta", thinking: reasoningContent } });
+  }
+
+  // Handle regular content
+  if (delta?.content) {
+    if (state.thinkingBlockStarted) { stopThinkingBlock(state, results); }
+    if (!state.textBlockStarted) {
+      state.textBlockIndex = state.nextBlockIndex++;
+      state.textBlockStarted = true;
+      state.textBlockClosed = false;
+      results.push({ type: "content_block_start", index: state.textBlockIndex, content_block: { type: "text", text: "" } });
+    }
+    results.push({ type: "content_block_delta", index: state.textBlockIndex, delta: { type: "text_delta", text: delta.content } });
+  }
+
+  // Tool calls
+  if (delta?.tool_calls) {
+    for (const tc of delta.tool_calls) {
+      const idx = tc.index ?? 0;
+      if (tc.id) {
+        stopThinkingBlock(state, results);
+        stopTextBlock(state, results);
+        const toolBlockIndex = state.nextBlockIndex++;
+        state.toolCalls.set(idx, { id: tc.id, name: tc.function?.name || "", blockIndex: toolBlockIndex });
+        results.push({ type: "content_block_start", index: toolBlockIndex, content_block: { type: "tool_use", id: tc.id, name: tc.function?.name || "", input: {} } });
+      }
+      if (tc.function?.arguments) {
+        if (!state.toolArgBuffers) state.toolArgBuffers = new Map();
+        state.toolArgBuffers.set(idx, (state.toolArgBuffers.get(idx) || "") + tc.function.arguments);
+      }
+    }
+  }
+
+  // Finish
+  if (choice.finish_reason) {
+    stopThinkingBlock(state, results);
+    stopTextBlock(state, results);
+    for (const [idx, toolInfo] of state.toolCalls) {
+      const buffered = state.toolArgBuffers?.get(idx);
+      if (buffered) {
+        results.push({ type: "content_block_delta", index: toolInfo.blockIndex, delta: { type: "input_json_delta", partial_json: buffered } });
+      }
+      results.push({ type: "content_block_stop", index: toolInfo.blockIndex });
+    }
+    state.finishReason = choice.finish_reason;
+    const finalUsage = state.usage || { input_tokens: 0, output_tokens: 0 };
+    results.push({ type: "message_delta", delta: { stop_reason: convertFinishReason(choice.finish_reason) }, usage: finalUsage });
+    results.push({ type: "message_stop" });
+  }
+
+  return results.length > 0 ? results : null;
+}
+
+function stopThinkingBlock(state, results) {
+  if (!state.thinkingBlockStarted) return;
+  results.push({ type: "content_block_stop", index: state.thinkingBlockIndex });
+  state.thinkingBlockStarted = false;
+}
+
+function stopTextBlock(state, results) {
+  if (!state.textBlockStarted || state.textBlockClosed) return;
+  state.textBlockClosed = true;
+  results.push({ type: "content_block_stop", index: state.textBlockIndex });
+  state.textBlockStarted = false;
+}
+
+// ─── 照抄 9Router: formatSSE ────────────────────────────────────────────────
+
+function formatSSE(data) {
+  if (data === null || data === undefined) return "data: null\n\n";
+  if (data && data.done) return "data: [DONE]\n\n";
+  // Claude format: events have a type field
+  if (data && data.type) {
+    return `event: ${data.type}\ndata: ${JSON.stringify(data)}\n\n`;
+  }
+  return `data: ${JSON.stringify(data)}\n\n`;
+}
+
+// ─── SSE 行解析 (照抄 9Router parseSSELine) ─────────────────────────────────
+
+function parseSSELine(line) {
+  if (!line) return null;
+  if (line.charCodeAt(0) !== 100) return null; // 'd'
+  const data = line.slice(5).trim();
+  if (data === "[DONE]") return { done: true };
+  try { return JSON.parse(data); } catch { return null; }
+}
+
+// ─── 非流式响应 ──────────────────────────────────────────────────────────────
+
+function openAIToClaudeResponse(resp) {
+  const choice = resp.choices?.[0];
+  if (!choice) return { type: "message", role: "assistant", content: [{ type: "text", text: "" }], model: resp.model || "unknown", stop_reason: "end_turn", stop_sequence: null };
+  const msg = choice.message || {};
+  const blocks = [];
+  const tc = msg.tool_calls;
+  if (msg.reasoning_content || msg.reasoning) blocks.push({ type: "thinking", thinking: msg.reasoning_content || msg.reasoning });
+  if (Array.isArray(tc) && tc.length > 0) {
+    if (msg.content) blocks.push({ type: "text", text: msg.content });
+    for (const t of tc) blocks.push({ type: "tool_use", id: t.id, name: t.function.name, input: safeJson(t.function.arguments) });
+  } else {
+    blocks.push({ type: "text", text: msg.content || "" });
+  }
+  const finishMap = { stop: "end_turn", tool_calls: "tool_use", length: "max_tokens" };
+  const result = { id: resp.id || `msg_${Date.now()}`, type: "message", role: "assistant", content: blocks, model: resp.model || "unknown", stop_reason: finishMap[choice.finish_reason] || choice.finish_reason || "end_turn", stop_sequence: null };
+  if (resp.usage) result.usage = { input_tokens: resp.usage.prompt_tokens || 0, output_tokens: resp.usage.completion_tokens || 0 };
+  return result;
+}
+
+function safeJson(s) { try { return JSON.parse(s); } catch { return s; } }
+
+// ─── HTTP 请求 ───────────────────────────────────────────────────────────────
+
+function fetchOpenCode(path, body, stream) {
+  const data = JSON.stringify(body);
+  return new Promise((resolve, reject) => {
+    const opts = {
+      hostname: OPENCODE_BASE, port: 443, path, method: "POST",
+      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data), Authorization: `Bearer ${AUTH_TOKEN}`, "x-opencode-client": "desktop" },
+    };
+    const req = https.request(opts, (res) => {
+      if (stream) { resolve({ ok: res.statusCode < 400, status: res.statusCode, stream: res }); return; }
+      const chunks = [];
+      res.on("data", c => chunks.push(c));
+      res.on("end", () => resolve({ ok: res.statusCode < 400, status: res.statusCode, body: Buffer.concat(chunks).toString() }));
+    });
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+
+// ─── 路径标准化 ──────────────────────────────────────────────────────────────
+
+function normalizePath(pathname) {
+  const p = pathname.replace(/\/+$/, "");
+  if (p.startsWith("/v1/v1/")) return p.replace("/v1/v1/", "/v1/");
+  if (p === "/v1/v1") return "/v1";
+  return p;
+}
+
+// ─── 服务器 ───────────────────────────────────────────────────────────────────
+
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url, `http://${req.headers.host}`);
+  url.pathname = normalizePath(url.pathname);
+
+  const corsHeaders = { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "GET, POST, OPTIONS", "Access-Control-Allow-Headers": "*" };
+  if (req.method === "OPTIONS") { res.writeHead(204, corsHeaders); res.end(); return; }
+
+  if (req.method === "GET" && url.pathname === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", port: PORT }));
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/v1/models") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ object: "list", data: [{ id: "combo", object: "model", owned_by: "combo" }] }));
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname.startsWith("/v1/models/")) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ id: url.pathname.split("/").pop(), object: "model", owned_by: "combo" }));
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
+    const raw = []; for await (const c of req) raw.push(c);
+    const body = json(Buffer.concat(raw).toString()) || {};
+    let chars = 0;
+    for (const msg of (body.messages || [])) {
+      if (typeof msg.content === "string") chars += msg.content.length;
+      else if (Array.isArray(msg.content)) for (const p of msg.content) { if (p.type === "text" && p.text) chars += p.text.length; }
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ input_tokens: Math.ceil(chars / 4) || 1 }));
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/v1/messages") {
+    const raw = []; for await (const c of req) raw.push(c);
+    const body = json(Buffer.concat(raw).toString());
+    if (!body) { res.writeHead(400); res.end(JSON.stringify({ error: "Invalid JSON" })); return; }
+
+    const openAIReq = claudeToOpenAI(body);
+    const upstream = await fetchOpenCode("/zen/v1/chat/completions", openAIReq, true);
+
+    if (!upstream.ok) {
+      let msg = "Upstream error";
+      try {
+        const chunk = await new Promise(rs => { const t = setTimeout(() => rs(""), 3000); upstream.stream.once("data", d => { clearTimeout(t); rs(d.toString()); }); });
+        msg = json(chunk)?.error?.message || chunk?.slice(0, 200) || msg;
+      } catch {}
+      res.writeHead(upstream.status, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ type: "error", error: { message: msg } }));
+      return;
+    }
+
+    // ─── 照抄 9Router 的流式处理 ─────────────────────────────────────────────
+    // pipeline: 解析 SSE → openaiToClaudeResponse → formatSSE → 写出
+    const state = {
+      messageStartSent: false, messageId: null, model: null,
+      thinkingBlockStarted: false, thinkingBlockIndex: -1,
+      textBlockStarted: false, textBlockIndex: -1, textBlockClosed: false,
+      toolCalls: new Map(), toolArgBuffers: null,
+      nextBlockIndex: 0, finishReason: null, usage: null,
+    };
+
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*",
+    });
+
+    let sseBuffer = "";
+    upstream.stream.setEncoding("utf8");
+
+    upstream.stream.on("data", (chunk) => {
+      sseBuffer += chunk;
+      const lines = sseBuffer.split("\n");
+      sseBuffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        const parsed = parseSSELine(trimmed);
+        if (!parsed || parsed.done) continue;
+
+        // 用 9Router 的 openaiToClaudeResponse 处理这个 chunk
+        const events = openaiToClaudeResponse(parsed, state);
+        if (!events) continue;
+
+        for (const evt of events) {
+          res.write(formatSSE(evt));
+        }
+      }
+    });
+
+    upstream.stream.on("end", () => {
+      res.end();
+    });
+
+    upstream.stream.on("error", () => { res.end(); });
+    return;
+  }
+
+  res.writeHead(404);
+  res.end();
+});
+
+server.listen(PORT, "127.0.0.1", () => {
+  console.log(`
+╔═══════════════════════════════════════════╗
+║    Pan Router  :${PORT}                     ║
+║                                           ║
+║   Claude Code ← Pan Router → OpenCode Free  ║
+╚═══════════════════════════════════════════╝
+  Model: combo → deepseek-v4-flash-free
+  `);
+});