fix(translator): ESM-safe registry + tool-id pairing + responses max_tokens; add real-creds tests

- translator/index.js: replace require() with static side-effect imports (ESM-safe),
  lazy-init registry maps to survive circular import order
- openai-responses->openai: map max_output_tokens -> max_tokens (avoid leaking field upstream)
- gemini/antigravity -> openai: derive deterministic tool_call id from name so
  functionCall/functionResponse pair correctly (fixes provider tool-pairing 400s)
- add offline unit tests (finish-reason, usage, session-manager, ollama malformed args, const guard)
- add real-creds integration tests (provider-cases + all-formats matrix: 6 inbound formats x 4 scenarios)

Includes co-located provider registry refactor (pricing/capabilities/media providers) and sessionManager updates.

Co-authored-by: Cursor <cursoragent@cursor.com>

tests/translator/bugs-antigravity.test.js

@@ -27,7 +27,7 @@ describe("Antigravity → OpenAI", () => {
 
   // antigravity-to-openai.js:167 — functionCall without id gets a random Date.now() id
   // KNOWN BUG: unstable id breaks matching with its functionResponse
-  it.fails("functionCall without id keeps a stable matchable id", () => {
+  it("functionCall without id keeps a stable matchable id", () => {
     const out = AG2O({
       contents: [
         { role: "model", parts: [{ functionCall: { name: "search", args: { q: "x" } } }] },

tests/translator/real/all-formats.real.test.js

@@ -0,0 +1,293 @@
+// REAL matrix test: every active provider in DB x every inbound client format x 4 scenarios.
+// Goal: maximize translation-path coverage to surface real bugs (system, multimodal image,
+// tool-call/tool-result, reasoning) across all source formats.
+//
+//   RUN_REAL=1 npx vitest run --config tests/vitest.config.js tests/translator/real/all-formats.real.test.js
+//   RUN_REAL=1 REAL_PROVIDERS=gemini,kiro,codex npx vitest run ... (optional filter)
+//
+// Skips (console.warn + pass) when: no credential/model, auth/quota status (401/402/403/429),
+// or the model rejects a capability (e.g. image on a non-vision model).
+import { describe, it, expect } from "vitest";
+import { getProviderCredentials } from "../../../src/sse/services/auth.js";
+import { checkAndRefreshToken } from "../../../src/sse/services/tokenRefresh.js";
+import { handleChatCore } from "../../../open-sse/handlers/chatCore.js";
+import { getModelsByProviderId } from "../../../open-sse/config/providerModels.js";
+
+const RUN_REAL = process.env.RUN_REAL === "1";
+const TIMEOUT_MS = 90000;
+const CRED_ISSUE = [401, 402, 403, 429];
+// Account/plan/capability rejections -> skip (not a translate bug). Kept specific to avoid masking real bugs.
+const SKIP_MSG_RE = /image|multimodal|vision|modality|unsupported|not support|reasoning_effort|deprecated|temperature|subscription|valid.*plan|embedding|quota|insufficient|model not found|context length|organization policy|disallowed|allowedmodels|failed_precondition/i;
+
+const PROVIDER_FILTER = (process.env.REAL_PROVIDERS || "")
+  .split(",").map((s) => s.trim()).filter(Boolean);
+
+// Tiny 1x1 transparent PNG (data URI body + raw base64) for multimodal scenarios.
+const PNG_B64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
+const PNG_DATA_URI = `data:image/png;base64,${PNG_B64}`;
+
+// Pick first chat LLM, excluding non-chat kinds (embedding/image/tts/stt/...).
+const NON_CHAT_KINDS = new Set(["embedding", "image", "imageToText", "tts", "stt", "video", "music", "webSearch"]);
+function firstLlmModel(providerId) {
+  const models = getModelsByProviderId(providerId);
+  const llm = models.find((m) => {
+    const kind = m.kind || m.type || "llm";
+    return kind === "llm" || (!NON_CHAT_KINDS.has(kind) && kind === "llm");
+  }) || models.find((m) => !NON_CHAT_KINDS.has(m.kind || m.type || "llm"));
+  return llm?.id || null;
+}
+
+async function drainSSE(response) {
+  if (!response?.body) return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let out = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    out += decoder.decode(value, { stream: true });
+  }
+  return out;
+}
+
+async function prepare(providerId) {
+  const model = firstLlmModel(providerId);
+  if (!model) return null;
+  const credentials = await getProviderCredentials(providerId, new Set(), model);
+  if (!credentials || credentials.allRateLimited) return null;
+  const refreshed = await checkAndRefreshToken(providerId, credentials);
+  return { model, credentials, refreshed };
+}
+
+// Run one request. Returns { raw } | "skip" | throws (real translate/runtime bug).
+async function runChat(providerId, prep, body, sourceFormatOverride) {
+  const result = await handleChatCore({
+    body: { ...body, model: `${providerId}/${prep.model}` },
+    modelInfo: { provider: providerId, model: prep.model },
+    credentials: prep.refreshed,
+    connectionId: prep.credentials.connectionId,
+    sourceFormatOverride,
+  });
+  if (!result.success) {
+    const status = Number(result.status);
+    if (CRED_ISSUE.includes(status)) return "skip";
+    // Upstream 5xx and 406 are provider-side issues, not translate bugs.
+    if (status >= 500 || status === 406) return "skip";
+    // Account/plan/capability rejection (e.g. non-vision model + image) is not a translate bug.
+    if (status === 400 && SKIP_MSG_RE.test(String(result.error || ""))) return "skip";
+    throw new Error(`${providerId} [${result.status}]: ${result.error}`);
+  }
+  return { raw: await drainSSE(result.response) };
+}
+
+// SSE validity marker per inbound format (response is re-encoded back to source format).
+const SSE_MARKER = {
+  openai: /chat\.completion\.chunk|"delta"|\[DONE\]/,
+  "openai-responses": /response\.|"type"\s*:\s*"response|\[DONE\]/,
+  claude: /event:\s*\w|"type"\s*:\s*"(message_start|content_block|message_delta)"/,
+  gemini: /"candidates"|"content"|data:/,
+  "gemini-cli": /"candidates"|"content"|data:/,
+  antigravity: /"candidates"|"content"|data:/,
+};
+
+// ---- Body builders: per format x scenario (full, spec-correct shapes) ----
+
+const COMMON = { temperature: 0.3, top_p: 0.9, max_tokens: 256 };
+// Reasoning models often reject custom temperature (must be default/1) -> omit sampling.
+const REASON_TOK = { max_tokens: 1024 };
+
+// OpenAI Chat Completions
+const openaiBody = {
+  basic: () => ({
+    ...COMMON, stream: true, stream_options: { include_usage: true },
+    messages: [
+      { role: "system", content: "You are concise." },
+      { role: "user", content: "Reply with the single word: hi" },
+    ],
+  }),
+  multimodal: () => ({
+    ...COMMON, stream: true,
+    messages: [
+      { role: "system", content: "Describe images briefly." },
+      { role: "user", content: [
+        { type: "text", text: "What color dominates this image? One word." },
+        { type: "image_url", image_url: { url: PNG_DATA_URI } },
+      ] },
+    ],
+  }),
+  tools: () => ({
+    ...COMMON, stream: true, tool_choice: "auto",
+    tools: [{ type: "function", function: { name: "get_weather", description: "Get weather", parameters: { type: "object", properties: { city: { type: "string" } }, required: ["city"] } } }],
+    messages: [
+      { role: "user", content: "Weather in Paris?" },
+      { role: "assistant", content: "", tool_calls: [{ id: "call_1", type: "function", function: { name: "get_weather", arguments: '{"city":"Paris"}' } }] },
+      { role: "tool", tool_call_id: "call_1", content: '{"temp":"20C"}' },
+      { role: "user", content: "Summarize in one short sentence." },
+    ],
+  }),
+  reasoning: () => ({
+    ...REASON_TOK, stream: true, reasoning_effort: "low",
+    messages: [{ role: "user", content: "What is 17 + 26? Reply with just the number." }],
+  }),
+};
+
+// OpenAI Responses API
+const responsesBody = {
+  basic: () => ({
+    ...COMMON, stream: true, max_output_tokens: 256,
+    instructions: "You are concise.",
+    input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "Reply with the single word: hi" }] }],
+  }),
+  multimodal: () => ({
+    ...COMMON, stream: true, max_output_tokens: 256,
+    instructions: "Describe images briefly.",
+    input: [{ type: "message", role: "user", content: [
+      { type: "input_text", text: "What color dominates? One word." },
+      { type: "input_image", image_url: PNG_DATA_URI },
+    ] }],
+  }),
+  tools: () => ({
+    ...COMMON, stream: true,
+    tools: [{ type: "function", name: "get_weather", description: "Get weather", parameters: { type: "object", properties: { city: { type: "string" } }, required: ["city"] } }],
+    input: [
+      { type: "message", role: "user", content: [{ type: "input_text", text: "Weather in Paris?" }] },
+      { type: "function_call", call_id: "call_1", name: "get_weather", arguments: '{"city":"Paris"}' },
+      { type: "function_call_output", call_id: "call_1", output: '{"temp":"20C"}' },
+      { type: "message", role: "user", content: [{ type: "input_text", text: "Summarize in one short sentence." }] },
+    ],
+  }),
+  reasoning: () => ({
+    ...REASON_TOK, stream: true, max_output_tokens: 1024, reasoning: { effort: "low" },
+    input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "What is 17 + 26? Just the number." }] }],
+  }),
+};
+
+// Anthropic Messages (Claude)
+const claudeBody = {
+  basic: () => ({
+    ...COMMON, stream: true,
+    system: [{ type: "text", text: "You are concise." }],
+    messages: [{ role: "user", content: "Reply with the single word: hi" }],
+  }),
+  multimodal: () => ({
+    ...COMMON, stream: true,
+    system: [{ type: "text", text: "Describe images briefly." }],
+    messages: [{ role: "user", content: [
+      { type: "text", text: "What color dominates? One word." },
+      { type: "image", source: { type: "base64", media_type: "image/png", data: PNG_B64 } },
+    ] }],
+  }),
+  tools: () => ({
+    ...COMMON, stream: true,
+    tools: [{ name: "get_weather", description: "Get weather", input_schema: { type: "object", properties: { city: { type: "string" } }, required: ["city"] } }],
+    messages: [
+      { role: "user", content: "Weather in Paris?" },
+      { role: "assistant", content: [{ type: "tool_use", id: "toolu_1", name: "get_weather", input: { city: "Paris" } }] },
+      { role: "user", content: [{ type: "tool_result", tool_use_id: "toolu_1", content: '{"temp":"20C"}' }] },
+      { role: "user", content: "Summarize in one short sentence." },
+    ],
+  }),
+  reasoning: () => ({
+    ...REASON_TOK, stream: true, thinking: { type: "enabled", budget_tokens: 1024 },
+    messages: [{ role: "user", content: "What is 17 + 26? Just the number." }],
+  }),
+};
+
+// Gemini generateContent
+const geminiBody = {
+  basic: () => ({
+    systemInstruction: { parts: [{ text: "You are concise." }] },
+    contents: [{ role: "user", parts: [{ text: "Reply with the single word: hi" }] }],
+    generationConfig: { maxOutputTokens: 256, temperature: 0.3, topP: 0.9 },
+  }),
+  multimodal: () => ({
+    systemInstruction: { parts: [{ text: "Describe images briefly." }] },
+    contents: [{ role: "user", parts: [
+      { text: "What color dominates? One word." },
+      { inlineData: { mimeType: "image/png", data: PNG_B64 } },
+    ] }],
+    generationConfig: { maxOutputTokens: 256 },
+  }),
+  tools: () => ({
+    tools: [{ functionDeclarations: [{ name: "get_weather", description: "Get weather", parameters: { type: "object", properties: { city: { type: "string" } }, required: ["city"] } }] }],
+    contents: [
+      { role: "user", parts: [{ text: "Weather in Paris?" }] },
+      { role: "model", parts: [{ functionCall: { name: "get_weather", args: { city: "Paris" } } }] },
+      { role: "user", parts: [{ functionResponse: { name: "get_weather", response: { temp: "20C" } } }] },
+      { role: "user", parts: [{ text: "Summarize in one short sentence." }] },
+    ],
+    generationConfig: { maxOutputTokens: 256 },
+  }),
+  reasoning: () => ({
+    contents: [{ role: "user", parts: [{ text: "What is 17 + 26? Just the number." }] }],
+    generationConfig: { maxOutputTokens: 1024, thinkingConfig: { thinkingBudget: 512, includeThoughts: true } },
+  }),
+};
+
+// Antigravity = Gemini body wrapped in { request, userAgent }.
+const wrapAntigravity = (fn) => () => ({ request: fn(), userAgent: "antigravity" });
+const antigravityBody = {
+  basic: wrapAntigravity(geminiBody.basic),
+  multimodal: wrapAntigravity(geminiBody.multimodal),
+  tools: wrapAntigravity(geminiBody.tools),
+  reasoning: wrapAntigravity(geminiBody.reasoning),
+};
+
+const BUILDERS = {
+  openai: openaiBody,
+  "openai-responses": responsesBody,
+  claude: claudeBody,
+  gemini: geminiBody,
+  "gemini-cli": geminiBody,
+  antigravity: antigravityBody,
+};
+
+const FORMATS = Object.keys(BUILDERS);
+const SCENARIOS = ["basic", "multimodal", "tools", "reasoning"];
+
+// Read active providers from DB at module-eval time (one test per provider/format/scenario).
+function targetProviders() {
+  try {
+    const Database = require("better-sqlite3");
+    const os = require("os");
+    const path = require("path");
+    const dbPath = process.env.DATA_DIR
+      ? path.join(process.env.DATA_DIR, "db", "data.sqlite")
+      : path.join(os.homedir(), ".9router", "db", "data.sqlite");
+    const db = new Database(dbPath, { readonly: true });
+    const rows = db.prepare("SELECT DISTINCT provider FROM providerConnections WHERE isActive = 1").all();
+    db.close();
+    let list = rows.map((r) => r.provider).sort();
+    if (PROVIDER_FILTER.length) list = list.filter((p) => PROVIDER_FILTER.includes(p));
+    return list;
+  } catch {
+    return [];
+  }
+}
+
+describe.skipIf(!RUN_REAL)("REAL all-formats matrix", () => {
+  const providers = RUN_REAL ? targetProviders() : [];
+
+  it("has active providers in DB", () => {
+    expect(providers.length).toBeGreaterThan(0);
+  });
+
+  for (const providerId of providers) {
+    for (const fmt of FORMATS) {
+      for (const scn of SCENARIOS) {
+        it.concurrent(`${providerId} | ${fmt} | ${scn}`, async () => {
+          const prep = await prepare(providerId);
+          if (!prep) { console.warn(`[skip] ${providerId}: no cred/model`); return expect(true).toBe(true); }
+
+          const body = BUILDERS[fmt][scn]();
+          const out = await runChat(providerId, prep, body, fmt);
+          if (out === "skip") { console.warn(`[skip] ${providerId} ${fmt}/${scn}: cred/quota/capability`); return expect(true).toBe(true); }
+
+          expect(out.raw.length, `${providerId} ${fmt}/${scn}: empty SSE`).toBeGreaterThan(0);
+          expect(SSE_MARKER[fmt].test(out.raw), `${providerId} ${fmt}/${scn}: invalid SSE shape`).toBe(true);
+        }, TIMEOUT_MS);
+      }
+    }
+  }
+});

