llm-relay 0.14.4 → 0.15.0

package/README.md

@@ -1,6 +1,6 @@
 # llm-relay
 
-A standalone, **loopback** Anthropic-Messages-API reverse proxy. It forwards `/v1/messages` to any backend model and **validates tool-call responses** against the request's `tools[].input_schema`, so the Claude Code harness (or any `ANTHROPIC_BASE_URL` client) can run on non-Anthropic models without pre-filtering them by tool competence.
+A standalone, **loopback** bidirectional LLM API proxy. It forwards Anthropic `/v1/messages` and OpenAI `/v1/chat/completions` or `/v1/responses` requests to any configured backend, translating protocols where needed. Anthropic responses still pass through the relay's **tool-call validation/repair** layer, so Claude Code and OpenAI-native clients can share the same routed providers.
 
 **The one boundary:** it fixes/flags *protocol form* (malformed tool calls), never *judgment* (bad reasoning).
 
@@ -10,6 +10,7 @@ A standalone, **loopback** Anthropic-Messages-API reverse proxy. It forwards `/v
 - **`detect` mode** — deterministic tool_use validation (Ajv2020) with metadata-only logging of pass/fail/uncheckable. Behavior is unchanged; it only observes.
 - **`repair` mode** — on a validation failure, a cheap reshaper model corrects the call, the result is **re-validated**, and the corrected response is re-emitted (JSON or freshly-serialized SSE). Destructive-tool calls are **refused, never fabricated**; unrepairable calls **fail-clean** (502). Valid calls pass through untouched. The refusal matches the tool **name exactly** (case-insensitively) — see [Destructive-tool refusal](#destructive-tool-refusal-repairdestructivetools) for which tools that now covers.
 - **OpenAI-compatible backends** (`backend.kind:"openai"`) — front NIM / vLLM / OpenRouter / LM Studio. Requests are translated Anthropic→OpenAI and responses back (streaming SSE + non-streaming) via [`llm-bridge`](https://github.com/supermemoryai/llm-bridge) (zero-dep). The validate/repair layer always sees Anthropic Messages, regardless of backend. Verified live end-to-end.
+- **Bidirectional OpenAI front** — `POST /v1/chat/completions` and `POST /v1/responses` work against both `kind:"openai"` and `kind:"anthropic"` targets. OpenAI Chat Completions remains byte-transparent to OpenAI backends; Responses and Anthropic targets use the same Anthropic-shaped translation seam, including streaming SSE and tool calls.
 - **Streaming repair** — text-block SSE frames stream to the client **as they arrive**; the proxy only withholds from the first `tool_use` block. A pure-text response is byte-for-byte passthrough with zero added latency; a valid tool call flushes the withheld frames verbatim; an invalid one is repaired with only the corrected trailing blocks re-emitted (`message_start` + leading text already delivered). A mid-stream repair failure surfaces as an SSE `error` event, never a fabricated call. Handles LF and CRLF frame delimiters and multibyte UTF-8 across chunk boundaries.
 
 ### Live demo (no external creds)
@@ -63,7 +64,7 @@ llm-relay
 - **Multi-Candidate Failover**: `routing.default` and every `routing.tiers` entry accept an **array** of target specs (e.g. `["nim/z-ai/glm-5.2", "groq/llama-3.3-70b"]`) for continuous fallback. ⚠ Ranking and failover both require **more than one** candidate — a single pinned model silently disables both, and on providers where a listed model may not actually be servable that turns one dead backend into a dead relay. Prefer arrays.
 - **Named pools** (`routing.pools`, addressed as `model: "pool/<name>"`): the same ranked-candidate behaviour for callers that can only send **one model string** — notably Claude Code subagent frontmatter. Lets an agent ask for *the best available coding model* instead of naming one. An unknown pool is a loud 400, never a silent fall-through.
 - **Passthrough targets**: a provider with `kind:"anthropic"` and **no `authEnv`** forwards the caller's own credentials untouched, so real Claude traffic stays on real Anthropic while `pool/*` requests route elsewhere — from the same proxy.
-- **Subagent offload** (`routing.offload` + `routing.subagents`): route Claude Code *subagents* to other providers while the human's own conversation stays on passthrough — with no agent files and no model ids in the prompt. **Off by default**; `llm-relay offload on` flips it without a restart, `llm-relay candidates` shows what to point it at. See below.
+- **Granular offload** (`routing.offload` + `routing.subagents`): independently route Claude, Codex, and future client requests to other providers. Each client can be limited to subagents or set to `scope: "all"` to reroute its main conversation too. **Off by default**; `llm-relay candidates` shows what to point it at. See below.
 
 ### 3. Prompt Token & Context Length Guardrails
 - Estimates the request's prompt token count (`estimateRequestTokens`) against the target model's context limit, read from the warm catalog cache (`cachedLimits()` — it never fetches, so a cold cache costs no round-trip on the request path).
@@ -88,7 +89,7 @@ llm-relay
 
 ### 6. Programmatic Telemetry & Quota Access for Claude
 - **Read-only HTTP endpoints**: `GET /telemetry` (live JSON metrics), `GET /registry` (full provider/routing/model catalog with quality scores), `GET /ping` (trigger health probe pass & mode summary), `GET /health` (diagnostic status), `GET /candidates` (the un-blended offload decision table).
-- **Mutating HTTP endpoints**: `GET|POST /offload` (read/flip the subagent-offload switch), `GET|POST /dispatch` (the dispatch ladder). ⚠ **Loopback is not authorization** — any page you visit can POST cross-origin to a loopback listener without a preflight, and these two write your `config.json` and steer lane order. They therefore reject a present-but-non-loopback `Origin` with 403, require `content-type: application/json` on a mutating request, and require a loopback `Host` (closing DNS rebinding). An **absent** `Origin` is allowed on purpose — that is what a CLI sends, and it is what keeps `llm-relay offload on` working against a running proxy with no restart.
+- **Mutating HTTP endpoints**: `GET|POST /offload` (read/set per-client offload rules), `GET|POST /dispatch` (the dispatch ladder). ⚠ **Loopback is not authorization** — any page you visit can POST cross-origin to a loopback listener without a preflight, and these two write your `config.json` and steer lane order. They therefore reject a present-but-non-loopback `Origin` with 403, require `content-type: application/json` on a mutating request, and require a loopback `Host` (closing DNS rebinding). An **absent** `Origin` is allowed on purpose — that is what a CLI sends, and it is what keeps targeted offload changes working against a running proxy with no restart.
 - **CLI Commands**: `llm-relay telemetry` outputs live telemetry metrics; `llm-relay models` lists live model catalogs with SWE-bench & quality scores; `llm-relay ping` performs live health & latency probes.
 - **Response Headers**: Proxy responses include `x-llm-relay-quota-percent`, `x-llm-relay-stability-score`, and `x-llm-relay-target`.
 
@@ -107,9 +108,9 @@ llm-relay
 | `llm-relay telemetry` | Output live JSON telemetry, stability scores, and quota metrics |
 | `llm-relay models [-p <name>] [-r]` | Query live `/models` catalog per provider (`-p` filter, `-r` force refresh) |
 | `llm-relay ping [-p <name>]` | Perform live health, latency & quota probe across providers |
-| `llm-relay offload [on\|off\|status]` | Read or flip the subagent-offload switch — applies to the next request, no restart |
+| `llm-relay offload [client] [on\|off\|status] [--scope subagents\|all]` | Read or change one client's offload rule; changes apply to the next request, no restart |
 | `llm-relay candidates [-p <name>]` | The un-blended offload decision table (capability, cost, live health, quota, breaker state) |
-| `llm-relay dispatch [lane] [-t <task>]` | Which lane to hand a whole delegated task to next; it returns the command, **you** run it (`-x <lane>` reports one spent) |
+| `llm-relay dispatch [lane] [-t <task>] [--client <name>]` | Which lane to hand a whole delegated task to next; it returns the command, **you** run it (`-x <lane>` reports one spent) |
 
 ---
 
@@ -138,6 +139,21 @@ llm-relay pools --probe
 handed straight to an AI assistant ("set this up for me"), covering free providers, the offload
 switch, local models, and using your other CLI subscriptions as fallback lanes.
 
+### Release publishing
+
+Releases publish through npm Trusted Publishing (GitHub Actions OIDC); no `NPM_TOKEN` is stored in
+the repository. After merging a version bump to `main`, push the matching tag:
+
+```bash
+git tag vX.Y.Z
+git push origin vX.Y.Z
+```
+
+`.github/workflows/publish.yml` accepts only `v*` tags from this repository, verifies that the tag
+is contained in the default branch and matches `package.json`, then publishes with npm 11.5.1+.
+The one-time setup also requires the npm trusted publisher to reference this repository and
+workflow, plus the protected GitHub `npm-publish` environment to carry its approval rules.
+
 ### Verifying a setup — two checks, two different questions
 
 `keys` answers *are my credentials good?* `pools --probe` answers *will the models I configured
@@ -164,8 +180,14 @@ directories: `~/.claude/skills/llm-relay/SKILL.md` for Claude Code and
 switch, `@relay:` directives, reading the candidates table, failure modes) cannot drift between
 hosts. Both refresh automatically on every upgrade; local/dev installs touch neither directory.
 
+The same global install also provisions local Codex: it adds the `llm-relay` Responses provider to
+`~/.codex/config.toml` and creates relay-backed `default` and `relay_coding` child agents under
+`~/.codex/agents/` when those files are absent. Existing Codex config and agent files are preserved.
+This keeps the parent on its normal provider while making generic or named child dispatches use the
+relay automatically.
+
 If your npm blocks unknown install scripts (`npm warn install-scripts … blocked`), allow this one —
-`npm config set allow-scripts=llm-relay --location=user` — or install the skill by hand:
+`npm config set allow-scripts=llm-relay --location=user` — or install the host integrations by hand:
 `node "$(npm root -g)/llm-relay/scripts/install-skill.mjs" --force`.
 
 ### Staying current
@@ -384,43 +406,51 @@ refusing safe calls. So:
 There is no built-in list inside the proxy: an empty `repair.destructiveTools` refuses nothing, so
 coverage is always traceable to your config.
 
-### Subagent offload (`routing.offload` + `routing.subagents`)
-
-Send Claude Code **subagents** to other providers while the human's own conversation stays on the
-Anthropic passthrough — without writing agent files and without naming a model.
+### Granular offload (`routing.offload` + `routing.subagents`)
 
-**Off by default.** Until you turn it on, subagents route exactly like everything else:
-
-```bash
-llm-relay offload on
-```
-
-That reaches the running proxy over loopback, so it applies to the next request without a restart,
-and is persisted to `config.json` so it survives one. `llm-relay offload status` shows the state and
-where each tier goes; `off` reverts.
+Offload rules are keyed by the originating harness. Claude requests use the `/v1/messages` front
+door; Codex requests use `/v1/responses`. Each rule is independent and chooses whether it applies
+to marked subagents only (the current behavior) or to the whole conversation:
 
 ```jsonc
 "routing": {
-  "offload":   false,   // master switch (default). `subagents` is inert until this is true.
   "tiers":     { "opus": "anthropic", "sonnet": "anthropic", "haiku": "anthropic", "fable": "anthropic" },
-  "subagents": { "opus": "pool/reasoning", "haiku": "pool/fast", "default": "pool/coding" }
+  "subagents": { "opus": "pool/reasoning", "haiku": "pool/fast", "default": "pool/coding" },
+  "offload": {
+    "claude": { "enabled": true,  "scope": "subagents" },
+    "codex":  { "enabled": false, "scope": "all" }
+  }
 }
 ```
 
-Why opt-in: offloading silently changes *which model answers* for every built-in agent (Explore,
-general-purpose, every one-off dispatch). That is worth deciding on purpose rather than inheriting
-from the presence of a config key.
+`scope: "subagents"` preserves the existing topology. `scope: "all"` also applies the same
+`routing.subagents` tier/default map to the client's main conversation, which is useful when a
+Claude or Codex quota is exhausted. Rules may use any future client name; an explicit `default`
+rule is the opt-in catch-all for otherwise unnamed front doors. All rules are off by default.
+
+The CLI changes one client without restarting the proxy:
+
+```bash
+llm-relay offload status
+llm-relay offload claude on --scope subagents
+llm-relay offload codex on --scope all
+llm-relay offload claude off
+```
+
+The old `llm-relay offload on|off` command remains a global compatibility switch for configs that
+still use the boolean form (`"offload": false`). `GET /offload?client=claude` reads one rule;
+`POST /offload` accepts `{"client":"claude","enabled":true,"scope":"all"}`. Changes are
+persisted and take effect on the next request.
 
 Claude Code stamps `cc_is_subagent=true` into the `system` block of subagent requests (built-in
-agents like Explore included — verified on the wire, Claude Code 2.1.220). llm-relay reads that flag
-and only then consults `routing.subagents`. **This is the entire reason the feature is safe.**
-Without the flag, a subagent asking for `haiku` and a human picking Haiku are byte-identical
-requests, so any tier→provider mapping silently drops the human's own conversation onto a weak
-model. `routing.tiers` therefore stays free to point at a passthrough.
+agents like Explore included — verified on the wire, Claude Code 2.1.220). Local Codex stamps
+`x-codex-turn-metadata: {"request_kind":"subagent",...}` on child-agent turns. A subagents-only
+rule requires that marker; an all-scope rule also accepts ordinary main-conversation requests.
+An explicit `@relay:` directive remains a subagent-only per-call opt-in, even when a client has an
+all-scope rule, so text in a human conversation cannot self-reroute it.
 
-A dispatcher then chooses a destination with the one per-call knob it already has — the Agent tool's
-`model` parameter (`sonnet|opus|haiku|fable`) — or by not choosing at all, in which case
-`subagents.default` applies and the pool's ranking picks the model.
+A dispatcher chooses a destination with the Agent tool's `model` parameter (`sonnet|opus|haiku|fable`)
+or, when it does not choose, `subagents.default` applies and the pool's ranking picks the model.
 
 **To pin an exact model for one call**, put a directive on its own line in the subagent's prompt:
 
@@ -438,9 +468,75 @@ authored prompt. Block 0 is Claude Code's injected `<system-reminder>` (your CLA
 …), and later messages carry tool results, i.e. file contents. Reading either would let any file a
 subagent happens to read redirect its own routing. Both cases are covered by tests.
 
-Precedence for a subagent request: `@relay:` directive → `subagents[<tier>]` →
-`subagents.default` → normal routing. The middle two apply only while `routing.offload` is on; omit
-`routing.subagents` entirely and nothing changes either way.
+Precedence for a marked subagent request: `@relay:` directive → `subagents[<tier>]` →
+`subagents.default` → normal routing. The map applies only when that request's client rule is
+enabled and its scope admits the request; omit `routing.subagents` entirely and nothing changes.
+
+#### Local Codex setup
+
+For the intended split, keep the parent Codex session on its normal provider and define a named
+child agent whose own Responses requests use llm-relay. A global `llm-relay` install creates the
+provider and agents below automatically. If npm lifecycle scripts were blocked, run the bundled
+installer manually with `--force`, or create the files yourself as follows.
+
+```toml
+[model_providers.llm-relay]
+name = "llm-relay"
+base_url = "http://127.0.0.1:8791/v1"
+wire_api = "responses"
+requires_openai_auth = true
+```
+
+Then create `~/.codex/agents/relay_coding.toml`:
+
+```toml
+name = "relay_coding"
+description = "Read-only coding child routed through llm-relay."
+developer_instructions = "Work read-only. Return a concise result to the parent and do not modify files."
+
+model_provider = "llm-relay"
+model = "pool/coding"
+model_reasoning_effort = "medium"
+```
+
+To make an unqualified child dispatch use the relay automatically, override Codex's built-in
+`default` agent with `~/.codex/agents/default.toml`:
+
+```toml
+name = "default"
+description = "General-purpose read-only child routed through llm-relay."
+developer_instructions = "Work read-only. Return a concise result to the parent and do not modify files."
+
+model_provider = "llm-relay"
+model = "pool/coding"
+model_reasoning_effort = "medium"
+```
+
+With that override, a normal “use a subagent” request keeps the parent native while the generic child
+goes through `pool/coding`; named agents can still select a different pool explicitly.
+
+Run Codex normally, without the `llm-relay` profile. Ask the parent to use exactly one subagent of
+type `relay_coding`; Codex keeps the parent on its normal provider and starts the child through the
+relay. The relay pool then chooses the configured provider and can fail over normally.
+
+Enable only Codex child offload in `~/.llm-relay/config.json`:
+
+```bash
+llm-relay offload codex on --scope subagents
+```
+
+To redirect the parent Codex conversation through the same relay as well, use
+`llm-relay offload codex on --scope all`. Claude's rule is unaffected.
+
+The `llm-relay` profile remains available as an explicit all-relay mode, but it routes the parent
+through the relay too and is not the split setup described above. The automatic
+`x-codex-turn-metadata` marker is still recognized when a Codex client sends it; using a relay pool
+as the named child model keeps the split setup reliable even when a custom-agent request omits that
+private marker.
+
+This applies to local Codex clients that can reach `127.0.0.1`. Hosted ChatGPT/Cloud tasks cannot
+reach a loopback relay, and the relay cannot spend a ChatGPT subscription on behalf of an upstream
+request; those remain separate CLI/client-bound dispatch lanes.
 
 Whole-task CLI dispatch can likewise vary by tier with `routing.ladders.{reasoning,coding,fast}`.
 Use `llm-relay dispatch --tier reasoning -t "..."`; without `--tier`, the ladder matching
@@ -575,12 +671,21 @@ coherent JSON view:
 The consumer then dispatches by pointing its OpenAI-compatible pool at :8791 and
 setting each packet's model to a **namespaced** `provider/model` (it picked the exact
 backend). llm-relay exposes an **OpenAI-compatible front** for exactly this —
-`POST /v1/chat/completions` (and `/chat/completions`): the request's `model` is routed
-by namespace/tier, rewritten to the backend id, and the upstream OpenAI response is
-returned verbatim (OpenAI in, OpenAI out — the Anthropic `/v1/messages` front with
-tool-call repair stays available in parallel for a Claude-harness client). Meanwhile a plain `claude` client that sends `claude-sonnet-…` still gets the
-**dumb tier/default routing** — both coexist, no mode switch. So the tier map stays the
-default, and dispatcher-style usage is just "send namespaced ids + read `/registry`".
+`POST /v1/chat/completions` (and `/chat/completions`) plus `POST /v1/responses`: the
+request's `model` is routed by namespace/tier. OpenAI-compatible targets receive the
+backend model id directly; Anthropic targets receive a translated `/v1/messages` request
+and their response is translated back to the caller's OpenAI envelope. Responses streaming,
+tool calls and usage are supported. The Anthropic `/v1/messages` front with tool-call repair
+stays available in parallel for a Claude-harness client. Meanwhile a plain `claude` client
+that sends `claude-sonnet-…` still gets the **dumb tier/default routing** — both coexist,
+no mode switch. So the tier map stays the default, and dispatcher-style usage is just
+"send namespaced ids + read `/registry`".
+
+OpenAI-native clients can point their base URL at `http://127.0.0.1:8791/v1` and use a
+namespaced model such as `anthropic/claude-sonnet-4-20250514` or `pool/coding`. Codex uses
+`/v1/responses`; other IDEs commonly use `/v1/chat/completions`. Configure the Anthropic
+provider with `kind: "anthropic"` and `authEnv: "ANTHROPIC_API_KEY"` when the relay should
+use its own key, or omit `authEnv` for an intentional caller-credential passthrough.
 
 ### Model tiers from leaderboards (never a hand-maintained table)
 
@@ -656,9 +761,9 @@ credentials byte-for-byte (`authorization`/`x-api-key` *and* `anthropic-beta`).
 model you pick therefore reaches real Anthropic untouched, while anything addressed as
 `pool/<name>` goes to another provider. One instance, both behaviours.
 
-⚠ **Do not route Codex through this.** headroom has a single OpenAI upstream covering both
-`/v1/chat/completions` and `/v1/responses`; Codex uses `/v1/responses` and must reach
-api.openai.com. Point `--anthropic-api-url` at llm-relay and leave `--openai-api-url` alone.
+⚠ **Do not route Codex through headroom.** headroom has a single OpenAI upstream covering both
+`/v1/chat/completions` and `/v1/responses`; when using headroom, Codex must reach api.openai.com.
+Codex can instead point directly at llm-relay, whose OpenAI front supports `/v1/responses`.
 
 Note the `claude-proxied` wrappers set `ANTHROPIC_BASE_URL` straight to :8791 with a dummy
 token and an isolated `CLAUDE_CONFIG_DIR`, so **they bypass headroom entirely** — they are for

package/config.example.json

@@ -88,7 +88,10 @@
       "fable": "pool/fast",
       "default": "pool/coding"
     },
-    "offload": false
+    "offload": {
+      "claude": { "enabled": false, "scope": "subagents" },
+      "codex": { "enabled": false, "scope": "subagents" }
+    }
   },
   "mode": "repair",
   "repair": {

package/dist/backend.d.ts

@@ -51,6 +51,15 @@ export declare function fetchBackend(target: ResolvedTarget, args: {
 }, fetchFn?: typeof fetch): Promise<Response>;
 /** Map a non-streaming OpenAI chat completion into an Anthropic message. */
 export declare function openAiResponseToAnthropic(j: Record<string, unknown>, model: string): object;
