@dondetir/ccmux 0.1.3 → 0.1.4

package/README.md

@@ -70,6 +70,8 @@ Free tier gets `claude-haiku-4.5` only; paid Copilot unlocks sonnet, GPT, and Ge
 | `ccmux login ollama` | Save an Ollama Cloud API key (from ollama.com/settings/keys) |
 | `ccmux logout` | Remove saved tokens (GitHub + Ollama) + VS Code Copilot tokens + stop the proxy. Use `eval "$(ccmux logout)"` to also clear tokens exported in the current shell |
 | `ccmux serve` | Run the proxy in the foreground on `:4141` |
+| `ccmux claude --dangerously-skip-permissions` | Launch Claude Code with `--dangerously-skip-permissions` (aliases: `--dangerously`, `--yolo`). Skips per-action permission prompts — sandbox/VM only |
+| `ccmux claude --debug` | Dump every request + upstream response (auth redacted) to `~/.config/ccmux/debug.log` (also `CCMUX_DEBUG=1`) |
 
 Logs stream to `~/.config/ccmux/proxy.log`. If models vanish, the catalog self-heals on the next request.
 
@@ -86,6 +88,36 @@ Env vars (or `~/.config/ccmux/env`):
 | `USE_NATIVE` | `1` | `1` = native pass-through; `0` = OpenAI translation path |
 | `CLAUDE_CONTEXT_WINDOW` | `200000` | Context window Claude Code assumes (token counts scaled to match) |
 
+## 🐛 Troubleshooting
+
+### GPT-5 / reasoning models show "invalid parameter" and no response
+
+GPT-5 reasoning models (gpt-5.*, served via the Responses API) reject sampling
+parameters — `temperature` and `top_p` — returning an "invalid/unsupported
+parameter" error, so Claude Code renders nothing. ccmux now drops those for
+reasoning models automatically. If a model still errors, find the exact rejected
+field with debug logging:
+
+```bash
+ccmux claude --debug          # or CCMUX_DEBUG=1 ccmux serve
+# then reproduce; inspect ~/.config/ccmux/debug.log
+```
+
+Every inbound Anthropic request, the translated upstream request (Authorization
+redacted), and the full upstream response (or raw SSE frames for streams) are
+appended to `~/.config/ccmux/debug.log` (0600, loopback proxy only). This is the
+authoritative way to see what Copilot rejected.
+
+### Run without permission prompts
+
+```bash
+ccmux claude --dangerously-skip-permissions   # alias: --yolo
+```
+
+This passes `--dangerously-skip-permissions` through to Claude Code, skipping its
+per-action prompts. Only do this inside a sandbox or VM — it lets the agent read,
+write, and execute without asking.
+
 ## 🔧 Development
 
 ```bash

package/bin/ccmux.mjs

@@ -85,6 +85,7 @@ const USAGE = `${hero()}${paint(C.bold, "Usage:")} ccmux <command> [args]
 ${paint(C.cyan, "Commands:")}
   claude [args...]   Start the proxy (if needed) + launch Claude Code through it
   serve              Run the proxy in the foreground on http://127.0.0.1:${PORT}
+  stop               Stop a running background proxy
   login copilot      GitHub device-flow login (saves token, auto-restarts proxy)
   login ollama       Paste (or set OLLAMA_API_KEY) an Ollama Cloud key, validate, auto-restart proxy
   logout             Remove saved tokens (GitHub + Ollama) + VS Code Copilot
@@ -92,6 +93,16 @@ ${paint(C.cyan, "Commands:")}
                      clear exported tokens in the current shell
   help               Show this help
 
+${paint(C.cyan, "Flags (any position):")}
+  --dangerously-skip-permissions
+                     Launch Claude Code with --dangerously-skip-permissions
+                     (aliases: --dangerously, --yolo). Bypasses Claude Code's
+                     per-action permission prompts — only use in a sandbox/VM.
+  --debug            Dump every request + upstream response (auth redacted) to
+                     ~/.config/ccmux/debug.log. Use to diagnose "invalid
+                     parameter" / empty-response errors (e.g. GPT-5 reasoning
+                     models). Also set via CCMUX_DEBUG=1.
+
 ${paint(C.mag, "Environment")} ${paint(C.dim, "(or ~/.config/ccmux/env):")}
   NATIVE_MODEL  Override the model served to Claude Code (default claude-haiku-4.5)
   PORT          Proxy port, localhost only (default ${PORT})