tests/translator/real/provider-cases.real.test.js

@@ -0,0 +1,168 @@
+// B2: REAL behavior assertions for the risky provider-specific cases.
+// Unlike smoke (only "doesn't crash"), each test asserts concrete OUTPUT.
+// Gated by RUN_REAL=1; any provider lacking creds/model or returning an auth/quota
+// status (401/402/403/429) is skipped (console.warn + pass).
+//
+//   RUN_REAL=1 npx vitest run --config tests/vitest.config.js tests/translator/real/provider-cases.real.test.js
+import { describe, it, expect } from "vitest";
+import { getProviderCredentials } from "../../../src/sse/services/auth.js";
+import { checkAndRefreshToken } from "../../../src/sse/services/tokenRefresh.js";
+import { handleChatCore } from "../../../open-sse/handlers/chatCore.js";
+import { getModelsByProviderId } from "../../../open-sse/config/providerModels.js";
+
+const RUN_REAL = process.env.RUN_REAL === "1";
+const TIMEOUT_MS = 90000;
+const CRED_ISSUE = [401, 402, 403, 429];
+
+// Pick the first plain llm model for a provider.
+function firstLlmModel(providerId) {
+  const models = getModelsByProviderId(providerId);
+  const llm = models.find((m) => (m.type || "llm") === "llm");
+  return llm?.id || null;
+}
+
+async function drainSSE(response) {
+  if (!response?.body) return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let out = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    out += decoder.decode(value, { stream: true });
+  }
+  return out;
+}
+
+// Resolve creds+model for a provider, or null when unavailable (caller skips).
+async function prepare(providerId) {
+  const model = firstLlmModel(providerId);
+  if (!model) {
+    console.warn(`[skip] ${providerId}: no llm model`);
+    return null;
+  }
+  const credentials = await getProviderCredentials(providerId, new Set(), model);
+  if (!credentials || credentials.allRateLimited) {
+    console.warn(`[skip] ${providerId}: no usable credential`);
+    return null;
+  }
+  const refreshed = await checkAndRefreshToken(providerId, credentials);
+  return { model, credentials, refreshed };
+}
+
+// Run handleChatCore + drain; returns { raw } or null if cred/quota issue (caller skips).
+async function runChat(providerId, prep, body) {
+  const result = await handleChatCore({
+    body: { model: `${providerId}/${prep.model}`, ...body },
+    modelInfo: { provider: providerId, model: prep.model },
+    credentials: prep.refreshed,
+    connectionId: prep.credentials.connectionId,
+  });
+  if (!result.success) {
+    if (CRED_ISSUE.includes(Number(result.status))) {
+      console.warn(`[skip] ${providerId}: ${result.status} (credential/quota)`);
+      return null;
+    }
+    throw new Error(`${providerId} failed: ${result.status} ${result.error}`);
+  }
+  return { raw: await drainSSE(result.response) };
+}
+
+describe.skipIf(!RUN_REAL)("REAL provider behavior cases", () => {
+  // Case #1: Gemini normal prompt -> finish_reason "stop".
+  it("gemini: finish_reason stop", async () => {
+    const prep = await prepare("gemini");
+    if (!prep) return expect(true).toBe(true);
+    // Generous max_tokens so reasoning models (gemini-3 pro) don't hit "length" first.
+    const out = await runChat("gemini", prep, {
+      stream: true,
+      max_tokens: 2048,
+      messages: [{ role: "user", content: "Reply with the single word: hi" }],
+    });
+    if (!out) return expect(true).toBe(true);
+    expect(/"finish_reason"\s*:\s*"stop"/.test(out.raw), "no stop finish_reason").toBe(true);
+  }, TIMEOUT_MS);
+
+  // Case #4: Kiro tool turn -> tool_calls finish_reason + tool_calls delta.
+  it("kiro: tool turn -> tool_calls", async () => {
+    const prep = await prepare("kiro");
+    if (!prep) return expect(true).toBe(true);
+    const out = await runChat("kiro", prep, {
+      stream: true,
+      max_tokens: 128,
+      tool_choice: "auto",
+      tools: [{
+        type: "function",
+        function: {
+          name: "get_weather",
+          description: "Get the current weather for a city",
+          parameters: {
+            type: "object",
+            properties: { city: { type: "string", description: "City name" } },
+            required: ["city"],
+          },
+        },
+      }],
+      messages: [{ role: "user", content: "What's the weather in Paris? Use the get_weather tool." }],
+    });
+    if (!out) return expect(true).toBe(true);
+    expect(/"finish_reason"\s*:\s*"tool_calls"/.test(out.raw), "no tool_calls finish_reason").toBe(true);
+    expect(/"tool_calls"/.test(out.raw), "no tool_calls delta").toBe(true);
+  }, TIMEOUT_MS);
+
+  // Case #3: Ollama tiny max_tokens + long prompt -> finish_reason "length".
+  it("ollama: max_tokens -> length", async () => {
+    const prep = await prepare("ollama");
+    if (!prep) return expect(true).toBe(true);
+    const out = await runChat("ollama", prep, {
+      stream: true,
+      max_tokens: 4,
+      messages: [{ role: "user", content: "Write a long detailed essay about the history of computing." }],
+    });
+    if (!out) return expect(true).toBe(true);
+    // length is model-dependent; if the model stopped on its own, skip rather than fail.
+    if (!/"finish_reason"\s*:\s*"length"/.test(out.raw)) {
+      console.warn("[skip] ollama: model did not hit length (output shorter than max_tokens)");
+      return expect(true).toBe(true);
+    }
+    expect(/"finish_reason"\s*:\s*"length"/.test(out.raw)).toBe(true);
+  }, TIMEOUT_MS);
+
+  // Case #4/#5: Codex multi-turn -> session stickiness (prompt-cache hit on 2nd turn).
+  it("codex: session stickiness (cached_tokens on 2nd turn)", async () => {
+    const prep = await prepare("codex");
+    if (!prep) return expect(true).toBe(true);
+    const longContext = "The capital of France is Paris. ".repeat(40);
+    const messages = [
+      { role: "user", content: longContext },
+      { role: "assistant", content: "Understood. I have noted that context." },
+      { role: "user", content: "Reply with the single word: ok" },
+    ];
+    const body = { stream: true, max_tokens: 32, messages };
+    const first = await runChat("codex", prep, body);
+    if (!first) return expect(true).toBe(true);
+    const second = await runChat("codex", prep, body);
+    if (!second) return expect(true).toBe(true);
+    // 2nd identical-context turn should hit prompt cache when session is sticky.
+    const m = second.raw.match(/"cached_tokens"\s*:\s*(\d+)/);
+    if (!m) {
+      console.warn("[skip] codex: no cached_tokens in usage (provider may not report)");
+      return expect(true).toBe(true);
+    }
+    expect(Number(m[1]), "cached_tokens not > 0 on 2nd turn").toBeGreaterThan(0);
+  }, TIMEOUT_MS);
+
+  // Case #1/#2: Antigravity normal prompt -> valid SSE response.
+  it("antigravity: responds OK", async () => {
+    const prep = await prepare("antigravity");
+    if (!prep) return expect(true).toBe(true);
+    const out = await runChat("antigravity", prep, {
+      stream: true,
+      max_tokens: 32,
+      messages: [{ role: "user", content: "Reply with the single word: hi" }],
+    });
+    if (!out) return expect(true).toBe(true);
+    expect(out.raw.length, "empty response").toBeGreaterThan(0);
+    expect(/data:|finish_reason|"delta"|"content"|event:/.test(out.raw), "not SSE").toBe(true);
+  }, TIMEOUT_MS);
+});

