llm-switcher 1.2.0 → 1.2.2

package/formats.mjs

@@ -19,6 +19,7 @@
 //   params: { maxTokens, temperature, topP, topK, stop[],
 //             presencePenalty?, frequencyPenalty? },
 //   thinking: { type:'enabled'|'disabled'|'adaptive', budget?, effort? } | null,
+//   responseFormat: { type:'json_object' } | { type:'json_schema', name?, schema, strict? } | null,
 //   stream: bool
 // }
 // ============================================================
@@ -327,10 +328,23 @@ function baseIR() {
   return {
     model: '', system: '', messages: [], tools: [], toolChoice: null,
     params: { maxTokens: null, temperature: null, topP: null, topK: null, stop: [] },
-    thinking: null, stream: false
+    thinking: null, responseFormat: null, stream: false
   };
 }
 
+// Structured output (Anthropic output_config.format, Responses text.format) -> IR responseFormat.
+// `text` asks for nothing.
+function responseFormatIR(f) {
+  if (!f || typeof f !== 'object') return null;
+  if (f.type === 'json_object') return { type: 'json_object' };
+  if (f.type !== 'json_schema') return null;
+  if (!f.schema || typeof f.schema !== 'object') return { type: 'json_object' };
+  const out = { type: 'json_schema', schema: f.schema };
+  if (typeof f.name === 'string' && f.name) out.name = f.name;
+  if (typeof f.strict === 'boolean') out.strict = f.strict;
+  return out;
+}
+
 // Anthropic Messages API -> IR (logic ported from the old transformAnthropicToOpenAI).
 function anthropicToIR(payload) {
   const ir = baseIR();
@@ -423,6 +437,7 @@ function anthropicToIR(payload) {
   if (Array.isArray(payload.stop_sequences)) ir.params.stop = stopList(payload.stop_sequences);
 
   ir.thinking = thinkingFromAnthropicParam(payload.thinking, payload.output_config?.effort);
+  ir.responseFormat = responseFormatIR(payload.output_config?.format || payload.output_format);
   return ir;
 }
 
@@ -644,6 +659,7 @@ function responsesToIR(payload) {
   if (payload.reasoning && typeof payload.reasoning === 'object') {
     ir.thinking = thinkingFromReasoningParam(payload.reasoning);
   }
+  ir.responseFormat = responseFormatIR(payload.text?.format);
   return ir;
 }
 
@@ -822,6 +838,13 @@ function irToChatBody(ir, model, opts = {}) {
   if (typeof ir.params.frequencyPenalty === 'number') body.frequency_penalty = ir.params.frequencyPenalty;
   if (ir.params.stop.length) body.stop = ir.params.stop;
   if (ir.params.parallelToolCalls === false && body.tools) body.parallel_tool_calls = false;
+  if (ir.responseFormat?.type === 'json_schema') {
+    const js = { name: ir.responseFormat.name || 'response', schema: ir.responseFormat.schema };
+    if (typeof ir.responseFormat.strict === 'boolean') js.strict = ir.responseFormat.strict;
+    body.response_format = { type: 'json_schema', json_schema: js };
+  } else if (ir.responseFormat?.type === 'json_object') {
+    body.response_format = { type: 'json_object' };
+  }
 
   if (wantsThinking && mode === 'native') {
     body.reasoning_effort = ir.thinking?.effort && !['max', 'xhigh'].includes(ir.thinking.effort)
@@ -941,6 +964,8 @@ function irToAnthropicBody(ir, model) {
   if (typeof ir.params.topP === 'number') body.top_p = ir.params.topP;
   if (typeof ir.params.topK === 'number') body.top_k = ir.params.topK;
   if (ir.params.stop.length) body.stop_sequences = ir.params.stop;
+  // Anthropic has no JSON mode without a schema.
+  if (ir.responseFormat?.type === 'json_schema') body.output_config = { format: { type: 'json_schema', schema: ir.responseFormat.schema } };
   if (ir.thinking && ir.thinking.type === 'adaptive') {
     body.thinking = { type: 'adaptive' };
   } else if (ir.thinking && ir.thinking.type !== 'disabled' && body.max_tokens > 1024) {
@@ -1062,6 +1087,10 @@ function irToVertexBody(ir, model) {
       gc.thinkingConfig.thinkingBudget = clampBudget(ir.thinking.budget ?? (ir.thinking.effort ? effortToBudget(ir.thinking.effort) : 2048));
     }
   }
+  if (ir.responseFormat) {
+    gc.responseMimeType = 'application/json';
+    if (ir.responseFormat.type === 'json_schema') gc.responseSchema = toGeminiSchema(ir.responseFormat.schema);
+  }
   if (Object.keys(gc).length) body.generationConfig = gc;
   return body;
 }

package/icons/intact.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><defs><linearGradient id="lg" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#7c6cf6"/><stop offset="1" stop-color="#2dd4bf"/></linearGradient></defs><rect width="32" height="32" rx="9" fill="url(#lg)"/><path d="M16 6.5 24 9.6v6.1c0 5-3.4 8.6-8 10-4.6-1.4-8-5-8-10V9.6Z" fill="none" stroke="#fff" stroke-width="2.2" stroke-linejoin="round"/><path d="m12.4 16.2 2.6 2.6 4.8-5" fill="none" stroke="#fff" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round"/></svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Zero-dependency multi-protocol edge gateway & provider switcher for Claude Code, Codex, OpenAI and Gemini clients",
   "keywords": [
     "llm",

package/proxy.mjs

@@ -1018,15 +1018,6 @@ function validateProfileInput(p) {
       if (name !== '' && !isSafeModelName(name)) return `Invalid codexRoles.${slot} value "${name}"`;
     }
   }
-  if (p.blindfoldPort !== undefined && p.blindfoldPort !== '' && !parsePort(p.blindfoldPort)) {
-    return `Invalid blindfoldPort "${p.blindfoldPort}"`;
-  }
-  if (p.blindfoldHost !== undefined && p.blindfoldHost !== '' && !/^[A-Za-z0-9.-]{1,253}$/.test(p.blindfoldHost)) {
-    return `Invalid blindfoldHost "${p.blindfoldHost}"`;
-  }
-  if (p.blindfoldPrefix !== undefined && p.blindfoldPrefix !== '' && !/^\/[A-Za-z0-9._~/-]{0,200}$/.test(p.blindfoldPrefix)) {
-    return `Invalid blindfoldPrefix "${p.blindfoldPrefix}"`;
-  }
   return null;
 }
 
@@ -1118,11 +1109,32 @@ async function route(req, res) {
     res.writeHead(204, {
       'Access-Control-Allow-Origin': req.headers.origin || `http://127.0.0.1:${PORT}`,
       'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-      'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization, x-llm-switcher-token'
     });
     return res.end();
   }
 
+  // Serve static tool icons (cached, immutable, strictly image/png and image/svg+xml)
+  if (method === 'GET' && pathname.startsWith('/icons/')) {
+    const iconName = path.basename(pathname);
+    if (!/\.(png|svg)$/i.test(iconName)) {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      return res.end('Icon not found');
+    }
+    const iconPath = path.join(__dirname, 'icons', iconName);
+    if (fs.existsSync(iconPath)) {
+      const ext = path.extname(iconName).toLowerCase();
+      const contentType = ext === '.svg' ? 'image/svg+xml' : 'image/png';
+      res.writeHead(200, {
+        'Content-Type': contentType,
+        'Cache-Control': 'public, max-age=604800, immutable'
+      });
+      return fs.createReadStream(iconPath).pipe(res);
+    }
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    return res.end('Icon not found');
+  }
+
   // Serve Web UI (no-cache: always serve the latest version after file edits)
   if (method === 'GET' && (pathname === '/' || pathname === '/ui')) {
     if (fs.existsSync(uiHtmlPath)) {
@@ -1275,6 +1287,11 @@ async function routeApi(req, res, method, pathname) {
     return sendJson(res, 200, { logs: requestLogs.slice().reverse() });
   }
 
+  // GET /api/catalog (Dynamic Model Discovery)
+  if (method === 'GET' && pathname === '/api/catalog') {
+    return sendJson(res, 200, loadCatalogCache(STATE_DIR));
+  }
+
   if (method !== 'POST') {
     req.resume();
     return sendJson(res, 404, { error: `Not found: ${method} ${pathname}` });
@@ -1287,11 +1304,6 @@ async function routeApi(req, res, method, pathname) {
     return sendJson(res, err.status || 400, { error: err.message });
   }
 
-  // GET /api/catalog
-  if (method === 'GET' && pathname === '/api/catalog') {
-    return sendJson(res, 200, loadCatalogCache(STATE_DIR));
-  }
-
   // POST /api/catalog/refresh
   if (method === 'POST' && pathname === '/api/catalog/refresh') {
     const active = getActiveMap(requireConfig(res) || {});

package/skills/llm-switcher/SKILL.md

@@ -1,93 +1,93 @@
----
-name: llm-switcher
-description: Mandatory guidance for AI coding agents and token compression tools (Headroom, RTK, Ponytail, Repomix). Enforces routing all LLM traffic through the local LLM Switcher edge gateway (http://127.0.0.1:3456) instead of directly calling provider endpoints.
----
-
-# LLM Switcher Edge Gateway Skill
-
-This skill governs how AI coding agents (Claude Code, Codex, Cursor, Windsurf, Opencode) and prompt optimization/compression tools (Headroom, RTK, Ponytail, Repomix) must interact with LLM providers on this workstation.
-
-## 1. The Core Directive
-
-> **ALL OUTBOUND LLM REQUESTS MUST ROUTE THROUGH LLM SWITCHER (`http://127.0.0.1:3456`).**
-> 
-> Never configure any tool, script, sub-agent, or token compression proxy to call external provider endpoints directly (such as `https://api.anthropic.com`, `https://api.openai.com`, or `https://generativelanguage.googleapis.com`).
->
-> If a token compression tool (Headroom, RTK, Ponytail) is used, it MUST be positioned as an **inner processing layer**, and its **upstream destination MUST be configured to point to LLM Switcher** at `http://127.0.0.1:3456`.
-
-```
-[Client CLI / Agent]
-         │
-         ▼
-[Token Compressor: RTK / Headroom / Ponytail]  <-- Inner Layer
-         │
-         ▼ (MANDATORY: Upstream MUST point to http://127.0.0.1:3456)
-[LLM Switcher Edge Gateway (:3456)]            <-- Outermost Gatekeeper
-         │
-         ▼ (Heals schemas, maps 1M context, extracts thinking, converts protocol)
-[Internet / intact (Recommended) / 9Router / Upstream LLM]
-```
-
-## 2. Why This is Mandatory
-
-Direct outbound calls from token compressors will break the developer environment for several reasons:
-
-1. **Schema Breakage & The Healer Engine:**
-   Token optimizers frequently prune conversation history to save tokens. In doing so, they often delete an `assistant` turn containing a `tool_use`, while leaving the subsequent `user` turn containing a `tool_result`.
-   - Anthropic and OpenAI APIs strictly reject this with `HTTP 400 (orphaned tool_use_id)`.
-   - **LLM Switcher** intercepts these malformed requests and runs its **Healer Engine**, automatically converting orphaned results into safe context text blocks and merging consecutive same-role turns so upstream providers accept the payload cleanly.
-2. **Thinking / Reasoning Protection:**
-   Many token compressors naively strip `thinking` parameters or reasoning budgets to reduce token count.
-   - When routed through LLM Switcher, the gateway detects reasoning models (such as `ag/claude-opus-4-6-thinking` or `ag/gemini-3.8-flash`) and **automatically restores thinking parameters**, ensuring the model retains its full reasoning capabilities.
-3. **Official Context Windows & Dynamic Model Discovery:**
-   Context windows follow the model you select without mutating permanent settings. The gateway auto-discovers official models from Anthropic and OpenAI, refreshing mappings on tool version upgrades (`switch models`).
-4. **Server Gateway Synergy (intact / 9Router):**
-   LLM Switcher pairs directly with server-side gateways like **intact** (strongly recommended for credential proxying, account pooling, and contract lab self-healing) or 9Router, handling retries and quotas far better than any local tool.
-
-## 3. Configuring Token Compression Tools
-
-When setting up or assisting the user with token compression tools, apply these exact configurations:
-
-### A. Headroom (Prompt Compression Proxy)
-When configuring Headroom's upstream endpoint:
-- In Headroom config (`headroom.yaml` or environment variables):
-  ```bash
-  ANTHROPIC_BASE_URL="http://127.0.0.1:3456"
-  OPENAI_BASE_URL="http://127.0.0.1:3456/v1"
-  ```
-- Point your CLI to Headroom's listening port (e.g. `http://127.0.0.1:8787`). Headroom compresses the prompt and forwards it to LLM Switcher on port `3456`.
-
-### B. RTK (Rust Token Killer / Repomix)
-- In RTK configuration or execution flags:
-  ```bash
-  # Ensure RTK's target upstream proxy is LLM Switcher
-  export UPSTREAM_URL="http://127.0.0.1:3456"
-  ```
-
-### C. Ponytail / Custom Proxies
-- Always set the proxy's upstream host to:
-  `http://127.0.0.1:3456` (or `http://127.0.0.1:3456/v1` for OpenAI-compatible tools).
-
-### D. Sub-Agents & Spawned Terminal Commands
-When an agent spawns sub-processes that call LLM CLIs:
-- **Never advise sourcing `env.sh` or `env.cmd`.** Those files carry no proxy variables any
-  more, so sourcing one changes nothing — and a stale variable an older version once wrote
-  would still point the tool at a port where nothing listens.
-- Run `switch claude <profile>` or `switch codex <profile>` instead. The shims in
-  `~/.llm-switcher/bin` inject the proxy variables into the tool process itself and clear
-  anything stale first.
-- `claude` and `codex` on `PATH` already are those shims: invoke them normally, and never
-  wrap them in another script.
-
-## 4. Operational Rules for AI Agents
-
-1. **NEVER edit `~/.claude/settings.json` directly.**
-   LLM Switcher uses zero-mutation launcher flags (`active.flag`). Writing custom base URLs or auth tokens into `settings.json` triggers warning banners in Claude Code and risks breaking the user's official subscription. Use `switch` CLI commands instead.
-2. **Check Gateway Health Before Complex Operations:**
-   Run `switch status` or call the `switcher_audit` MCP tool to confirm:
-   - LLM Switcher is active on port `3456`.
-   - The active profile matches the intended CLI target (Claude Code, Codex, or OpenAI).
-3. **Verify Routing When Errors Occur:**
-   If a tool fails with `HTTP 400`, `HTTP 502`, or connection errors:
-   - Run `switch doctor` to audit port collisions and environment variables.
-   - Inspect recent request logs via `http://127.0.0.1:3456/ui` (Tab 4: Live Inspector) to see if an intermediary tool mangled the payload.
+---
+name: llm-switcher
+description: Mandatory guidance for AI coding agents and token compression tools (Headroom, RTK, Ponytail, Repomix). Enforces routing all LLM traffic through the local LLM Switcher edge gateway (http://127.0.0.1:3456) instead of directly calling provider endpoints.
+---
+
+# LLM Switcher Edge Gateway Skill
+
+This skill governs how AI coding agents (Claude Code, Codex, Cursor, Windsurf, Opencode) and prompt optimization/compression tools (Headroom, RTK, Ponytail, Repomix) must interact with LLM providers on this workstation.
+
+## 1. The Core Directive
+
+> **ALL OUTBOUND LLM REQUESTS MUST ROUTE THROUGH LLM SWITCHER (`http://127.0.0.1:3456`).**
+> 
+> Never configure any tool, script, sub-agent, or token compression proxy to call external provider endpoints directly (such as `https://api.anthropic.com`, `https://api.openai.com`, or `https://generativelanguage.googleapis.com`).
+>
+> If a token compression tool (Headroom, RTK, Ponytail) is used, it MUST be positioned as an **inner processing layer**, and its **upstream destination MUST be configured to point to LLM Switcher** at `http://127.0.0.1:3456`.
+
+```
+[Client CLI / Agent]
+         │
+         ▼
+[Token Compressor: RTK / Headroom / Ponytail]  <-- Inner Layer
+         │
+         ▼ (MANDATORY: Upstream MUST point to http://127.0.0.1:3456)
+[LLM Switcher Edge Gateway (:3456)]            <-- Outermost Gatekeeper
+         │
+         ▼ (Heals schemas, maps 1M context, extracts thinking, converts protocol)
+[Internet / intact (Recommended) / 9Router / Upstream LLM]
+```
+
+## 2. Why This is Mandatory
+
+Direct outbound calls from token compressors will break the developer environment for several reasons:
+
+1. **Schema Breakage & The Healer Engine:**
+   Token optimizers frequently prune conversation history to save tokens. In doing so, they often delete an `assistant` turn containing a `tool_use`, while leaving the subsequent `user` turn containing a `tool_result`.
+   - Anthropic and OpenAI APIs strictly reject this with `HTTP 400 (orphaned tool_use_id)`.
+   - **LLM Switcher** intercepts these malformed requests and runs its **Healer Engine**, automatically converting orphaned results into safe context text blocks and merging consecutive same-role turns so upstream providers accept the payload cleanly.
+2. **Thinking / Reasoning Protection:**
+   Many token compressors naively strip `thinking` parameters or reasoning budgets to reduce token count.
+   - When routed through LLM Switcher, the gateway detects reasoning models (such as `ag/claude-opus-4-6-thinking` or `ag/gemini-3.8-flash`) and **automatically restores thinking parameters**, ensuring the model retains its full reasoning capabilities.
+3. **Official Context Windows & Dynamic Model Discovery:**
+   Context windows follow the model you select without mutating permanent settings. The gateway auto-discovers official models from Anthropic and OpenAI, refreshing mappings on tool version upgrades (`switch models`).
+4. **Server Gateway Synergy (intact / 9Router):**
+   LLM Switcher pairs directly with server-side gateways like **intact** (strongly recommended for credential proxying, account pooling, and contract lab self-healing) or 9Router, handling retries and quotas far better than any local tool.
+
+## 3. Configuring Token Compression Tools
+
+When setting up or assisting the user with token compression tools, apply these exact configurations:
+
+### A. Headroom (Prompt Compression Proxy)
+When configuring Headroom's upstream endpoint:
+- In Headroom config (`headroom.yaml` or environment variables):
+  ```bash
+  ANTHROPIC_BASE_URL="http://127.0.0.1:3456"
+  OPENAI_BASE_URL="http://127.0.0.1:3456/v1"
+  ```
+- Point your CLI to Headroom's listening port (e.g. `http://127.0.0.1:8787`). Headroom compresses the prompt and forwards it to LLM Switcher on port `3456`.
+
+### B. RTK (Rust Token Killer / Repomix)
+- In RTK configuration or execution flags:
+  ```bash
+  # Ensure RTK's target upstream proxy is LLM Switcher
+  export UPSTREAM_URL="http://127.0.0.1:3456"
+  ```
+
+### C. Ponytail / Custom Proxies
+- Always set the proxy's upstream host to:
+  `http://127.0.0.1:3456` (or `http://127.0.0.1:3456/v1` for OpenAI-compatible tools).
+
+### D. Sub-Agents & Spawned Terminal Commands
+When an agent spawns sub-processes that call LLM CLIs:
+- **Never advise sourcing `env.sh` or `env.cmd`.** Those files carry no proxy variables any
+  more, so sourcing one changes nothing — and a stale variable an older version once wrote
+  would still point the tool at a port where nothing listens.
+- Run `switch claude <profile>` or `switch codex <profile>` instead. The shims in
+  `~/.llm-switcher/bin` inject the proxy variables into the tool process itself and clear
+  anything stale first.
+- `claude` and `codex` on `PATH` already are those shims: invoke them normally, and never
+  wrap them in another script.
+
+## 4. Operational Rules for AI Agents
+
+1. **NEVER edit `~/.claude/settings.json` directly.**
+   LLM Switcher uses zero-mutation launcher flags (`active.flag`). Writing custom base URLs or auth tokens into `settings.json` triggers warning banners in Claude Code and risks breaking the user's official subscription. Use `switch` CLI commands instead.
+2. **Check Gateway Health Before Complex Operations:**
+   Run `switch status` or call the `switcher_audit` MCP tool to confirm:
+   - LLM Switcher is active on port `3456`.
+   - The active profile matches the intended CLI target (Claude Code, Codex, or OpenAI).
+3. **Verify Routing When Errors Occur:**
+   If a tool fails with `HTTP 400`, `HTTP 502`, or connection errors:
+   - Run `switch doctor` to audit port collisions and environment variables.
+   - Inspect recent request logs via `http://127.0.0.1:3456/ui` (Tab 4: Live Inspector) to see if an intermediary tool mangled the payload.

package/tests/classifier.test.mjs

@@ -0,0 +1,210 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import {
+  heuristicClassify,
+  findJevKey,
+  classifyPrompt,
+  checkSemanticEquivalence,
+  DEFAULT_JEV_URL,
+  OPENROUTER_JEV_URL,
+} from '../classifier.mjs';
+
+function createServer(handler) {
+  const server = http.createServer(handler);
+  return new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', () => {
+      const addr = server.address();
+      resolve({
+        url: `http://127.0.0.1:${addr.port}`,
+        close: () => new Promise((res) => server.close(res)),
+      });
+    });
+    server.on('error', reject);
+  });
+}
+
+describe('classifier module', () => {
+  describe('heuristicClassify', () => {
+    it('classifies complex tasks to opus', () => {
+      assert.equal(heuristicClassify('Design the system architecture for high throughput'), 'opus');
+      assert.equal(heuristicClassify('Find race condition in concurrent worker pool'), 'opus');
+      assert.equal(heuristicClassify('Conduct a security audit of our auth boundary'), 'opus');
+    });
+
+    it('classifies simple short tasks to haiku', () => {
+      assert.equal(heuristicClassify('Fix typo in comment'), 'haiku');
+      assert.equal(heuristicClassify('Format json output to string'), 'haiku');
+      assert.equal(heuristicClassify('Extract date from this line'), 'haiku');
+    });
+
+    it('defaults general programming tasks to sonnet', () => {
+      assert.equal(heuristicClassify('Refactor this helper function to accept options object and write tests'), 'sonnet');
+    });
+  });
+
+  describe('findJevKey', () => {
+    it('resolves TYPESAFE_API_KEY first', () => {
+      const res = findJevKey({ TYPESAFE_API_KEY: 'ts_key', JEV_API_KEY: 'jev_key' });
+      assert.deepEqual(res, { key: 'ts_key', source: 'typesafe' });
+    });
+
+    it('resolves JEV_API_KEY when TYPESAFE_API_KEY is absent', () => {
+      const res = findJevKey({ JEV_API_KEY: 'jev_key' });
+      assert.deepEqual(res, { key: 'jev_key', source: 'openrouter' });
+    });
+
+    it('returns null on empty env', () => {
+      assert.equal(findJevKey({}), null);
+    });
+  });
+
+  describe('classifyPrompt', () => {
+    it('returns heuristic tier with reason no-key when no key is present', async () => {
+      const res = await classifyPrompt({
+        prompt: 'Design architecture for database',
+        env: {},
+      });
+      assert.equal(res.tier, 'opus');
+      assert.equal(res.source, 'heuristic');
+      assert.equal(res.reason, 'no-key');
+    });
+
+    it('calls Jev endpoint and parses choice response', async () => {
+      let receivedAuth = null;
+      let receivedBody = null;
+
+      const server = await createServer(async (req, res) => {
+        receivedAuth = req.headers.authorization;
+        const chunks = [];
+        for await (const chunk of req) chunks.push(chunk);
+        receivedBody = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({
+            model: 'jev-latest',
+            answers: {
+              recommended_tier: {
+                choice: 'haiku',
+                confidence: 0.94,
+                distribution: { haiku: 0.94, sonnet: 0.05, opus: 0.01 },
+              },
+            },
+          }),
+        );
+      });
+
+      try {
+        const res = await classifyPrompt({
+          prompt: 'Translate hello to French',
+          apiKey: 'test-ts-key',
+          url: server.url,
+        });
+
+        assert.equal(res.tier, 'haiku');
+        assert.equal(res.confidence, 0.94);
+        assert.equal(res.source, 'jev');
+        assert.equal(res.model, 'jev-latest');
+        assert.equal(receivedAuth, 'Bearer test-ts-key');
+        assert.equal(receivedBody.state, 'Translate hello to French');
+        assert.ok('recommended_tier' in receivedBody.questions);
+      } finally {
+        await server.close();
+      }
+    });
+
+    it('falls back gracefully to heuristic on HTTP error', async () => {
+      const server = await createServer((req, res) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'internal error' }));
+      });
+
+      try {
+        const res = await classifyPrompt({
+          prompt: 'Fix typo',
+          apiKey: 'key',
+          url: server.url,
+        });
+
+        assert.equal(res.tier, 'haiku');
+        assert.equal(res.source, 'heuristic');
+        assert.equal(res.reason, 'http-500');
+      } finally {
+        await server.close();
+      }
+    });
+
+    it('falls back gracefully to heuristic on timeout', async () => {
+      const server = await createServer((req, res) => {
+        // Hang indefinitely
+      });
+
+      try {
+        const res = await classifyPrompt({
+          prompt: 'Fix typo',
+          apiKey: 'key',
+          url: server.url,
+          timeoutMs: 50,
+        });
+
+        assert.equal(res.tier, 'haiku');
+        assert.equal(res.source, 'heuristic');
+        assert.equal(res.reason, 'timeout');
+      } finally {
+        await server.close();
+      }
+    });
+  });
+
+  describe('checkSemanticEquivalence', () => {
+    it('returns exact-match immediately when strings match', async () => {
+      const res = await checkSemanticEquivalence({
+        candidate: 'What is Node.js?',
+        target: 'What is Node.js?',
+      });
+      assert.equal(res.equivalent, true);
+      assert.equal(res.confidence, 1.0);
+      assert.equal(res.reason, 'exact-match');
+    });
+
+    it('bypasses immediately with false when no key is configured', async () => {
+      const res = await checkSemanticEquivalence({
+        candidate: 'Say hello',
+        target: 'Greet me',
+        env: {},
+      });
+      assert.equal(res.equivalent, false);
+      assert.equal(res.reason, 'no-key-fallback-bypass');
+    });
+
+    it('evaluates Noul probability from Jev and confirms equivalence >= 0.85', async () => {
+      const server = await createServer(async (req, res) => {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({
+            model: 'jev-latest',
+            answers: {
+              is_equivalent: 0.92,
+            },
+          }),
+        );
+      });
+
+      try {
+        const res = await checkSemanticEquivalence({
+          candidate: 'How do I read a file in Node?',
+          target: 'Read file contents in NodeJS',
+          apiKey: 'test-key',
+          url: server.url,
+        });
+
+        assert.equal(res.equivalent, true);
+        assert.equal(res.confidence, 0.92);
+        assert.equal(res.reason, 'jev-confirmed');
+      } finally {
+        await server.close();
+      }
+    });
+  });
+});