+export type OpenAiFrontProtocol = "chat" | "responses";
+/**
+ * Turn an Anthropic Message response into the response envelope expected by an OpenAI client.
+ *
+ * This is deliberately separate from llm-bridge's request translation. Provider request bodies
+ * and provider response bodies are different contracts, and treating a response as a request
+ * loses tool calls, stop reasons and usage on the way back to the caller.
+ */
+export declare function anthropicMessageToOpenAi(body: Record<string, unknown>, protocol: OpenAiFrontProtocol, fallbackModel?: string): Record<string, unknown>;
 /**
  * Coerce an upstream error body into the OpenAI error envelope — WITHOUT rewriting one that
  * already conforms.
@@ -73,18 +82,19 @@ export declare function openAiResponseToAnthropic(j: Record<string, unknown>, mo
  */
 export declare function normalizeOpenAiErrorBody(body: string, status: number): string | null;
 /**
- * OpenAI-compatible FRONT: an OpenAI `/chat/completions` request comes in, its `model`
- * has already been resolved to a provider target by namespace/tier routing. For an
- * openai-kind target this is a routing reverse-proxy — rewrite `model` to the backend
- * id, inject the backend key, and stream the upstream OpenAI response straight back
- * (OpenAI in, OpenAI out — no translation). This is the transport a dispatcher (e.g.
- * an external dispatcher) consumes to reach many backends behind one endpoint.
+ * OpenAI-compatible FRONT: an OpenAI Chat Completions or Responses request comes in, its
+ * `model` has already been resolved to a provider target by namespace/tier routing.
  *
- * anthropic-kind targets are not served on the OpenAI front (they need OpenAI↔Anthropic
- * translation and are not the dispatcher use case) — a clean 400, never a mistranslation.
+ * The common case remains a byte-transparent OpenAI→OpenAI Chat Completions proxy. The other
+ * combinations use the same Anthropic-shaped internal seam as the Messages front:
+ * OpenAI request → Anthropic request → resolved backend → Anthropic response → OpenAI response.
+ * That makes an Anthropic passthrough usable from Codex and OpenAI-native IDEs without changing
+ * the existing Claude client path.
  */
 export declare function fetchOpenAiFront(target: ResolvedTarget, args: {
     reqJson: unknown;
     wantsStream: boolean;
     signal: AbortSignal;
+    protocol?: OpenAiFrontProtocol;
+    anthropicHeaders?: Record<string, string>;
 }, fetchFn?: typeof fetch): Promise<Response>;