tests/unit/executor-const-guard.test.js

@@ -0,0 +1,48 @@
+// A5 (cases #7/#9/#10): lock hardcode->config no-op values.
+import { describe, it, expect } from "vitest";
+import {
+  OPENAI_COMPAT_BASE,
+  ANTHROPIC_COMPAT_BASE,
+  ANTHROPIC_API_VERSION,
+} from "../../open-sse/providers/shared.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_MIN_TOKENS } from "../../open-sse/config/runtimeConfig.js";
+import mimoFree from "../../open-sse/providers/registry/mimo-free.js";
+import opencode from "../../open-sse/providers/registry/opencode.js";
+import antigravity from "../../open-sse/providers/registry/antigravity.js";
+
+describe("compat base URLs / version", () => {
+  it("OPENAI_COMPAT_BASE", () => {
+    expect(OPENAI_COMPAT_BASE).toBe("https://api.openai.com/v1");
+  });
+  it("ANTHROPIC_COMPAT_BASE", () => {
+    expect(ANTHROPIC_COMPAT_BASE).toBe("https://api.anthropic.com/v1");
+  });
+  it("ANTHROPIC_API_VERSION", () => {
+    expect(ANTHROPIC_API_VERSION).toBe("2023-06-01");
+  });
+});
+
+describe("default token limits", () => {
+  it("max/min", () => {
+    expect(DEFAULT_MAX_TOKENS).toBe(64000);
+    expect(DEFAULT_MIN_TOKENS).toBe(32000);
+  });
+});
+
+describe("provider baseUrl const (full path, no trailing slash)", () => {
+  it("mimo-free full path", () => {
+    expect(mimoFree.transport.baseUrl).toBe("https://api.xiaomimimo.com/api/free-ai/openai/chat");
+  });
+  it("opencode no trailing slash", () => {
+    expect(opencode.transport.baseUrl).toBe("https://opencode.ai");
+  });
+});
+
+describe("antigravity retry (intentional change: 429=6, 503=3)", () => {
+  it("429 attempts = 6", () => {
+    expect(antigravity.transport.retry["429"].attempts).toBe(6);
+  });
+  it("503 attempts = 3", () => {
+    expect(antigravity.transport.retry["503"].attempts).toBe(3);
+  });
+});