package/tests/formats.test.mjs

@@ -802,3 +802,33 @@ test('an empty tool schema is healed, not forwarded as {}', () => {
   );
   assert.deepEqual(body.tools[0].function.parameters, { type: 'object', properties: {} });
 });
+
+// Structured output: a JSON schema the client asks the answer to follow must reach every upstream.
+const TITLE_SCHEMA = { type: 'object', properties: { title: { type: 'string' } }, required: ['title'], additionalProperties: false };
+
+test('structured output: Anthropic output_config.format reaches chat, Anthropic and Vertex upstreams', () => {
+  const ir = anthropicToIR({ model: 'x', max_tokens: 100, messages: [{ role: 'user', content: 'hi' }], tools: [],
+    output_config: { format: { type: 'json_schema', schema: TITLE_SCHEMA } } });
+  assert.deepEqual(irToChatBody(ir, 'm').response_format,
+    { type: 'json_schema', json_schema: { name: 'response', schema: TITLE_SCHEMA } });
+  assert.deepEqual(irToAnthropicBody(ir, 'm').output_config, { format: { type: 'json_schema', schema: TITLE_SCHEMA } });
+  const gc = irToVertexBody(ir, 'm').generationConfig;
+  assert.equal(gc.responseMimeType, 'application/json');
+  assert.deepEqual(gc.responseSchema, toGeminiSchema(TITLE_SCHEMA));
+  // The deprecated top-level field still works.
+  const old = anthropicToIR({ model: 'x', messages: [{ role: 'user', content: 'hi' }], output_format: { type: 'json_schema', schema: TITLE_SCHEMA } });
+  assert.equal(irToChatBody(old, 'm').response_format.json_schema.schema, TITLE_SCHEMA);
+});
+
+test('structured output: Responses text.format keeps name and strict; JSON mode and plain text', () => {
+  const resp = responsesToIR({ model: 'x', input: 'hi', text: { format: { type: 'json_schema', name: 'title', schema: TITLE_SCHEMA, strict: true } } });
+  assert.deepEqual(irToChatBody(resp, 'm').response_format,
+    { type: 'json_schema', json_schema: { name: 'title', schema: TITLE_SCHEMA, strict: true } });
+  const jm = responsesToIR({ model: 'x', input: 'hi', text: { format: { type: 'json_object' } } });
+  assert.deepEqual(irToChatBody(jm, 'm').response_format, { type: 'json_object' });
+  assert.equal(irToVertexBody(jm, 'm').generationConfig.responseMimeType, 'application/json');
+  assert.equal(irToAnthropicBody(jm, 'm').output_config, undefined);
+  const txt = responsesToIR({ model: 'x', input: 'hi', text: { format: { type: 'text' } } });
+  assert.equal(irToChatBody(txt, 'm').response_format, undefined);
+  assert.equal(irToVertexBody(txt, 'm').generationConfig, undefined);
+});