@elvatis_com/openclaw-cli-bridge-elvatis 1.3.4 → 1.5.0

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "1.3.4",
+  "version": "1.5.0",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
   "providers": [
     "openai-codex"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "1.3.4",
+  "version": "1.5.0",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/claude-browser.ts

@@ -42,6 +42,8 @@ const MODEL_MAP: Record<string, string> = {
   "claude-sonnet-4-5":   "claude-sonnet-4-5",
   "claude-sonnet-4-6":   "claude-sonnet-4-6",
   "claude-opus-4-5":     "claude-opus-4-5",
+  "claude-opus-4-6":     "claude-opus-4-6",
+  "claude-haiku-4-5":    "claude-haiku-4-5",
 };
 
 function resolveModel(m?: string): string {

package/src/proxy-server.ts

@@ -13,9 +13,7 @@ import { randomBytes } from "node:crypto";
 import { type ChatMessage, routeToCliRunner } from "./cli-runner.js";
 import { scheduleTokenRefresh, setAuthLogger, stopTokenRefresh } from "./claude-auth.js";
 import { grokComplete, grokCompleteStream, type ChatMessage as GrokChatMessage } from "./grok-client.js";
-import { claudeComplete, claudeCompleteStream, type ChatMessage as ClaudeBrowserChatMessage } from "./claude-browser.js";
 import { geminiComplete, geminiCompleteStream, type ChatMessage as GeminiBrowserChatMessage } from "./gemini-browser.js";
-import { chatgptComplete, chatgptCompleteStream, type ChatMessage as ChatGPTBrowserChatMessage } from "./chatgpt-browser.js";
 import type { BrowserContext } from "playwright";
 
 export type GrokCompleteOptions = Parameters<typeof grokComplete>[1];
@@ -36,14 +34,6 @@ export interface ProxyServerOptions {
   _grokComplete?: typeof grokComplete;
   /** Override for testing — replaces grokCompleteStream */
   _grokCompleteStream?: typeof grokCompleteStream;
-  /** Returns the current authenticated Claude BrowserContext (null if not logged in) */
-  getClaudeContext?: () => BrowserContext | null;
-  /** Async lazy connect — called when getClaudeContext returns null */
-  connectClaudeContext?: () => Promise<BrowserContext | null>;
-  /** Override for testing — replaces claudeComplete */
-  _claudeComplete?: typeof claudeComplete;
-  /** Override for testing — replaces claudeCompleteStream */
-  _claudeCompleteStream?: typeof claudeCompleteStream;
   /** Returns the current authenticated Gemini BrowserContext (null if not logged in) */
   getGeminiContext?: () => BrowserContext | null;
   /** Async lazy connect — called when getGeminiContext returns null */
@@ -52,14 +42,6 @@ export interface ProxyServerOptions {
   _geminiComplete?: typeof geminiComplete;
   /** Override for testing — replaces geminiCompleteStream */
   _geminiCompleteStream?: typeof geminiCompleteStream;
-  /** Returns the current authenticated ChatGPT BrowserContext */
-  getChatGPTContext?: () => BrowserContext | null;
-  /** Async lazy connect for ChatGPT */
-  connectChatGPTContext?: () => Promise<BrowserContext | null>;
-  /** Override for testing */
-  _chatgptComplete?: typeof chatgptComplete;
-  /** Override for testing */
-  _chatgptCompleteStream?: typeof chatgptCompleteStream;
 }
 
 /** Available CLI bridge models for GET /v1/models */
@@ -77,21 +59,11 @@ export const CLI_MODELS = [
   { id: "web-grok/grok-3-fast",      name: "Grok 3 Fast (web session)",      contextWindow: 131_072, maxTokens: 131_072 },
   { id: "web-grok/grok-3-mini",      name: "Grok 3 Mini (web session)",      contextWindow: 131_072, maxTokens: 131_072 },
   { id: "web-grok/grok-3-mini-fast", name: "Grok 3 Mini Fast (web session)", contextWindow: 131_072, maxTokens: 131_072 },
-  // Claude web-session models (requires /claude-login)
-  { id: "web-claude/claude-sonnet",   name: "Claude Sonnet (web session)",   contextWindow: 200_000, maxTokens: 8192 },
-  { id: "web-claude/claude-opus",     name: "Claude Opus (web session)",     contextWindow: 200_000, maxTokens: 8192 },
-  { id: "web-claude/claude-haiku",    name: "Claude Haiku (web session)",    contextWindow: 200_000, maxTokens: 8192 },
   // Gemini web-session models (requires /gemini-login)
   { id: "web-gemini/gemini-2-5-pro",   name: "Gemini 2.5 Pro (web session)",   contextWindow: 1_000_000, maxTokens: 8192 },
   { id: "web-gemini/gemini-2-5-flash", name: "Gemini 2.5 Flash (web session)", contextWindow: 1_000_000, maxTokens: 8192 },
   { id: "web-gemini/gemini-3-pro",     name: "Gemini 3 Pro (web session)",     contextWindow: 1_000_000, maxTokens: 8192 },
   { id: "web-gemini/gemini-3-flash",   name: "Gemini 3 Flash (web session)",   contextWindow: 1_000_000, maxTokens: 8192 },
-  // ChatGPT web-session models (requires /chatgpt-login)
-  { id: "web-chatgpt/gpt-4o",       name: "GPT-4o (web session)",       contextWindow: 128_000, maxTokens: 16_384 },
-  { id: "web-chatgpt/gpt-4o-mini",  name: "GPT-4o Mini (web session)",  contextWindow: 128_000, maxTokens: 16_384 },
-  { id: "web-chatgpt/gpt-o3",       name: "o3 (web session)",           contextWindow: 200_000, maxTokens: 100_000 },
-  { id: "web-chatgpt/gpt-o4-mini",  name: "o4-mini (web session)",      contextWindow: 200_000, maxTokens: 100_000 },
-  { id: "web-chatgpt/gpt-5",        name: "GPT-5 (web session)",        contextWindow: 1_000_000, maxTokens: 32_768 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -263,55 +235,6 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
-    // ── Claude web-session routing ────────────────────────────────────────────
-    if (model.startsWith("web-claude/")) {
-      let claudeCtx = opts.getClaudeContext?.() ?? null;
-      if (!claudeCtx && opts.connectClaudeContext) {
-        claudeCtx = await opts.connectClaudeContext();
-      }
-      if (!claudeCtx) {
-        res.writeHead(503, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: { message: "No active claude.ai session. Use /claude-login to authenticate.", code: "no_claude_session" } }));
-        return;
-      }
-      const timeoutMs = opts.timeoutMs ?? 120_000;
-      const claudeMessages = messages as ClaudeBrowserChatMessage[];
-      const doClaudeComplete = opts._claudeComplete ?? claudeComplete;
-      const doClaudeCompleteStream = opts._claudeCompleteStream ?? claudeCompleteStream;
-      try {
-        if (stream) {
-          res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", ...corsHeaders() });
-          sendSseChunk(res, { id, created, model, delta: { role: "assistant" }, finish_reason: null });
-          const result = await doClaudeCompleteStream(
-            claudeCtx,
-            { messages: claudeMessages, model, timeoutMs },
-            (token) => sendSseChunk(res, { id, created, model, delta: { content: token }, finish_reason: null }),
-            opts.log
-          );
-          sendSseChunk(res, { id, created, model, delta: {}, finish_reason: result.finishReason });
-          res.write("data: [DONE]\n\n");
-          res.end();
-        } else {
-          const result = await doClaudeComplete(claudeCtx, { messages: claudeMessages, model, timeoutMs }, opts.log);
-          res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
-          res.end(JSON.stringify({
-            id, object: "chat.completion", created, model,
-            choices: [{ index: 0, message: { role: "assistant", content: result.content }, finish_reason: result.finishReason }],
-            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-          }));
-        }
-      } catch (err) {
-        const msg = (err as Error).message;
-        opts.warn(`[cli-bridge] Claude browser error for ${model}: ${msg}`);
-        if (!res.headersSent) {
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: { message: msg, type: "claude_browser_error" } }));
-        }
-      }
-      return;
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-
     // ── Gemini web-session routing ────────────────────────────────────────────
     if (model.startsWith("web-gemini/")) {
       let geminiCtx = opts.getGeminiContext?.() ?? null;
@@ -361,43 +284,6 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
-    // ── ChatGPT web-session routing ───────────────────────────────────────────
-    if (model.startsWith("web-chatgpt/")) {
-      let chatgptCtx = opts.getChatGPTContext?.() ?? null;
-      if (!chatgptCtx && opts.connectChatGPTContext) chatgptCtx = await opts.connectChatGPTContext();
-      if (!chatgptCtx) {
-        res.writeHead(503, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: { message: "No active chatgpt.com session. Use /chatgpt-login to authenticate.", code: "no_chatgpt_session" } }));
-        return;
-      }
-      const timeoutMs = opts.timeoutMs ?? 120_000;
-      const msgs = messages as ChatGPTBrowserChatMessage[];
-      const doComplete = opts._chatgptComplete ?? chatgptComplete;
-      const doStream = opts._chatgptCompleteStream ?? chatgptCompleteStream;
-      try {
-        if (stream) {
-          res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", ...corsHeaders() });
-          sendSseChunk(res, { id, created, model, delta: { role: "assistant" }, finish_reason: null });
-          const result = await doStream(chatgptCtx, { messages: msgs, model, timeoutMs },
-            (token) => sendSseChunk(res, { id, created, model, delta: { content: token }, finish_reason: null }), opts.log);
-          sendSseChunk(res, { id, created, model, delta: {}, finish_reason: result.finishReason });
-          res.write("data: [DONE]\n\n"); res.end();
-        } else {
-          const result = await doComplete(chatgptCtx, { messages: msgs, model, timeoutMs }, opts.log);
-          res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
-          res.end(JSON.stringify({ id, object: "chat.completion", created, model,
-            choices: [{ index: 0, message: { role: "assistant", content: result.content }, finish_reason: result.finishReason }],
-            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } }));
-        }
-      } catch (err) {
-        const msg = (err as Error).message;
-        opts.warn(`[cli-bridge] ChatGPT browser error for ${model}: ${msg}`);
-        if (!res.headersSent) { res.writeHead(500, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: { message: msg, type: "chatgpt_browser_error" } })); }
-      }
-      return;
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-
     // ── CLI runner routing (Gemini / Claude Code) ─────────────────────────────
     let content: string;
     try {

package/test/chatgpt-proxy.test.ts

@@ -1,107 +0,0 @@
-/**
- * test/chatgpt-proxy.test.ts
- *
- * Tests for ChatGPT web-session routing in the cli-bridge proxy.
- * Uses _chatgptComplete/_chatgptCompleteStream DI overrides (no real browser).
- */
-
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import http from "node:http";
-import type { AddressInfo } from "node:net";
-import { startProxyServer, CLI_MODELS } from "../src/proxy-server.js";
-import type { BrowserContext } from "playwright";
-
-type Opts = { messages: { role: string; content: string }[]; model?: string; timeoutMs?: number };
-type Result = { content: string; model: string; finishReason: string };
-
-const stubComplete = vi.fn(async (_ctx: BrowserContext, opts: Opts, _log: (m: string) => void): Promise<Result> => ({
-  content: `chatgpt mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
-  model: opts.model ?? "web-chatgpt/gpt-4o", finishReason: "stop",
-}));
-const stubStream = vi.fn(async (_ctx: BrowserContext, opts: Opts, onToken: (t: string) => void, _log: (m: string) => void): Promise<Result> => {
-  ["chatgpt ", "stream ", "mock"].forEach(t => onToken(t));
-  return { content: "chatgpt stream mock", model: opts.model ?? "web-chatgpt/gpt-4o", finishReason: "stop" };
-});
-
-async function post(url: string, body: unknown): Promise<{ status: number; body: unknown }> {
-  return new Promise((res, rej) => {
-    const d = JSON.stringify(body); const u = new URL(url);
-    const r = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
-      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(d) } },
-      resp => { let raw = ""; resp.on("data", c => raw += c); resp.on("end", () => { try { res({ status: resp.statusCode ?? 0, body: JSON.parse(raw) }); } catch { res({ status: resp.statusCode ?? 0, body: raw }); } }); });
-    r.on("error", rej); r.write(d); r.end();
-  });
-}
-async function get(url: string): Promise<{ status: number; body: unknown }> {
-  return new Promise((res, rej) => {
-    const u = new URL(url);
-    const r = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "GET" },
-      resp => { let raw = ""; resp.on("data", c => raw += c); resp.on("end", () => { try { res({ status: resp.statusCode ?? 0, body: JSON.parse(raw) }); } catch { res({ status: resp.statusCode ?? 0, body: raw }); } }); });
-    r.on("error", rej); r.end();
-  });
-}
-
-const fakeCtx = {} as BrowserContext;
-let server: http.Server;
-let baseUrl: string;
-
-beforeAll(async () => {
-  server = await startProxyServer({
-    port: 0, log: () => {}, warn: () => {},
-    getChatGPTContext: () => fakeCtx,
-    // @ts-expect-error stub
-    _chatgptComplete: stubComplete,
-    // @ts-expect-error stub
-    _chatgptCompleteStream: stubStream,
-  });
-  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
-});
-afterAll(() => server.close());
-
-describe("ChatGPT routing — model list", () => {
-  it("includes web-chatgpt/* models in /v1/models", async () => {
-    const res = await get(`${baseUrl}/v1/models`);
-    expect(res.status).toBe(200);
-    const ids = (res.body as { data: { id: string }[] }).data.map(m => m.id);
-    expect(ids).toContain("web-chatgpt/gpt-4o");
-    expect(ids).toContain("web-chatgpt/gpt-5");
-  });
-  it("CLI_MODELS includes web-chatgpt/*", () => {
-    expect(CLI_MODELS.some(m => m.id.startsWith("web-chatgpt/"))).toBe(true);
-  });
-});
-
-describe("ChatGPT routing — non-streaming", () => {
-  it("returns assistant message for web-chatgpt/gpt-4o", async () => {
-    const res = await post(`${baseUrl}/v1/chat/completions`, {
-      model: "web-chatgpt/gpt-4o", messages: [{ role: "user", content: "hello chatgpt" }], stream: false,
-    });
-    expect(res.status).toBe(200);
-    expect((res.body as any).choices[0].message.content).toContain("chatgpt mock");
-  });
-  it("passes correct model to stub", async () => {
-    stubComplete.mockClear();
-    await post(`${baseUrl}/v1/chat/completions`, { model: "web-chatgpt/gpt-o3", messages: [{ role: "user", content: "x" }] });
-    expect(stubComplete).toHaveBeenCalledOnce();
-    expect(stubComplete.mock.calls[0][1].model).toBe("web-chatgpt/gpt-o3");
-  });
-  it("returns 503 when no context", async () => {
-    const s = await startProxyServer({ port: 0, log: () => {}, warn: () => {}, getChatGPTContext: () => null });
-    const u = `http://127.0.0.1:${(s.address() as AddressInfo).port}`;
-    const r = await post(`${u}/v1/chat/completions`, { model: "web-chatgpt/gpt-4o", messages: [{ role: "user", content: "hi" }] });
-    expect(r.status).toBe(503);
-    expect((r.body as any).error.code).toBe("no_chatgpt_session");
-    s.close();
-  });
-});
-
-describe("ChatGPT routing — streaming", () => {
-  it("returns SSE stream with [DONE]", () => new Promise<void>((resolve, reject) => {
-    const body = JSON.stringify({ model: "web-chatgpt/gpt-4o", messages: [{ role: "user", content: "s" }], stream: true });
-    const u = new URL(`${baseUrl}/v1/chat/completions`);
-    const r = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
-      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
-      resp => { let raw = ""; resp.on("data", c => raw += c); resp.on("end", () => { expect(raw).toContain("[DONE]"); resolve(); }); });
-    r.on("error", reject); r.write(body); r.end();
-  }));
-});