tests/unit/finish-reason-concern.test.js

@@ -0,0 +1,83 @@
+// A1: locks toOpenAIFinish/fromOpenAIFinish behavior changes vs open-sse.old.
+import { describe, it, expect } from "vitest";
+import { toOpenAIFinish, fromOpenAIFinish } from "../../open-sse/translator/concerns/finishReason.js";
+import { OPENAI_FINISH, CLAUDE_STOP, GEMINI_FINISH } from "../../open-sse/translator/schema/finishReasons.js";
+
+describe("toOpenAIFinish - gemini", () => {
+  it.each([
+    ["SAFETY", "content_filter"],
+    ["RECITATION", "content_filter"],
+    ["BLOCKLIST", "content_filter"],
+    ["PROHIBITED_CONTENT", "content_filter"],
+    ["OTHER", "stop"],
+    ["UNKNOWN_XYZ", "stop"],
+    ["STOP", "stop"],
+    ["MAX_TOKENS", "length"],
+  ])("%s -> %s", (input, expected) => {
+    expect(toOpenAIFinish(input, "gemini")).toBe(expected);
+  });
+});
+
+describe("toOpenAIFinish - ollama", () => {
+  it.each([
+    ["length", "length"],
+    ["max_tokens", "length"],
+    ["tool_calls", "tool_calls"],
+    ["unknown_xyz", "stop"],
+  ])("%s -> %s", (input, expected) => {
+    expect(toOpenAIFinish(input, "ollama")).toBe(expected);
+  });
+});
+
+describe("toOpenAIFinish - kiro", () => {
+  it("tool_use -> tool_calls", () => {
+    expect(toOpenAIFinish("tool_use", "kiro")).toBe("tool_calls");
+  });
+});
+
+describe("toOpenAIFinish - claude", () => {
+  it.each([
+    ["end_turn", "stop"],
+    ["max_tokens", "length"],
+    ["tool_use", "tool_calls"],
+  ])("%s -> %s", (input, expected) => {
+    expect(toOpenAIFinish(input, "claude")).toBe(expected);
+  });
+});
+
+describe("toOpenAIFinish - commandcode", () => {
+  it("tool-calls -> tool_calls", () => {
+    expect(toOpenAIFinish("tool-calls", "commandcode")).toBe("tool_calls");
+  });
+  it("unknown passthrough", () => {
+    expect(toOpenAIFinish("xyz", "commandcode")).toBe("xyz");
+  });
+});
+
+describe("fromOpenAIFinish round-trip - claude", () => {
+  it("tool_calls -> tool_use", () => {
+    expect(fromOpenAIFinish("tool_calls", "claude")).toBe("tool_use");
+  });
+  it("length -> max_tokens", () => {
+    expect(fromOpenAIFinish("length", "claude")).toBe("max_tokens");
+  });
+});
+
+describe("enum literals (catch drift)", () => {
+  it("OPENAI_FINISH literals", () => {
+    expect(OPENAI_FINISH.STOP).toBe("stop");
+    expect(OPENAI_FINISH.LENGTH).toBe("length");
+    expect(OPENAI_FINISH.TOOL_CALLS).toBe("tool_calls");
+    expect(OPENAI_FINISH.CONTENT_FILTER).toBe("content_filter");
+  });
+  it("CLAUDE_STOP literals", () => {
+    expect(CLAUDE_STOP.END_TURN).toBe("end_turn");
+    expect(CLAUDE_STOP.MAX_TOKENS).toBe("max_tokens");
+    expect(CLAUDE_STOP.TOOL_USE).toBe("tool_use");
+  });
+  it("GEMINI_FINISH literals", () => {
+    expect(GEMINI_FINISH.STOP).toBe("STOP");
+    expect(GEMINI_FINISH.MAX_TOKENS).toBe("MAX_TOKENS");
+    expect(GEMINI_FINISH.SAFETY).toBe("SAFETY");
+  });
+});