@@ -351,7 +362,29 @@ function logout() {
     warn("ccmux: token(s) are still exported in this shell. Run `eval \"$(ccmux logout)\"` to clear them, then `ccmux login copilot`/`login ollama` to re-auth.");
 }
 
-function runClaude(args) {
+// Pre-scan ccmux-level flags so they work in any position (e.g.
+// `ccmux --dangerously-skip-permissions` or `ccmux claude --debug`). Recognized
+// flags are stripped so they don't reach Claude Code twice; the permission flag
+// is re-injected explicitly to guarantee it is passed through.
+const DANGEROUSLY = new Set([
+  "--dangerously-skip-permissions",
+  "--dangerously-skip-permission",
+  "--dangerously",
+  "--yolo",
+]);
+function extractCcmuxFlags(argv) {
+  let dangerously = false;
+  let debug = false;
+  const rest = [];
+  for (const a of argv) {
+    if (a === "--debug") { debug = true; continue; }
+    if (DANGEROUSLY.has(a)) { dangerously = true; continue; }
+    rest.push(a);
+  }
+  return { dangerously, debug, rest };
+}
+
+function runClaude(args, dangerously = false) {
   const env = {
     ...process.env,
     ANTHROPIC_BASE_URL: BASE,
@@ -360,8 +393,9 @@ function runClaude(args) {
     // aliased as claude-* so they survive Claude Code's discovery filter).
     CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: process.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY ?? "1",
   };
+  const claudeArgs = dangerously ? ["--dangerously-skip-permissions", ...args] : args;
   registerSession();
-  const child = spawn("claude", args, { stdio: "inherit", env });
+  const child = spawn("claude", claudeArgs, { stdio: "inherit", env });
   child.once("close", (code) => {
     deregisterSession();
     process.exit(code ?? 0);
@@ -369,8 +403,10 @@ function runClaude(args) {
 }
 
 async function main() {
-  const cmd = process.argv[2];
-  const rest = process.argv.slice(3);
+  const { dangerously, debug, rest: cleanArgs } = extractCcmuxFlags(process.argv.slice(2));
+  if (debug) process.env.CCMUX_DEBUG = "1"; // startProxy/serve inherit process.env
+  const cmd = cleanArgs[0];
+  const rest = cleanArgs.slice(1);
 
   // Print and exit without starting a proxy (unknown cmds previously fell
   // through to the proxy-up block and booted a stray proxy).
@@ -382,7 +418,11 @@ async function main() {
     console.log(`ccmux v${VERSION}`);
     process.exit(0);
   }
-  const KNOWN = new Set(["claude", undefined, "serve", "login", "logout"]);
+  if (cmd === "stop") {
+    console.error(stopProxy() ? `ccmux: stopped proxy on ${BASE}` : "ccmux: no proxy running");
+    process.exit(0);
+  }
+  const KNOWN = new Set(["claude", undefined, "serve", "stop", "login", "logout"]);
   if (!KNOWN.has(cmd)) {
     console.error(`ccmux: unknown command "${cmd ?? ""}"\n\n${USAGE}`);
     process.exit(1);
@@ -450,7 +490,7 @@ async function main() {
   }
 
   if (cmd === "claude" || cmd === undefined) {
-    runClaude(rest);
+    runClaude(rest, dangerously);
   } else {
     console.error(`usage: ccmux [claude ...] | login [copilot|ollama] | logout | serve`);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dondetir/ccmux",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Run Claude Code on GitHub Copilot's backend, a local Anthropic-to-Copilot proxy",
   "private": false,
   "publishConfig": {

package/src/debug.ts

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_DIR } from "./env.js";
+
+// CCMUX_DEBUG=1 (or `ccmux --debug`) dumps every inbound Anthropic request, the
+// translated upstream request (auth redacted), and the upstream response
+// (status + body, or raw SSE frames for streams) to ~/.config/ccmux/debug.log.
+// The file is 0600 and the proxy is loopback-only, so prompts/code stay local.
+// This is the authoritative way to confirm upstream rejections (e.g. the
+// "invalid parameter" GPT-5 reasoning models return for temperature/top_p).
+export const DEBUG = /^(1|true|yes)$/i.test(process.env.CCMUX_DEBUG ?? "");
+
+const LOG = path.join(CONFIG_DIR, "debug.log");
+
+let ensured = false;
+function ensureLog(): void {
+  if (ensured) return;
+  ensured = true;
+  try {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    try { fs.chmodSync(CONFIG_DIR, 0o700); } catch { /* non-posix */ }
+  } catch { /* best effort */ }
+}
+
+function stamp(): string {
+  return new Date().toISOString();
+}
+
+// Redact bearer tokens so credentials never land in the debug log.
+function redactAuth(h: any): any {
+  if (!h || typeof h !== "object") return h;
+  const out: any = Array.isArray(h) ? [...h] : { ...h };
+  for (const k of Object.keys(out)) {
+    if (/^authorization$/i.test(k))
+      out[k] = String(out[k]).replace(/(Bearer\s+)[^\s]+/i, "$1<redacted>");
+  }
+  return out;
+}
+
+function write(label: string, text: string): void {
+  if (!DEBUG) return;
+  ensureLog();
+  try {
+    fs.appendFileSync(LOG, `[${stamp()}] ${label}\n${text}\n\n`, { mode: 0o600 });
+    try { fs.chmodSync(LOG, 0o600); } catch { /* non-posix */ }
+  } catch {
+    // Debug must never break a request.
+  }
+}
+
+export function debugObj(label: string, obj: unknown): void {
+  if (!DEBUG) return;
+  const text = typeof obj === "string" ? obj : JSON.stringify(obj, null, 2);
+  write(label, text);
+}
+
+export function debugInbound(path: string, body: unknown): void {
+  debugObj(`>>> INBOUND ${path}`, body);
+}
+
+export function debugUpstreamRequest(
+  method: string,
+  url: string,
+  headers: unknown,
+  body: unknown,
+): void {
+  if (!DEBUG) return;
+  write(
+    `>>> UPSTREAM ${method} ${url}`,
+    JSON.stringify({ headers: redactAuth(headers), body }, null, 2),
+  );
+}
+
+export function debugUpstreamResponse(status: number, bodyText: string): void {
+  debugObj(`<<< UPSTREAM status ${status}`, bodyText);
+}
+
+// Tee a response stream so every raw chunk is logged as it flows to the
+// translator. Returns a new ReadableStream that yields the same bytes; the
+// translator reads it exactly like the original upstream body.
+export function debugTeeStream(
+  stream: ReadableStream<Uint8Array>,
+  label: string,
+): ReadableStream<Uint8Array> {
+  if (!DEBUG) return stream;
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  return new ReadableStream<Uint8Array>({
+    async pull(c) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          c.close();
+          return;
+        }
+        try {
+          write(`${label} (stream chunk)`, decoder.decode(value, { stream: true }));
+        } catch { /* ignore */ }
+        c.enqueue(value);
+      } catch (e) {
+        c.error(e as any);
+      }
+    },
+    cancel(reason) {
+      reader.cancel(reason);
+    },
+  });
+}

package/src/index.ts

@@ -38,9 +38,19 @@ import { rewriteNativeStream } from "./native-stream.js";
 import { anthropicToResponses, translateResponsesResponse, ResponsesApiUnsupported } from "./translate-responses.js";
 import { translateResponsesStream } from "./responses-stream.js";
 import { startIdleReaper } from "./sessions.js";
+import { DEBUG, debugInbound, debugUpstreamResponse, debugTeeStream } from "./debug.js";
 
 const app = new Hono();
 
+// Browsers always send Origin on cross-origin requests; CLI clients don't.
+// Rejecting it stops a malicious webpage from spending Copilot quota through
+// the unauthenticated loopback port (no-preflight "simple request" POSTs).
+app.use(async (c, next) => {
+  if (c.req.header("origin"))
+    return c.json({ type: "error", error: { type: "forbidden", message: "browser-origin requests are not allowed" } }, 403);
+  await next();
+});
+
 const NATIVE_ALLOWED = new Set([
   "model", "max_tokens", "messages", "system", "tools", "tool_choice",
   "temperature", "top_p", "top_k", "stop_sequences", "stream", "thinking",
@@ -67,21 +77,41 @@ async function mirrorError(c: Context, up: Response, preRead?: string) {
   return c.json({ type: "error", error: { type, message: text } }, up.status as any);
 }
 
+// Single source of truth for upstream routing. Endpoint choice is catalog-driven
+// (supportedEndpoints), so new Copilot models need no code here — a /responses
+// model routes to Path C, everything else to Path B. Native is the one exception:
+// Copilot exposes no /v1/messages in the catalog, so Claude passthrough is a
+// ccmux opt-in (USE_NATIVE), not a catalog fact. Add a future endpoint here only.
+function route(model: string): "native" | "responses" | "chat" {
+  if (USE_NATIVE && !needsTranslation(model)) return "native";
+  if (needsResponsesApi(model)) return "responses";
+  return "chat";
+}
+
 app.post("/v1/messages", async (c) => {
   const body = await c.req.json();
   // The /model picker may send an aliased id (claude-gpt-4.1); restore the real
   // Copilot id so path selection + scaling use it.
   body.model = unaliasModel(body.model ?? "");
+  debugInbound("/v1/messages", body);
   try {
-    // Path A: native pass-through. GPT/Gemini ids always use the translation path;
-    // Claude goes native when USE_NATIVE is set.
-    if (USE_NATIVE && !needsTranslation(body.model ?? "")) {
+    const path = route(body.model ?? "");
+    // Path A: native pass-through to Vertex Claude (USE_NATIVE).
+    if (path === "native") {
       body.model = resolveModel(body.model ?? "");
       if (body.max_tokens) body.max_tokens = clampMaxTokens(body.model, body.max_tokens);
       // Copilot's native endpoint (Vertex Claude) validates strictly and 400s on
       // unknown fields. Allowlist instead of chasing each new field Claude Code adds.
       for (const k of Object.keys(body))
         if (!NATIVE_ALLOWED.has(k)) delete body[k];
+      // Copilot's schema also lags Claude Code's server-tool types (e.g. a new
+      // "advisor_20260301"); drop anything but custom tools, same as Path B.
+      if (Array.isArray(body.tools)) {
+        const allTools = body.tools;
+        body.tools = allTools.filter((t: any) => !t.type || t.type === "custom");
+        if (body.tools.length !== allTools.length)
+          console.warn(`dropped ${allTools.length - body.tools.length} server tool(s)`);
+      }
       // Rewrite thinking + output_config.effort to what the serving model supports.
       adaptBodyToModel(body);
       await ensureModelPolicy(body.model);
@@ -98,28 +128,37 @@ app.post("/v1/messages", async (c) => {
           adaptBodyToModel(body);
           up = await callCopilotNative(body);
         } else {
+          debugUpstreamResponse(400, txt);
           return c.json({ type: "error", error: { type: "invalid_request_error", message: txt } }, 400);
         }
       }
       if (!up.ok) {
         const txt = await up.text();
+        debugUpstreamResponse(up.status, txt);
         return mirrorError(c, up, txt);
       }
       const factor = contextScale(body.model);
       if (body.stream) {
         c.header("Content-Type", "text/event-stream");
         return stream(c, async (s) => {
-          for await (const evt of rewriteNativeStream(up.body!, factor, () => {}, () => {}))
+          for await (const evt of rewriteNativeStream(
+            debugTeeStream(up.body!, "<<< native stream"),
+            factor,
+            () => {},
+            () => {},
+          ))
             await s.write(evt);
         });
       }
-      const json: any = await up.json();
+      const nativeText = await up.text();
+      debugUpstreamResponse(up.status, nativeText);
+      const json: any = JSON.parse(nativeText);
       scaleUsage(json.usage, factor);
       return c.json(json);
     }
 
-    // Path C: Responses API for models that only expose /responses (gpt-5*, mai-code-1*).
-    if (needsResponsesApi(body.model ?? "")) {
+    // Path C: Responses API for /responses-capable models (gpt-5*, mai-code-1*).
+    if (path === "responses") {
       let responsesPayload: any;
       try {
         responsesPayload = anthropicToResponses(body);
@@ -132,17 +171,25 @@ app.post("/v1/messages", async (c) => {
       const up = await callCopilotResponses(responsesPayload);
       if (!up.ok) {
         const txt = await up.text();
+        debugUpstreamResponse(up.status, txt);
         return mirrorError(c, up, txt);
       }
       const factor = contextScale(responsesPayload.model);
       if (body.stream) {
         c.header("Content-Type", "text/event-stream");
         return stream(c, async (s) => {
-          for await (const evt of translateResponsesStream(up.body!, () => {}, factor, () => {}))
+          for await (const evt of translateResponsesStream(
+            debugTeeStream(up.body!, "<<< responses stream"),
+            () => {},
+            factor,
+            () => {},
+          ))
             await s.write(evt);
         });
       }
-      const res = translateResponsesResponse(await up.json());
+      const respText = await up.text();
+      debugUpstreamResponse(up.status, respText);
+      const res = translateResponsesResponse(JSON.parse(respText));
       scaleUsage(res.usage, factor);
       return c.json(res);
     }
@@ -154,6 +201,7 @@ app.post("/v1/messages", async (c) => {
     const up = await callCopilot(payload, flags, provider);
     if (!up.ok) {
       const txt = await up.text();
+      debugUpstreamResponse(up.status, txt);
       return mirrorError(c, up, txt);
     }
     const factor = contextScale(payload.model);
@@ -161,11 +209,18 @@ app.post("/v1/messages", async (c) => {
     if (body.stream) {
       c.header("Content-Type", "text/event-stream");
       return stream(c, async (s) => {
-        for await (const evt of translateStream(up.body!, () => {}, factor, () => {}))
+        for await (const evt of translateStream(
+          debugTeeStream(up.body!, "<<< chat stream"),
+          () => {},
+          factor,
+          () => {},
+        ))
           await s.write(evt);
       });
     }
-    const res = openAIToAnthropic(await up.json());
+    const chatText = await up.text();
+    debugUpstreamResponse(up.status, chatText);
+    const res = openAIToAnthropic(JSON.parse(chatText));
     scaleUsage(res.usage, factor);
     return c.json(res);
   } catch (e: any) {
@@ -177,6 +232,7 @@ app.post("/v1/messages", async (c) => {
 // Claude Code calls this for context management. Must never 404.
 app.post("/v1/messages/count_tokens", async (c) => {
   const body = await c.req.json();
+  debugInbound("/v1/messages/count_tokens", body);
   // Apply same model resolution as /v1/messages so counts match the serving model.
   body.model = resolveModel(unaliasModel(body.model ?? ""));
   const factor = contextScale(body.model);
@@ -204,10 +260,10 @@ app.get("/v1/models", async (c) => {
     // Mirror upstream errors so proxyUp()'s auth-readiness gate fails correctly.
     if (!res.ok) return mirrorError(c, res);
     data = await res.json();
-    // Self-heal: if the startup catalog fetch failed, repopulate from this live
-    // fetch. Gate on copilotCatalogLoaded(), not map size, because Ollama entries
-    // can pre-fill the map and defeat a size===0 check.
-    if (!copilotCatalogLoaded()) loadCatalog(data);
+    // Refresh the routing catalog on every fetch (idempotent). Copilot adds
+    // models mid-run; without this they'd appear in the picker but misroute
+    // (unaliasModel/route need a modelCatalog entry) until a proxy restart.
+    loadCatalog(data);
   } catch (e) {
     // If Copilot has no credentials but Ollama is configured, serve the Ollama
     // catalog alone so the proxy is usable Ollama-only. If the Copilot catalog
@@ -271,6 +327,7 @@ if (process.argv.includes("--login")) {
     console.log(
       `ccmux on http://127.0.0.1:${PORT} (${USE_NATIVE ? "native" : "translation"} path)`,
     );
+    if (DEBUG) console.log("ccmux: DEBUG on — dumping requests/responses to ~/.config/ccmux/debug.log");
   });
 
   // When started by `ccmux claude` (MANAGED), shut down once all sessions end.

package/src/models.ts

@@ -179,11 +179,12 @@ export function unaliasModel(m: string): string {
   return modelCatalog.has(real) && !real.startsWith("claude-") ? real : m;
 }
 
-// Use /responses ONLY when it is the model's sole endpoint; dual-endpoint and
-// unknown models fall through to Path B safely.
+// Route every /responses-capable model (the gpt-5 reasoning family) to Path C.
+// Even dual-endpoint models like gpt-5.4 reject tools + reasoning_effort on
+// /chat/completions ("use /v1/responses instead"), so /responses is the only
+// path that works for them. Chat-only models (gpt-4o, gemini) fall through.
 export function needsResponsesApi(model: string): boolean {
-  const eps = modelCatalog.get(model)?.supportedEndpoints ?? [];
-  return eps.includes("/responses") && !eps.includes("/chat/completions");
+  return (modelCatalog.get(model)?.supportedEndpoints ?? []).includes("/responses");
 }
 
 export function clampMaxTokens(model: string, requested: number): number {

package/src/responses-stream.ts

@@ -34,12 +34,14 @@ export async function* translateResponsesStream(
   let buf = "";
 
   let nextIndex = 0;
-  const itemIdToIndex = new Map<string, number>(); // item.id -> Anthropic block index
+  // Key by output_index, NOT item.id: Copilot rotates the encrypted item_id on
+  // every event, so added/delta/done never share an id. output_index is stable.
+  const blockByOutputIndex = new Map<number, number>(); // output_index -> Anthropic block index
   let openBlock: number | null = null;
   let stopReason = "end_turn";
   let hadToolUse = false; // true if any function_call item was opened
-  // Tracks which item_ids have emitted at least one delta (for .done no-delta fallback)
-  const emittedDelta = new Set<string>();
+  // Tracks which output_index emitted at least one delta (for .done no-delta fallback)
+  const emittedDelta = new Set<number>();
   let outTokens = 0;
   let inTokens = 0;
 
@@ -89,7 +91,7 @@ export async function* translateResponsesStream(
 
             yield* closeOpen();
             const idx = nextIndex++;
-            itemIdToIndex.set(item.id, idx);
+            blockByOutputIndex.set(ev.output_index, idx);
             openBlock = idx;
 
             if (item.type === "function_call") {
@@ -115,14 +117,14 @@ export async function* translateResponsesStream(
           }
 
           case "response.output_text.delta": {
-            const idx = itemIdToIndex.get(ev.item_id);
+            const idx = blockByOutputIndex.get(ev.output_index);
             if (idx === undefined) break;
             if (openBlock !== idx) {
               yield* closeOpen();
               openBlock = idx;
             }
             if (ev.delta) {
-              emittedDelta.add(ev.item_id);
+              emittedDelta.add(ev.output_index);
               yield sse("content_block_delta", {
                 type: "content_block_delta",
                 index: idx,
@@ -134,8 +136,8 @@ export async function* translateResponsesStream(
 
           case "response.output_text.done": {
             // If no deltas arrived, emit full text now so short payloads are not lost.
-            if (!emittedDelta.has(ev.item_id) && ev.text) {
-              const idx = itemIdToIndex.get(ev.item_id);
+            if (!emittedDelta.has(ev.output_index) && ev.text) {
+              const idx = blockByOutputIndex.get(ev.output_index);
               if (idx !== undefined) {
                 yield sse("content_block_delta", {
                   type: "content_block_delta",
@@ -148,14 +150,14 @@ export async function* translateResponsesStream(
           }
 
           case "response.function_call_arguments.delta": {
-            const idx = itemIdToIndex.get(ev.item_id);
+            const idx = blockByOutputIndex.get(ev.output_index);
             if (idx === undefined) break;
             if (openBlock !== idx) {
               yield* closeOpen();
               openBlock = idx;
             }
             if (ev.delta) {
-              emittedDelta.add(ev.item_id);
+              emittedDelta.add(ev.output_index);
               yield sse("content_block_delta", {
                 type: "content_block_delta",
                 index: idx,
@@ -167,8 +169,8 @@ export async function* translateResponsesStream(
 
           case "response.function_call_arguments.done": {
             // If no deltas arrived, emit full arguments now so short tool calls are not empty.
-            if (!emittedDelta.has(ev.item_id) && ev.arguments) {
-              const idx = itemIdToIndex.get(ev.item_id);
+            if (!emittedDelta.has(ev.output_index) && ev.arguments) {
+              const idx = blockByOutputIndex.get(ev.output_index);
               if (idx !== undefined) {
                 yield sse("content_block_delta", {
                   type: "content_block_delta",
@@ -181,8 +183,7 @@ export async function* translateResponsesStream(
           }
 
           case "response.output_item.done": {
-            const item = ev.item;
-            const idx = item ? itemIdToIndex.get(item.id) : undefined;
+            const idx = blockByOutputIndex.get(ev.output_index);
             if (idx !== undefined) {
               yield sse("content_block_stop", { type: "content_block_stop", index: idx });
               if (openBlock === idx) openBlock = null;

package/src/token.ts

@@ -71,8 +71,15 @@ function persistToken(gh: string): void {
     fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
     try { fs.chmodSync(CONFIG_DIR, 0o700); } catch { /* fs ignores mode */ }
     const p = path.join(CONFIG_DIR, "env");
-    fs.appendFileSync(p, `\nGH_TOKEN=${gh}\n`, { mode: 0o600 });
-    // appendFileSync mode only applies on creation; chmod enforces it on existing files.
+    // Rewrite rather than append so re-logins replace the old token instead of
+    // accumulating stale plaintext tokens. Other keys (OLLAMA_API_KEY) are kept.
+    let kept: string[] = [];
+    try {
+      kept = fs.readFileSync(p, "utf8").split("\n").filter((l) => l.trim() && !/^GH_TOKEN=/.test(l));
+    } catch { /* file doesn't exist yet */ }
+    kept.push(`GH_TOKEN=${gh}`);
+    fs.writeFileSync(p, kept.join("\n") + "\n", { mode: 0o600 });
+    // writeFileSync mode only applies on creation; chmod enforces it on existing files.
     try { fs.chmodSync(p, 0o600); } catch { /* non-posix fs */ }
     console.log(`ccmux: saved GH_TOKEN to ${p} (one-time login)`);
   } catch {

package/src/translate-request.ts

@@ -1,4 +1,4 @@
-import { mapModel, clampMaxTokens, resolveEffort } from "./models.js";
+import { mapModel, clampMaxTokens, resolveEffort, modelCatalog } from "./models.js";
 import type { AnthropicBody, AnthropicMessage, TranslateFlags } from "./types.js";
 
 // Collapse an Anthropic system prompt (string | text-block[]) to a plain string.
@@ -94,12 +94,24 @@ export function anthropicToOpenAI(body: AnthropicBody): { payload: any; flags: T
   flags.agent = isAgentTurn(body.messages);
 
   const model = mapModel(body.model ?? "");
+  // Reasoning models (gpt-5*, o-series) reject `max_tokens` and sampling params
+  // on /chat/completions ("Unsupported parameter: use max_completion_tokens").
+  // Send max_completion_tokens and drop temperature/top_p for them so a
+  // reasoning model that falls through to Path B still works.
+  const chatEntry = modelCatalog.get(model);
+  const isReasoning = !!(
+    chatEntry &&
+    ((chatEntry.efforts?.length ?? 0) > 0 || chatEntry.adaptiveThinking || chatEntry.maxThinking)
+  );
   const payload: any = {
     model,
     messages,
-    max_tokens: clampMaxTokens(model, body.max_tokens ?? 4096),
+    [isReasoning ? "max_completion_tokens" : "max_tokens"]: clampMaxTokens(
+      model,
+      body.max_tokens ?? 4096,
+    ),
   };
-  if (body.temperature !== undefined) payload.temperature = body.temperature;
+  if (body.temperature !== undefined && !isReasoning) payload.temperature = body.temperature;
   if (body.stream) {
     payload.stream = true;
     payload.stream_options = { include_usage: true }; // omitting this leaves output_tokens at 0

package/src/translate-responses.ts

@@ -1,4 +1,4 @@
-import { mapModel, clampMaxTokens, resolveEffort } from "./models.js";
+import { mapModel, clampMaxTokens, resolveEffort, modelCatalog } from "./models.js";
 import { extractSystemText } from "./translate-request.js";
 import type { AnthropicBody } from "./types.js";
 
@@ -130,8 +130,17 @@ export function anthropicToResponses(body: AnthropicBody): any {
 
   if (systemText) payload.instructions = systemText;
   if (body.stream) payload.stream = true;
-  if (body.temperature !== undefined) payload.temperature = body.temperature;
-  if ((body as any).top_p !== undefined) payload.top_p = (body as any).top_p;
+  // GPT-5 reasoning models reject temperature/top_p on the Responses API
+  // ("Unsupported parameter"/"invalid parameter"), which surfaces in Claude
+  // Code as an error with no assistant response rendered. Drop them for
+  // reasoning models; the Responses API doesn't honor sampling for reasoning.
+  const rEntry = modelCatalog.get(model);
+  const isReasoning = !!(
+    rEntry &&
+    ((rEntry.efforts?.length ?? 0) > 0 || rEntry.adaptiveThinking || rEntry.maxThinking)
+  );
+  if (body.temperature !== undefined && !isReasoning) payload.temperature = body.temperature;
+  if ((body as any).top_p !== undefined && !isReasoning) payload.top_p = (body as any).top_p;
 
   // Tool schema is flat (no function wrapper); parameters renamed from input_schema.
   const allTools = body.tools ?? [];

package/src/upstream.ts

@@ -1,5 +1,6 @@
 import "./env.js"; // load .env BEFORE any env reads below
 import { getCopilotToken } from "./token.js";
+import { debugUpstreamRequest } from "./debug.js";
 import type { TranslateFlags } from "./types.js";
 
 export const PORT = Number(process.env.PORT ?? 4141);
@@ -43,9 +44,12 @@ export async function callCopilot(
   if (provider === "ollama") {
     const body = openaiBody as any;
     const wire = { ...body, model: String(body.model ?? "").replace(/^ollama\//, "") };
-    return fetch(`${OLLAMA_BASE}/chat/completions`, {
+    const url = `${OLLAMA_BASE}/chat/completions`;
+    const headers = { "Content-Type": "application/json", Authorization: `Bearer ${ollamaKey()}` };
+    debugUpstreamRequest("POST", url, headers, wire);
+    return fetch(url, {
       method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${ollamaKey()}` },
+      headers,
       body: JSON.stringify(wire),
     });
   }
@@ -53,7 +57,9 @@ export async function callCopilot(
   const headers: Record<string, string> = { ...COPILOT_HEADERS, Authorization: `Bearer ${bearer}` };
   headers["X-Initiator"] = flags.agent ? "agent" : "user";
   if (flags.vision) headers["Copilot-Vision-Request"] = "true";
-  return fetch(`${COPILOT_BASE}/chat/completions`, {
+  const url = `${COPILOT_BASE}/chat/completions`;
+  debugUpstreamRequest("POST", url, headers, openaiBody);
+  return fetch(url, {
     method: "POST",
     headers,
     body: JSON.stringify(openaiBody),
@@ -63,13 +69,16 @@ export async function callCopilot(
 // Path A: forward the Anthropic body unchanged to Copilot's native endpoint.
 export async function callCopilotNative(anthropicBody: unknown): Promise<Response> {
   const bearer = await getCopilotToken();
-  return fetch(`${COPILOT_BASE}/v1/messages`, {
+  const headers = {
+    ...COPILOT_HEADERS,
+    Authorization: `Bearer ${bearer}`,
+    "anthropic-version": "2023-06-01",
+  };
+  const url = `${COPILOT_BASE}/v1/messages`;
+  debugUpstreamRequest("POST", url, headers, anthropicBody);
+  return fetch(url, {
     method: "POST",
-    headers: {
-      ...COPILOT_HEADERS,
-      Authorization: `Bearer ${bearer}`,
-      "anthropic-version": "2023-06-01",
-    },
+    headers,
     body: JSON.stringify(anthropicBody),
   });
 }
@@ -78,9 +87,12 @@ export async function callCopilotNative(anthropicBody: unknown): Promise<Respons
 // model_not_supported on free tier, not 404.
 export async function callCopilotResponses(responsesBody: unknown): Promise<Response> {
   const bearer = await getCopilotToken();
-  return fetch(`${COPILOT_BASE}/responses`, {
+  const headers = { ...COPILOT_HEADERS, Authorization: `Bearer ${bearer}` };
+  const url = `${COPILOT_BASE}/responses`;
+  debugUpstreamRequest("POST", url, headers, responsesBody);
+  return fetch(url, {
     method: "POST",
-    headers: { ...COPILOT_HEADERS, Authorization: `Bearer ${bearer}` },
+    headers,
     body: JSON.stringify(responsesBody),
   });
 }
@@ -90,13 +102,16 @@ export async function callCopilotResponses(responsesBody: unknown): Promise<Resp
 export async function countTokensUpstream(anthropicBody: unknown): Promise<number | null> {
   try {
     const bearer = await getCopilotToken();
-    const res = await fetch(`${COPILOT_BASE}/v1/messages/count_tokens`, {
+    const headers = {
+      ...COPILOT_HEADERS,
+      Authorization: `Bearer ${bearer}`,
+      "anthropic-version": "2023-06-01",
+    };
+    const url = `${COPILOT_BASE}/v1/messages/count_tokens`;
+    debugUpstreamRequest("POST", url, headers, anthropicBody);
+    const res = await fetch(url, {
       method: "POST",
-      headers: {
-        ...COPILOT_HEADERS,
-        Authorization: `Bearer ${bearer}`,
-        "anthropic-version": "2023-06-01",
-      },
+      headers,
       body: JSON.stringify(anthropicBody),
     });
     if (res.ok) return ((await res.json()) as any).input_tokens ?? null;