package/dist/backend.js

@@ -189,6 +189,144 @@ function openaiError(status, message, origin) {
         headers: { "content-type": "application/json", [ERROR_ORIGIN_HEADER]: origin },
     });
 }
+/**
+ * Turn an Anthropic Message response into the response envelope expected by an OpenAI client.
+ *
+ * This is deliberately separate from llm-bridge's request translation. Provider request bodies
+ * and provider response bodies are different contracts, and treating a response as a request
+ * loses tool calls, stop reasons and usage on the way back to the caller.
+ */
+export function anthropicMessageToOpenAi(body, protocol, fallbackModel = "") {
+    const content = Array.isArray(body.content) ? body.content : [];
+    const textParts = [];
+    const toolCalls = [];
+    for (const raw of content) {
+        if (typeof raw !== "object" || raw === null)
+            continue;
+        const block = raw;
+        if (block.type === "text" && typeof block.text === "string") {
+            textParts.push(block.text);
+        }
+        else if (block.type === "tool_use") {
+            const input = block.input ?? {};
+            toolCalls.push({
+                id: typeof block.id === "string" ? block.id : `tool_call_${toolCalls.length}`,
+                type: "function",
+                function: {
+                    name: typeof block.name === "string" ? block.name : "",
+                    arguments: typeof input === "string" ? input : JSON.stringify(input),
+                },
+            });
+        }
+    }
+    const text = textParts.join("");
+    const model = typeof body.model === "string" && body.model ? body.model : fallbackModel;
+    const usage = openAiUsage(body.usage);
+    if (protocol === "chat") {
+        const message = {
+            role: "assistant",
+            content: text || null,
+        };
+        if (toolCalls.length > 0)
+            message.tool_calls = toolCalls;
+        const out = {
+            id: typeof body.id === "string" ? body.id : "chatcmpl_relay",
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [{
+                    index: 0,
+                    message,
+                    finish_reason: openAiFinishReason(body.stop_reason, toolCalls.length > 0),
+                }],
+        };
+        if (usage)
+            out.usage = withOpenAiTotal(usage);
+        return out;
+    }
+    const output = [];
+    if (text) {
+        output.push({
+            type: "message",
+            id: `msg_${typeof body.id === "string" ? body.id : "relay"}`,
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text, annotations: [] }],
+        });
+    }
+    for (const call of toolCalls) {
+        const fn = call.function;
+        output.push({
+            type: "function_call",
+            id: `fc_${call.id}`,
+            call_id: call.id,
+            name: fn.name,
+            arguments: fn.arguments,
+            status: "completed",
+        });
+    }
+    const out = {
+        id: typeof body.id === "string" ? body.id : "resp_relay",
+        object: "response",
+        created_at: Math.floor(Date.now() / 1000),
+        status: "completed",
+        model,
+        output,
+        output_text: text,
+    };
+    if (usage)
+        out.usage = withOpenAiTotal(usage);
+    return out;
+}
+function openAiUsage(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return null;
+    const usage = raw;
+    // A usage object with no numeric fields is not a measurement. Keep the relay's unknown-vs-zero
+    // convention instead of manufacturing a cost report for an upstream that omitted usage.
+    if (typeof usage.input_tokens !== "number" && typeof usage.output_tokens !== "number")
+        return null;
+    return {
+        ...(typeof usage.input_tokens === "number" ? { prompt_tokens: usage.input_tokens } : {}),
+        ...(typeof usage.output_tokens === "number" ? { completion_tokens: usage.output_tokens } : {}),
+    };
+}
+function withOpenAiTotal(usage) {
+    if (typeof usage.prompt_tokens === "number" && typeof usage.completion_tokens === "number") {
+        return { ...usage, total_tokens: usage.prompt_tokens + usage.completion_tokens };
+    }
+    return { ...usage };
+}
+function openAiFinishReason(stopReason, hasToolCalls) {
+    if (hasToolCalls || stopReason === "tool_use")
+        return "tool_calls";
+    if (stopReason === "max_tokens")
+        return "length";
+    if (stopReason === "content_filter")
+        return "content_filter";
+    return "stop";
+}
+/** Map an Anthropic error envelope to a client-readable OpenAI error envelope. */
+function anthropicErrorToOpenAi(body, status) {
+    try {
+        const parsed = JSON.parse(body);
+        if (typeof parsed === "object" && parsed !== null) {
+            const top = parsed;
+            const nested = typeof top.error === "object" && top.error !== null ? top.error : null;
+            if (nested && typeof nested.message === "string") {
+                return JSON.stringify({ error: {
+                        message: nested.message,
+                        type: typeof nested.type === "string" ? nested.type : "upstream_error",
+                        ...(nested.code !== undefined ? { code: nested.code } : {}),
+                    } });
+            }
+        }
+    }
+    catch {
+        // Fall through to the normalizer, which preserves a useful bounded text message.
+    }
+    return normalizeOpenAiErrorBody(body, status) ?? body;
+}
 /**
  * Coerce an upstream error body into the OpenAI error envelope — WITHOUT rewriting one that
  * already conforms.
@@ -242,27 +380,75 @@ function buildTargetHeaders(target) {
     };
 }
 /**
- * OpenAI-compatible FRONT: an OpenAI `/chat/completions` request comes in, its `model`
- * has already been resolved to a provider target by namespace/tier routing. For an
- * openai-kind target this is a routing reverse-proxy — rewrite `model` to the backend
- * id, inject the backend key, and stream the upstream OpenAI response straight back
- * (OpenAI in, OpenAI out — no translation). This is the transport a dispatcher (e.g.
- * an external dispatcher) consumes to reach many backends behind one endpoint.
+ * OpenAI-compatible FRONT: an OpenAI Chat Completions or Responses request comes in, its
+ * `model` has already been resolved to a provider target by namespace/tier routing.
  *
- * anthropic-kind targets are not served on the OpenAI front (they need OpenAI↔Anthropic
- * translation and are not the dispatcher use case) — a clean 400, never a mistranslation.
+ * The common case remains a byte-transparent OpenAI→OpenAI Chat Completions proxy. The other
+ * combinations use the same Anthropic-shaped internal seam as the Messages front:
+ * OpenAI request → Anthropic request → resolved backend → Anthropic response → OpenAI response.
+ * That makes an Anthropic passthrough usable from Codex and OpenAI-native IDEs without changing
+ * the existing Claude client path.
  */
 export async function fetchOpenAiFront(target, args, fetchFn = fetch) {
-    if (target.kind !== "openai") {
-        return openaiError(400, `llm-relay: OpenAI front requires an openai-kind provider; "${target.provider}" is ${target.kind}`, "local");
-    }
+    const protocol = args.protocol ?? "chat";
     const base = (args.reqJson ?? {});
-    const body = { ...base, model: target.model, stream: args.wantsStream };
-    return fetchFn(target.base + "/chat/completions", {
+    // Preserve the existing direct path for the protocol/backend pair that already speaks the
+    // same wire format. It keeps provider-specific OpenAI fields byte-for-byte intact.
+    if (target.kind === "openai" && protocol === "chat") {
+        const body = { ...base, model: target.model, stream: args.wantsStream };
+        return fetchFn(target.base + "/chat/completions", {
+            method: "POST",
+            headers: buildTargetHeaders(target),
+            body: JSON.stringify(body),
+            signal: args.signal,
+        });
+    }
+    let anthropicBody;
+    try {
+        const source = protocol === "responses" ? "openai-responses" : "openai";
+        anthropicBody = translateBetweenProviders(source, "anthropic", base);
+        if (target.model !== undefined)
+            anthropicBody.model = target.model;
+        anthropicBody.stream = args.wantsStream;
+    }
+    catch (e) {
+        return openaiError(400, `llm-relay: request translation failed: ${e.message}`, "local");
+    }
+    const reqBuf = Buffer.from(JSON.stringify(anthropicBody), "utf8");
+    const backendRes = await fetchBackend(target, {
+        path: "/v1/messages",
         method: "POST",
-        headers: buildTargetHeaders(target),
-        body: JSON.stringify(body),
+        reqBuf,
+        reqJson: anthropicBody,
+        anthropicHeaders: args.anthropicHeaders ?? {},
+        wantsStream: args.wantsStream,
         signal: args.signal,
-    });
+    }, fetchFn);
+    if (!backendRes.ok) {
+        const raw = await backendRes.text().catch(() => "");
+        const origin = errorOrigin(backendRes) ?? "upstream";
+        const headers = {
+            "content-type": "application/json",
+            [ERROR_ORIGIN_HEADER]: origin,
+            ...retryAfterHeader(backendRes.headers),
+        };
+        return new Response(anthropicErrorToOpenAi(raw, backendRes.status), { status: backendRes.status, headers });
+    }
+    const streamed = args.wantsStream || (backendRes.headers.get("content-type") ?? "").includes("text/event-stream");
+    if (streamed && backendRes.body) {
+        const targetProtocol = protocol === "responses" ? "openai-responses" : "openai";
+        const output = handleUniversalStreamRequest(backendRes.body, "anthropic", targetProtocol);
+        return new Response(output, { status: backendRes.status, headers: { "content-type": "text/event-stream" } });
+    }
+    try {
+        const body = (await backendRes.json());
+        return new Response(JSON.stringify(anthropicMessageToOpenAi(body, protocol, target.model ?? String(base.model ?? ""))), {
+            status: backendRes.status,
+            headers: { "content-type": "application/json" },
+        });
+    }
+    catch (e) {
+        return openaiError(502, `llm-relay: response translation failed: ${e.message}`, "local");
+    }
 }
 //# sourceMappingURL=backend.js.map