tests/unit/openai-to-ollama-malformed.test.js

@@ -0,0 +1,30 @@
+// A4 (case #10): malformed tool_calls args must not throw -> safeParseJSON returns {}.
+import { describe, it, expect } from "vitest";
+import { openaiToOllamaRequest } from "../../open-sse/translator/request/openai-to-ollama.js";
+
+function reqWith(args) {
+  return {
+    messages: [
+      {
+        role: "assistant",
+        content: "",
+        tool_calls: [{ id: "c1", type: "function", function: { name: "get_weather", arguments: args } }],
+      },
+    ],
+  };
+}
+
+describe("openaiToOllamaRequest - tool_calls arguments parsing", () => {
+  it("malformed JSON args -> {} (no throw)", () => {
+    let out;
+    expect(() => {
+      out = openaiToOllamaRequest("m", reqWith("{invalid json"), true);
+    }).not.toThrow();
+    expect(out.messages[0].tool_calls[0].function.arguments).toEqual({});
+  });
+
+  it("valid JSON args -> parsed object", () => {
+    const out = openaiToOllamaRequest("m", reqWith('{"a":1}'), true);
+    expect(out.messages[0].tool_calls[0].function.arguments).toEqual({ a: 1 });
+  });
+});

tests/unit/provider-pricing-minimax-m3.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { MODEL_PRICING } from "../../src/shared/constants/pricing.js";
+import { MODEL_PRICING } from "../../open-sse/providers/pricing.js";
 
 describe("MiniMax-M3 pricing", () => {
   it("includes MiniMax-M3 in MODEL_PRICING", () => {

tests/unit/session-manager.test.js

@@ -0,0 +1,49 @@
+// A2: locks resolveSessionId priority/stickiness (codex/kiro/antigravity centralization).
+import { describe, it, expect, beforeEach } from "vitest";
+import { resolveSessionId, deriveSessionId, clearSessionStore } from "../../open-sse/utils/sessionManager.js";
+
+// Assistant text must exceed ASSISTANT_MIN_LEN (50) to trigger sticky hash path.
+const longAssistant = "x".repeat(80);
+const bodyWithAssistant = { messages: [{ role: "assistant", content: longAssistant }] };
+
+beforeEach(() => clearSessionStore());
+
+describe("resolveSessionId", () => {
+  it("stickiness: same body+connectionId+scope -> same id", () => {
+    const opts = { body: bodyWithAssistant, connectionId: "conn1", scope: "codex" };
+    expect(resolveSessionId(opts)).toBe(resolveSessionId(opts));
+  });
+
+  it("different connectionId -> different id", () => {
+    const a = resolveSessionId({ body: bodyWithAssistant, connectionId: "connA", scope: "codex" });
+    const b = resolveSessionId({ body: bodyWithAssistant, connectionId: "connB", scope: "codex" });
+    expect(a).not.toBe(b);
+  });
+
+  it("different scope -> different id", () => {
+    const a = resolveSessionId({ body: bodyWithAssistant, connectionId: "conn1", scope: "codex" });
+    const b = resolveSessionId({ body: bodyWithAssistant, connectionId: "conn1", scope: "kiro" });
+    expect(a).not.toBe(b);
+  });
+
+  it("fallback: empty body+no header+no workspaceId -> deriveSessionId(connectionId)", () => {
+    const got = resolveSessionId({ body: {}, connectionId: "connFallback" });
+    expect(got).toBe(deriveSessionId("connFallback"));
+  });
+
+  it("client override: x-session-id header wins, skips later steps", () => {
+    const got = resolveSessionId({
+      headers: { "x-session-id": "client-sess-123" },
+      body: bodyWithAssistant,
+      connectionId: "conn1",
+      workspaceId: "ws1",
+      scope: "codex",
+    });
+    expect(got).toBe("client-sess-123");
+  });
+
+  it("workspaceId path: empty body + workspaceId set -> normalized workspaceId", () => {
+    const got = resolveSessionId({ body: {}, connectionId: "conn1", workspaceId: "ws-abc" });
+    expect(got).toBe("ws-abc");
+  });
+});

tests/unit/usage-concern.test.js

@@ -0,0 +1,69 @@
+// A3: locks toOpenAIUsage per-provider token math (claude/gemini/kiro/ollama/commandcode).
+import { describe, it, expect } from "vitest";
+import { toOpenAIUsage } from "../../open-sse/translator/concerns/usage.js";
+
+describe("toOpenAIUsage", () => {
+  it("claude: folds cache read+create into prompt, exposes details", () => {
+    const u = toOpenAIUsage(
+      { input_tokens: 100, output_tokens: 20, cache_read_input_tokens: 30, cache_creation_input_tokens: 10 },
+      "claude"
+    );
+    expect(u.prompt_tokens).toBe(140);
+    expect(u.completion_tokens).toBe(20);
+    expect(u.total_tokens).toBe(160);
+    expect(u.prompt_tokens_details.cached_tokens).toBe(30);
+    expect(u.prompt_tokens_details.cache_creation_tokens).toBe(10);
+  });
+
+  it("claude: no cache -> no prompt_tokens_details", () => {
+    const u = toOpenAIUsage({ input_tokens: 50, output_tokens: 5 }, "claude");
+    expect(u.prompt_tokens).toBe(50);
+    expect(u.prompt_tokens_details).toBeUndefined();
+  });
+
+  it("gemini: full fields, completion = candidates + thoughts", () => {
+    const u = toOpenAIUsage(
+      { promptTokenCount: 100, candidatesTokenCount: 40, thoughtsTokenCount: 10, totalTokenCount: 150 },
+      "gemini"
+    );
+    expect(u.prompt_tokens).toBe(100);
+    expect(u.completion_tokens).toBe(50);
+    expect(u.total_tokens).toBe(150);
+    expect(u.completion_tokens_details.reasoning_tokens).toBe(10);
+  });
+
+  it("gemini fallback: candidates=0 -> derive from total - prompt - thoughts", () => {
+    const u = toOpenAIUsage(
+      { promptTokenCount: 100, candidatesTokenCount: 0, thoughtsTokenCount: 10, totalTokenCount: 150 },
+      "gemini"
+    );
+    // candidates derived = 150 - 100 - 10 = 40 ; completion = 40 + 10
+    expect(u.completion_tokens).toBe(50);
+  });
+
+  it("kiro: input/output straight", () => {
+    const u = toOpenAIUsage({ inputTokens: 12, outputTokens: 3 }, "kiro");
+    expect(u.prompt_tokens).toBe(12);
+    expect(u.completion_tokens).toBe(3);
+    expect(u.total_tokens).toBe(15);
+  });
+
+  it("ollama: prompt_eval_count/eval_count", () => {
+    const u = toOpenAIUsage({ prompt_eval_count: 7, eval_count: 4 }, "ollama");
+    expect(u.prompt_tokens).toBe(7);
+    expect(u.completion_tokens).toBe(4);
+    expect(u.total_tokens).toBe(11);
+  });
+
+  it("commandcode: keeps totalTokens fallback", () => {
+    const u = toOpenAIUsage({ inputTokens: 8, outputTokens: 2, totalTokens: 99 }, "commandcode");
+    expect(u.prompt_tokens).toBe(8);
+    expect(u.completion_tokens).toBe(2);
+    expect(u.total_tokens).toBe(99);
+  });
+
+  it("unknown kind / null raw -> null", () => {
+    expect(toOpenAIUsage({}, "nope")).toBeNull();
+    expect(toOpenAIUsage(null, "claude")).toBeNull();
+  });
+});