package/test/claude-proxy.test.ts

@@ -1,235 +0,0 @@
-/**
- * test/claude-proxy.test.ts
- *
- * Tests for Claude web-session routing in the cli-bridge proxy.
- * Uses _claudeComplete/_claudeCompleteStream DI overrides (no real browser).
- */
-
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import http from "node:http";
-import type { AddressInfo } from "node:net";
-import { startProxyServer, CLI_MODELS } from "../src/proxy-server.js";
-import type { BrowserContext } from "playwright";
-
-// ── Stub types matching claude-browser exports ────────────────────────────────
-type ClaudeCompleteOptions = {
-  messages: { role: string; content: string }[];
-  model?: string;
-  timeoutMs?: number;
-};
-type ClaudeCompleteResult = { content: string; model: string; finishReason: string };
-
-// ── Stubs ─────────────────────────────────────────────────────────────────────
-const stubClaudeComplete = vi.fn(async (
-  _ctx: BrowserContext,
-  opts: ClaudeCompleteOptions,
-  _log: (msg: string) => void
-): Promise<ClaudeCompleteResult> => ({
-  content: `claude mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
-  model: opts.model ?? "web-claude/claude-sonnet",
-  finishReason: "stop",
-}));
-
-const stubClaudeCompleteStream = vi.fn(async (
-  _ctx: BrowserContext,
-  opts: ClaudeCompleteOptions,
-  onToken: (t: string) => void,
-  _log: (msg: string) => void
-): Promise<ClaudeCompleteResult> => {
-  const tokens = ["claude ", "stream ", "mock"];
-  for (const t of tokens) onToken(t);
-  return { content: tokens.join(""), model: opts.model ?? "web-claude/claude-sonnet", finishReason: "stop" };
-});
-
-// ── HTTP helper ───────────────────────────────────────────────────────────────
-async function httpPost(
-  url: string,
-  body: unknown,
-  headers: Record<string, string> = {}
-): Promise<{ status: number; body: unknown }> {
-  return new Promise((resolve, reject) => {
-    const data = JSON.stringify(body);
-    const urlObj = new URL(url);
-    const req = http.request(
-      { hostname: urlObj.hostname, port: Number(urlObj.port), path: urlObj.pathname, method: "POST",
-        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data), ...headers } },
-      (res) => {
-        let raw = "";
-        res.on("data", (c) => (raw += c));
-        res.on("end", () => {
-          try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); }
-          catch { resolve({ status: res.statusCode ?? 0, body: raw }); }
-        });
-      }
-    );
-    req.on("error", reject);
-    req.write(data);
-    req.end();
-  });
-}
-
-async function httpGet(url: string): Promise<{ status: number; body: unknown }> {
-  return new Promise((resolve, reject) => {
-    const urlObj = new URL(url);
-    const req = http.request(
-      { hostname: urlObj.hostname, port: Number(urlObj.port), path: urlObj.pathname, method: "GET" },
-      (res) => {
-        let raw = "";
-        res.on("data", (c) => (raw += c));
-        res.on("end", () => {
-          try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); }
-          catch { resolve({ status: res.statusCode ?? 0, body: raw }); }
-        });
-      }
-    );
-    req.on("error", reject);
-    req.end();
-  });
-}
-
-// ── Fake context ──────────────────────────────────────────────────────────────
-const fakeClaudeCtx = {} as BrowserContext;
-
-// ── Server setup ──────────────────────────────────────────────────────────────
-let server: http.Server;
-let baseUrl: string;
-
-beforeAll(async () => {
-  server = await startProxyServer({
-    port: 0,
-    log: () => {},
-    warn: () => {},
-    getClaudeContext: () => fakeClaudeCtx,
-    // @ts-expect-error — stub types close enough for testing
-    _claudeComplete: stubClaudeComplete,
-    // @ts-expect-error — stub types close enough for testing
-    _claudeCompleteStream: stubClaudeCompleteStream,
-  });
-  const addr = server.address() as AddressInfo;
-  baseUrl = `http://127.0.0.1:${addr.port}`;
-});
-
-afterAll(() => server.close());
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-describe("Claude web-session routing — model list", () => {
-  it("includes web-claude/* models in /v1/models", async () => {
-    const res = await httpGet(`${baseUrl}/v1/models`);
-    expect(res.status).toBe(200);
-    const data = res.body as { data: { id: string }[] };
-    const ids = data.data.map((m) => m.id);
-    expect(ids).toContain("web-claude/claude-sonnet");
-    expect(ids).toContain("web-claude/claude-opus");
-    expect(ids).toContain("web-claude/claude-haiku");
-  });
-
-  it("web-claude/* models listed in CLI_MODELS", () => {
-    const ids = CLI_MODELS.map((m) => m.id);
-    expect(ids.some((id) => id.startsWith("web-claude/"))).toBe(true);
-  });
-});
-
-describe("Claude web-session routing — non-streaming", () => {
-  it("returns assistant message for web-claude/claude-sonnet", async () => {
-    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
-      model: "web-claude/claude-sonnet",
-      messages: [{ role: "user", content: "hello" }],
-      stream: false,
-    });
-    expect(res.status).toBe(200);
-    const body = res.body as { choices: { message: { content: string } }[] };
-    expect(body.choices[0].message.content).toContain("claude mock");
-    expect(body.choices[0].message.content).toContain("hello");
-  });
-
-  it("calls stubClaudeComplete with correct model and messages", async () => {
-    stubClaudeComplete.mockClear();
-    await httpPost(`${baseUrl}/v1/chat/completions`, {
-      model: "web-claude/claude-opus",
-      messages: [{ role: "user", content: "test" }],
-      stream: false,
-    });
-    expect(stubClaudeComplete).toHaveBeenCalledOnce();
-    const call = stubClaudeComplete.mock.calls[0];
-    expect(call[0]).toBe(fakeClaudeCtx);
-    expect(call[1].model).toBe("web-claude/claude-opus");
-  });
-
-  it("returns 503 when no claude context is available", async () => {
-    const noCtxServer = await startProxyServer({
-      port: 0, log: () => {}, warn: () => {},
-      getClaudeContext: () => null,
-    });
-    const addr = noCtxServer.address() as AddressInfo;
-    const noCtxUrl = `http://127.0.0.1:${addr.port}`;
-    const res = await httpPost(`${noCtxUrl}/v1/chat/completions`, {
-      model: "web-claude/claude-sonnet",
-      messages: [{ role: "user", content: "hi" }],
-    });
-    expect(res.status).toBe(503);
-    const body = res.body as { error: { code: string } };
-    expect(body.error.code).toBe("no_claude_session");
-    noCtxServer.close();
-  });
-});
-
-describe("Claude web-session routing — streaming", () => {
-  it("returns SSE stream for web-claude/claude-sonnet", async () => {
-    return new Promise<void>((resolve, reject) => {
-      const body = JSON.stringify({
-        model: "web-claude/claude-sonnet",
-        messages: [{ role: "user", content: "stream test" }],
-        stream: true,
-      });
-      const urlObj = new URL(`${baseUrl}/v1/chat/completions`);
-      const req = http.request(
-        { hostname: urlObj.hostname, port: Number(urlObj.port), path: urlObj.pathname, method: "POST",
-          headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
-        (res) => {
-          expect(res.statusCode).toBe(200);
-          expect(res.headers["content-type"]).toContain("text/event-stream");
-          let raw = "";
-          res.on("data", (c) => (raw += c));
-          res.on("end", () => {
-            expect(raw).toContain("data:");
-            expect(raw).toContain("[DONE]");
-            resolve();
-          });
-        }
-      );
-      req.on("error", reject);
-      req.write(body);
-      req.end();
-    });
-  });
-
-  it("streams tokens from stub", async () => {
-    stubClaudeCompleteStream.mockClear();
-    return new Promise<void>((resolve, reject) => {
-      const body = JSON.stringify({
-        model: "web-claude/claude-haiku",
-        messages: [{ role: "user", content: "tokens" }],
-        stream: true,
-      });
-      const urlObj = new URL(`${baseUrl}/v1/chat/completions`);
-      const req = http.request(
-        { hostname: urlObj.hostname, port: Number(urlObj.port), path: urlObj.pathname, method: "POST",
-          headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
-        (res) => {
-          let raw = "";
-          res.on("data", (c) => (raw += c));
-          res.on("end", () => {
-            expect(stubClaudeCompleteStream).toHaveBeenCalledOnce();
-            // Verify stream contains token chunks
-            expect(raw).toContain("claude stream mock".split(" ")[0]);
-            resolve();
-          });
-        }
-      );
-      req.on("error", reject);
-      req.write(body);
-      req.end();
-    });
-  });
-});