pi-freeflow 1.38.2 → 1.38.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.38.4
+
+### Patch Changes
+
+- A relay that the upstream free-tier gate rejects can no longer wedge the pool: when a relay forwards back a 403 the relay itself is marked failed and the request rolls to the next candidate (or the direct route), instead of that 403 being recorded as a healthy verdict and pinning the relay as the pool's primary. The machine-wide upstream gate now only trips when the direct route is refused too, so one incompatible relay cannot fail everyone over.
+
+  Deploying a relay now proves inference through it, not just that its models list answers: the completion message verifies a real free-tier request and, when that fails, says so plainly — including the known Deno Deploy case (its platform rewrites the outbound User-Agent, so OpenCode Zen rejects traffic from it while Kilo still works). Deno Deploy deployments also resolve their public URL from the current API response again, so the deploy flow ends with a usable relay address instead of a "could not determine the public URL" error.
+
+## 1.38.3
+
+### Patch Changes
+
+- Absorb tool-call argument fragments arriving on terminal finish_reason chunks into buffered prefixes to prevent argument rotation and corrupted JSON loops. Add Reflection AI's Beam Free (1M context) to the OpenCode Zen lineup, and retire deprecated LL Alpha and Muse Spark 1.3 contributor free models.
+
 ## 1.38.2
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # pi-freeflow
 
-> 37 free models with up to 1M context. No API keys to manage. Add your own relays to spread requests across more IPs.
+> 36 free models with up to 1M context. No API keys to manage. Add your own relays to spread requests across more IPs.
 
 Thin by design: a model list, a relay proxy, and a log. The host (`pi-ai`) handles thinking, normalization, and provider behavior.
 
@@ -16,8 +16,8 @@ Thin by design: a model list, a relay proxy, and a log. The host (`pi-ai`) handl
 
 | Feature | What it does | Cost |
 | :--- | :--- | :--- |
-| **37 free models** | 14 from OpenCode Zen, 13 from KiloCode Gateway, 2 from Cline, 8 from OVHcloud AI Endpoints, context windows up to 1M. Full list below. | **$0** |
-| **Relay pool** | Route requests through your own Cloudflare Workers, Deno Deploy, and Vercel Edge relays. Traffic spreads across the pool, or stays on one sticky relay. A relay that rate-limits, times out, or drops the connection cools down while healthy ones take its traffic. | **$0** beyond your platforms' free tiers |
+| **36 free models** | 13 from OpenCode Zen, 13 from KiloCode Gateway, 2 from Cline, 8 from OVHcloud AI Endpoints, context windows up to 1M. Full list below. | **$0** |
+| **Relay pool** | Route requests through your own relays: a self-hosted egress pool (many egress IPs on one small host) or Cloudflare Workers / Deno Deploy / Vercel Edge workers. Traffic spreads across the pool, or stays on one sticky relay. A relay that rate-limits, times out, or drops the connection cools down while healthy ones take its traffic. | **$0** beyond your host or platforms' free tiers |
 | **Automatic fallback** | When every relay is cooling down, requests go direct to upstream instead of failing. | **$0** |
 | **Short model names** | Most models have a slash-free, colon-free alias, plus an optional `:effort` suffix for thinking depth. You type `freeflow/<name>`; the two Cline models have no alias and must be typed in full. | **$0** |
 | **Shared local proxy** | One daemon on `127.0.0.1:28180` serves every session on the machine, so parallel subagents reuse it instead of opening their own connections. | **$0** |
@@ -75,27 +75,50 @@ supported). The host resolves the rest.
 ### Add relays
 
 The default setup talks to upstream directly. Add relays when shared IPs start
-hitting rate limits. The fastest path is guided deploy: run
-`/freeflow deploy cloudflare` (or `deno`, `vercel`), paste your platform token
-once when asked, and the relay is created and added to your pool. The token
-stays in memory and is never written to disk.
+hitting rate limits — the OpenCode Zen free tier counts them per egress IP, so
+how many dedicated egress addresses you control decides how much you can run at
+once.
 
-Manual fallback per platform:
+**Option A: Self-hosted WARP relay pool (recommended for OpenCode Zen)**
+
+One Linux VPS runs a pool of isolated Cloudflare WARP egress addresses with
+automatic rotation of rate-limited IPs — [trefeon/warp-relay-pool](https://github.com/trefeon/warp-relay-pool):
 
-**Option A: Cloudflare Workers, auto deploy (recommended)**
+```bash
+git clone https://github.com/trefeon/warp-relay-pool.git
+cd warp-relay-pool && ./setup.sh
+```
+
+- **Many egress IPs, tiny footprint**: each relay node is ~1.8 MiB of RAM; the
+  default five-relay pool fits a 512 MB VPS (~50 MB of stack over a private
+  mesh-VPN URL, ~160 MB with public tunnel URLs).
+- **Auto-rotation**: a background service probes each egress for HTTP 429 and
+  rotates only the throttled node — the rest of the pool keeps serving and your
+  client URLs stay put.
+- **No platform quotas, no request rewriting**: your host's bandwidth, and
+  requests arrive upstream with the client's own fingerprint.
+- **Same contract as edge relays**: implements `x-relay-target`, so it can sit
+  in a pool alongside worker deployments.
+- The setup wizard prints ready-to-paste `/freeflow add <url> <label>` commands;
+  pair the pool with `/freeflow spread` so parallel sessions and subagents land
+  on different egress IPs.
+
+**Option B: Cloudflare Workers, auto deploy (zero-infra)**
 ```bash
 /freeflow deploy cloudflare  # prompts token in-memory, auto-adds to pool
 # or /freeflow deploy with no argument to pick the platform interactively
 ```
 Manual fallback: `dash.cloudflare.com` → Workers → Create → Deploy → Edit code → paste the canonical worker source (see below) → Deploy → `/freeflow add https://your.workers.dev cf-worker-1`
 
-**Option B: Deno Deploy, auto deploy**
+**Option C: Deno Deploy, auto deploy (Kilo models only)**
 ```bash
 /freeflow deploy deno  # prompts token in-memory, auto-adds to pool
 ```
 Manual fallback: `dash.deno.com` → New Project → Playground → paste the canonical worker source (see below) → Deploy → `/freeflow add https://your-project.deno.dev deno-relay-1`
 
-**Option C: Vercel Edge Relay (last resort, paid plan only)**
+Deno Deploy rewrites the outbound `User-Agent` at the platform layer, so OpenCode Zen free-tier traffic through a Deno relay is refused with `403 FreeTierError`; Kilo models still work. The deploy flow warns up front and its post-deploy inference probe reports what the relay can actually serve.
+
+**Option D: Vercel Edge Relay (last resort, paid plan only)**
 ```bash
 /freeflow deploy vercel  # prompts token in-memory, auto-adds to pool
 ```
@@ -108,18 +131,6 @@ For `api/relay.js`, use the canonical worker source (see below); `vercel.json` s
 { "rewrites": [{ "source": "/(.*)", "destination": "/api/relay" }] }
 ```
 
-**Option D: Self-Hosted WARP Relay on VPS (1GB VPS friendly)**
-
-If you have a Linux VPS (even a low-spec 1GB RAM instance), you can self-host a dedicated egress relay pool using [trefeon/warp-relay-pool](https://github.com/trefeon/warp-relay-pool):
-- **1GB VPS friendly**: Lightweight footprint designed to run comfortably on low-resource VPS nodes.
-- **Rotating Cloudflare WARP egress**: Automatically rotates outbound IPs so upstream rate limits don't block your sessions.
-- **Full protocol compatibility**: Implements the `x-relay-target` contract used by pi-freeflow.
-
-Once deployed on your VPS, register it in your relay pool:
-```bash
-/freeflow add https://your-vps:port vps-warp-relay
-```
-
 **Canonical worker source (all platforms)**
 
 The relay worker template is generated per deployment by `/freeflow deploy`, with one shared core adapted for Vercel, Cloudflare, and Deno. Every deploy embeds a random 32-byte secret, and the generated worker answers `401` to any request without a matching `x-relay-auth` header; the client sends that secret to each relay in the pool. Only a hand-pasted legacy worker built without a secret is open to anyone. Either way, a relay forwards only to an allowlist (`https://opencode.ai`, `https://api.kilo.ai`) with private-host and path checks.
@@ -197,14 +208,14 @@ The same command set works identically in OMP and Pi:
 
 ---
 
-### 37 models, one command
+### 36 models, one command
 
 ```bash
 /model → freeflow → pick
 ```
 
 Every model specification is reconciled against [models.dev](https://models.dev/), [OpenRouter](https://openrouter.ai/), and OMP's built-in catalog, configured with the highest verified context, output ceiling, and reasoning capabilities across twin models.
-#### OpenCode Zen (14 models), Responses and Chat API
+#### OpenCode Zen (13 models), Responses and Chat API
 
 Good defaults for long coding sessions and agentic work.
 
@@ -212,7 +223,6 @@ Good defaults for long coding sessions and agentic work.
 | :--- | :--- | :--- | :--- | :--- | :--- |
 | `cat-jam-free` | Cat Jam | **256K** (262.144) | **131K** (131.072) | `low … max` | ❌ |
 | `muse-spark-1.2-contributor-free` | Meta Superintelligence Labs | **1M** (1.048.576) | **131K** (131.072) | `minimal … xhigh` | ✅ |
-| `muse-spark-1.3-contributor-free` | Meta Superintelligence Labs | **1M** (1.048.576) | **131K** (131.072) | `minimal … xhigh` | ✅ |
 | `mimo-v2.6-flash-free` | Xiaomi MiMo | **1M** (1.048.576) | **131K** (131.072) | `minimal … xhigh`\* | ✅ |
 | `nemotron-3.5-lightning-free` | NVIDIA | **1M** (1.000.000) | **262K** (262.144) | `minimal … xhigh` | ❌ |
 | `nemotron-3.5-super-vl-free` | NVIDIA | **1M** (1.000.000) | **131K** (131.072) | `minimal … xhigh` | ✅ |
@@ -221,7 +231,7 @@ Good defaults for long coding sessions and agentic work.
 | `space-bunny-free` | Stealth preview (lab undisclosed) | **1M** (1.048.576) | **512K** (524.288) | `low … max` | ✅ |
 | `longcat-2.5-preview-free` | Meituan LongCat | **1M** (1.000.000) | **131K** (131.072) | `minimal … max` | ✅ |
 | `glm-5.3-flash-free` | Zhipu AI | **1M** (1.000.000) | **32K** (32.000) | `minimal … max` | ✅ |
-| `ll-alpha-free` | Undisclosed | **262K** (262.144) | **64K** (65.536) | `low … max` | ❌ |
+| `beam-free` | Reflection AI | **1M** (1.048.576) | **131K** (131.072) | `low … max` | ❌ |
 | `exo-free` | Undisclosed | **1M** (1.048.576) | **131K** (131.072) | `high` | ✅ |
 | `deepseek-v4.1-flash-free` | DeepSeek | **1M** (1.000.000) | **384K** (384.000) | `minimal … max` | ✅ |
 
@@ -368,7 +378,7 @@ pnpm smoke       # verifies extensions/index.ts loads without crashing
 #### Project structure
 
 ```
-├── models.ts                # 37-model catalog definitions
+├── models.ts                # 36-model catalog definitions
 ├── index.ts                 # extension entry, lifecycle hooks
 ├── catalog.ts               # model catalog cache (24h disk)
 ├── proxy.ts                 # local proxy server (127.0.0.1:28180)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-freeflow",
   "type": "module",
-  "version": "1.38.2",
+  "version": "1.38.4",
   "description": "Thin provider for OMP/Pi — model list + dumb relay proxy + log; host pi-ai owns thinking/normalization",
   "main": "extensions/index.ts",
   "types": "src/index.ts",

package/src/catalog.ts

@@ -124,6 +124,12 @@ export const DEAD_MODEL_IDS = new Set<string>([
  // answers 401 PAID_MODEL_AUTH_REQUIRED while the sibling z-ai/glm-5.3-flash
  // answers 200 keyless with the same request shape.
  "stepfun/step-5-preview-free",
+ // ll-alpha-free: decommissioned upstream (2026-10-17) — gone from live
+ // Zen /v1/models list, answers HTTP 410 "Model ll-alpha-free has been deprecated".
+ "ll-alpha-free",
+ // muse-spark-1.3-contributor-free: decommissioned upstream (2026-10-17) — gone from
+ // live Zen /v1/models list, answers HTTP 410 "Model muse-spark-1.3-contributor-free has been deprecated".
+ "muse-spark-1.3-contributor-free",
 ]);
 /**
  * Free-tier allowlist for anything entering the picker via network or stale disk.
@@ -163,7 +169,7 @@ export function sanitizeCatalogModels(models: RegisteredModel[]): RegisteredMode
 }
 /**
  * In-memory cache of currently active/available free models.
- * Initialized with all 37 verified models for 0ms instant availability.
+ * Initialized with all 36 verified models for 0ms instant availability.
  */
 let aliveCatalog: RegisteredModel[] = ALL_MODELS.map((m) => ({
  ...m,

package/src/commands.ts

@@ -728,6 +728,15 @@ export function createCommandSpec(
        ? "Deno Deploy relay — token: dash.deno.com → Access Tokens"
        : "Vercel relay — token: vercel.com/account/tokens";
     ctx.ui.notify(tokenHint, "info");
+    if (platform === "deno") {
+     // Verified 2026-10-17: Deno Deploy rewrites the outbound User-Agent at the
+     // platform layer, so OpenCode Zen's free tier rejects every request that
+     // rides this relay. Warn before spending a token on a Zen-only deployment.
+     ctx.ui.notify(
+      "⚠ Deno Deploy rewrites outbound User-Agent: OpenCode Zen free-tier requests through this relay are rejected (403 FreeTierError). It can still serve Kilo models — prefer Cloudflare for Zen.",
+      "warning",
+     );
+    }
     const token = (
      await ctx.ui.input(`${label} API token:`, "")
     )?.trim();
@@ -812,9 +821,31 @@ export function createCommandSpec(
         );
        },
       });
-      probeNote = probe.ok
-       ? ` ✓ reachable (HTTP ${probe.status}, ${probe.latencyMs}ms)`
-       : ` ⚠ deployed but unreachable (${probe.error || `HTTP ${probe.status}`}) — run /freeflow test ${finalUrl} to retry, or /freeflow remove ${finalUrl} to drop it`;
+      if (!probe.ok) {
+       probeNote = ` ⚠ deployed but unreachable (${probe.error || `HTTP ${probe.status}`}) — run /freeflow test ${finalUrl} to retry, or /freeflow remove ${finalUrl} to drop it`;
+      } else {
+       // Reachability is not enough: a relay can answer /v1/models while its
+       // egress is transformed in flight (Deno Deploy rewrites the outbound
+       // User-Agent), and OpenCode Zen then rejects the real traffic. The chat
+       // probe carries the full free-tier fingerprint + tools + stream, so it
+       // fails exactly when Zen inference through this relay would.
+       const chat = await probeRelay(finalUrl, auth, {
+        endpoint: "chat",
+        retries: 1,
+        retryDelayMs: retryDelay,
+       });
+       if (chat.ok) {
+        probeNote = ` ✓ reachable + free-tier inference verified (HTTP ${chat.status}, ${chat.latencyMs}ms)`;
+       } else {
+        // The Deno User-Agent rewrite only explains the free-tier gate; a
+        // timeout or a 5xx must report what was actually observed instead.
+        const denoGate = platform === "deno" && chat.status === 403;
+        const reason = denoGate
+         ? "— Deno Deploy rewrites the outbound User-Agent, which OpenCode Zen rejects; Kilo models still work through this relay"
+         : `(${chat.error || `HTTP ${chat.status}`}) — this relay cannot serve OpenCode Zen traffic (its egress is transformed in flight)`;
+        probeNote = ` ⚠ reachable, but the free-tier inference probe failed ${reason}. Run /freeflow test ${finalUrl} --chat to re-check, or /freeflow remove ${finalUrl} to drop it`;
+       }
+      }
      } catch {
       // probeRelay never throws, but keep the notify safe regardless
      }

package/src/deploy.ts

@@ -488,18 +488,45 @@ export async function deployCloudflareWorker(
  return { url, auth: relayAuth };
 }
 
+type DenoTimeline = {
+ /** Live v2 shape: display name, e.g. "Production". */
+ name?: string;
+ /** Live v2 shape: routing context ("Production" / "Preview"). */
+ context?: string;
+ /** Live v2 shape: hostnames routed to this timeline. */
+ hostnames?: string[];
+ /** Legacy shape retained for older API responses. */
+ slug?: string;
+ domains?: Array<{ domain?: string }>;
+};
+
 type DenoRevision = {
  status?: string;
  failure_reason?: string | null;
- timelines?: Array<{ slug?: string; domains?: Array<{ domain?: string }> }>;
+ timelines?: DenoTimeline[];
 };
 
+/** The v2 API labels the production timeline via `name`/`context` (legacy: `slug`). */
+function isProductionTimeline(t: DenoTimeline): boolean {
+ return [t.name, t.context, t.slug].some(
+  (v) => typeof v === "string" && v.trim().toLowerCase() === "production",
+ );
+}
+
+/**
+ * Resolve the hostname routed to the production timeline of a revision.
+ * The live v2 API answers `timelines[].hostnames` (e.g. `app-org.deno.net`);
+ * older responses carried `slug` + `domains: [{ domain }]`. Both are read,
+ * preferring whichever timeline is marked production, else the first one.
+ */
 function resolveRoutedDomain(revision: DenoRevision): string | null {
  const timelines = revision.timelines ?? [];
- const production = timelines.find((t) => t.slug === "production") ?? timelines[0];
- const host = (production?.domains ?? [])
-  .map((d) => d.domain ?? "")
-  .find((h) => h.length > 0);
+ const production = timelines.find(isProductionTimeline) ?? timelines[0];
+ if (!production) return null;
+ const host = [
+  ...(production.hostnames ?? []),
+  ...(production.domains ?? []).map((d) => d.domain ?? ""),
+ ].find((h) => typeof h === "string" && h.length > 0);
  return host ?? null;
 }
 

package/src/models.ts

@@ -1,8 +1,8 @@
 /**
  * Static model definitions and upstream routing catalogs for pi-freeflow
  *
- * Defines the 37 verified free models (live-verified 2026-10-16):
- * - 14 OpenCode Zen models (2 Responses API + 12 Chat Completions)
+ * Defines the 36 verified free models (live-verified 2026-10-17):
+ * - 13 OpenCode Zen models (1 Responses API + 12 Chat Completions)
  * - 13 KiloCode Keyless Gateway models (OpenRouter format)
  * - 2 Cline direct-only models (per-user pool)
  * - 8 OVHcloud AI Endpoints models (keyless, direct-only)
@@ -59,24 +59,6 @@ export const OPENCODE_MODELS: ModelDef[] = [
    max: null,
   },
  },
- {
-  id: "muse-spark-1.3-contributor-free",
-  name: "Muse Spark 1.3 [OpenCode]",
-  reasoning: true,
-  contextWindow: 1_048_576,
-  maxTokens: 131_072,
-  api: "openai-responses",
- input: ["text", "image", "video"],
-  thinkingLevelMap: {
-   off: null,
-   minimal: "minimal",
-   low: "low",
-   medium: "medium",
-   high: "high",
-   xhigh: "xhigh",
-   max: null,
-  },
- },
  {
   id: "mimo-v2.6-flash-free",
   name: "MiMo V2.6 Flash [OpenCode]",
@@ -251,23 +233,20 @@ export const OPENCODE_MODELS: ModelDef[] = [
   },
  },
  {
-  // Added 2026-10-16 (issue #71 drift): Zen v1.19.2 added this free id.
-  // Specs agree across pi.dev and models.dev (262,144 ctx / 65,536 max,
-  // text-only) and the boundary probe matches: a marker at 90% depth is
-  // recalled at ~220K words and the gateway refuses ~250K words (400), with
-  // a silent no-recall at ~240K — the window ends right about there.
-  // maxTokens 65,536 published; the gateway accepted 131,072, which is
-  // acceptance, not a cap. Effort ladder: low/medium/high/xhigh/max probed
-  // 200 with visibly different reasoning lengths; `minimal` answers 200 too
-  // but stays hidden because the published ladder starts at low (same class
-  // as nemotron's tolerated-but-hidden `max`); `off` is null like everywhere.
-  // Chat-only (/v1/responses 400 protocol). Text-only: an image probe
-  // produced no answer.
-  id: "ll-alpha-free",
-  name: "LL Alpha [OpenCode]",
+  // Added 2026-10-17: Reflection AI's Beam 501B open-weight MoE model (23B active),
+  // added as a limited-time free model on OpenCode Zen (/zen/v1/models: beam-free).
+  // Live-probed 2026-10-17: 200 with stream:true and tool sextet.
+  // Context window: 1_048_576 tokens (1M), maxTokens: 131_072.
+  // Probed boundary: filler up to 900,000 words (~1.1M tokens) answers 200.
+  // Input: text-only (image probe answers 400 "Beam supports text input only").
+  // Wire format: Chat Completions (/v1/responses answers 400 ModelProtocolUnsupported).
+  // Reasoning effort ladder: minimal is rejected with 400 (unsupported_value),
+  // low/medium/high/xhigh/max all answer 200 with reasoning.
+  id: "beam-free",
+  name: "Beam Free [OpenCode]",
   reasoning: true,
-  contextWindow: 262_144,
-  maxTokens: 65_536,
+  contextWindow: 1_048_576,
+  maxTokens: 131_072,
   input: ["text"],
   thinkingLevelMap: {
    off: null,
@@ -722,7 +701,7 @@ export const MODEL_ALIASES: Record<string, string> = {
  "space-bunny": "space-bunny-free",
  "longcat-2.5-preview": "longcat-2.5-preview-free",
  "longcat": "longcat-2.5-preview-free",
- "ll-alpha": "ll-alpha-free",
+ "beam": "beam-free",
  "deepseek-v4.1-flash": "deepseek-v4.1-flash-free",
  // provider-prefixed short aliases (slash-normalized)
  "laguna-s-2.1:free": "poolside/laguna-s-2.1:free",
@@ -777,7 +756,7 @@ export const OVH_MODEL_IDS = new Set<string>([
   .map(([alias]) => alias),
 ]);
 /**
- * Combined list of all 37 static free models (canonical)
+ * Combined list of all 36 static free models (canonical)
  */
 export const ALL_MODELS: ModelDef[] = [...OPENCODE_MODELS, ...KILO_MODELS, ...CLINE_MODELS, ...OVH_MODELS];
 

package/src/proxy.ts

@@ -1612,12 +1612,18 @@ export function startProxy(
         ) {
          rememberIssuerRelay(conversationKey, servedIssuer);
         }
-        // Upstream degradation tracking: successes prove Zen reachable,
-        // 403 free-tier gates feed the health state machine (a 403 never
-        // rolls — it is a terminal upstream verdict, not a relay fault).
+        // Upstream degradation tracking: successes prove Zen reachable; a 403
+        // free-tier gate feeds the health state machine only when the DIRECT
+        // path produced it (servedIssuer === null). A relay-served 403 is
+        // relay-shaped — relay.ts rolls it and marks the relay — so a salvaged
+        // relay 403 must never flip the machine-wide gate.
         if (response.ok) {
          recordUpstreamSuccess("zen", { sessionKey, canary: isCanary });
-        } else if (response.status === 403 && (response.headers.get("content-type") ?? "").includes("application/json")) {
+        } else if (
+         servedIssuer === null &&
+         response.status === 403 &&
+         (response.headers.get("content-type") ?? "").includes("application/json")
+        ) {
          try {
           const gateText = await response.clone().text();
           recordUpstreamFailure("zen", 403, gateText);

package/src/relay.ts

@@ -489,25 +489,38 @@ export async function relayFetch(
 				continue;
 			}
 
-			// Relay auth rejection: a deployed worker whose RELAY_AUTH no longer
-			// matches this entry's x-relay-auth answers 401 {"error":"unauthorized"}
-			// before forwarding, so the relay never reached upstream (deploy.ts).
-			// That is a relay-host fault, not an upstream verdict: mark it and roll
-			// like every other relay failure. Left to fall through, the broken relay
-			// reached markRelaySuccess below — recorded healthy/sticky, EWMA reset,
-			// no roll, so it kept serving the pool until something else noticed.
-			// Strictly 401: a 403 free-tier gate stays a terminal upstream verdict
-			// (rolling one buys nothing and burns pool quota), and 404-style client
-			// errors keep their non-penalizing terminal path below.
-			if (res.status === 401) {
-				markRelayFailure(targetUrl, 401, "Relay auth rejected (x-relay-auth mismatch)");
+			// Relay-host rejection: 401 = a deployed worker whose RELAY_AUTH no
+			// longer matches this entry's x-relay-auth answers
+			// 401 {"error":"unauthorized"} before forwarding (deploy.ts). 403 =
+			// the relay's egress transformed the request fingerprint (e.g. a
+			// stripped User-Agent), so the worker's target guard or the upstream
+			// free-tier check rejected it — the relay never produced a genuine
+			// upstream verdict either. Both are relay-host faults: mark and roll
+			// like every other relay failure. Left to fall through, the broken
+			// relay reached markRelaySuccess below — recorded healthy/sticky,
+			// EWMA reset, no roll, so it kept serving the pool until something
+			// else noticed. A 403 is no longer treated as a terminal upstream
+			// verdict: rolls are bounded by pool size, and the gate state machine
+			// only primes on a 403 the direct path produced (proxy.ts). Non-401/403
+			// client errors keep their non-penalizing terminal path below.
+			if (res.status === 401 || res.status === 403) {
+				const authRejected = res.status === 401;
+				markRelayFailure(
+					targetUrl,
+					res.status,
+					authRejected
+						? "Relay auth rejected (x-relay-auth mismatch)"
+						: "Relay returned HTTP 403 (stripped or blocked egress fingerprint)",
+				);
 				lastResponse?.body?.cancel().catch(() => {});
 				lastResponse = res;
 				lastResponseRelay = targetUrl;
 				log(
 					"warn",
-					`relay ${targetUrl} rejected the relay auth in ${elapsed}s — rolling to next relay`,
-					{ upstream: url, status: 401 },
+					authRejected
+						? `relay ${targetUrl} rejected the relay auth in ${elapsed}s — rolling to next relay`
+						: `relay ${targetUrl} returned HTTP 403 (blocked egress fingerprint) in ${elapsed}s — rolling to next relay`,
+					{ upstream: url, status: res.status },
 					rid,
 				);
 				const now = Date.now();
@@ -515,7 +528,12 @@ export async function relayFetch(
 					lastRollNotify = now;
 					const ui = getStatusUi();
 					if (ui?.notify) {
-						ui.notify(`relay ${shortRelayLabel(targetUrl)} rejected the relay auth (HTTP 401) — rolled to next relay`, "warning");
+						ui.notify(
+							authRejected
+								? `relay ${shortRelayLabel(targetUrl)} rejected the relay auth (HTTP 401) — rolled to next relay`
+								: `relay ${shortRelayLabel(targetUrl)} failed (HTTP 403) — rolled to next relay`,
+							"warning",
+						);
 					}
 				}
 				continue;

package/src/stream-pipe.ts

@@ -442,6 +442,53 @@ function cloakStreamResponsesObject(resp: unknown, cloak: StreamCloakOptions): v
  (resp as Record<string, unknown>).output = kept;
 }
 
+/**
+ * Terminal chunk for chat choice: absorb any tool-call argument fragment
+ * riding the finish_reason chunk into the buffered prefix, then re-emit every
+ * buffered tool call's whole argument packet, repaired.
+ * Returns true if delta was mutated.
+ */
+function flushChatTerminalToolCalls(
+ d: Record<string, unknown>,
+ state: SseStreamCloakState,
+ cloak: StreamCloakOptions,
+ flushedIndices: Set<number>,
+): boolean {
+ if (state.chatArgsByIndex.size === 0) return false;
+
+ for (const tc of Array.isArray(d.tool_calls) ? d.tool_calls : []) {
+  if (!tc || typeof tc !== "object" || Array.isArray(tc)) continue;
+  const rec = tc as Record<string, unknown>;
+  const idx = typeof rec.index === "number" ? rec.index : 0;
+  const fn = rec.function;
+  const fnRec = fn && typeof fn === "object" && !Array.isArray(fn) ? (fn as Record<string, unknown>) : null;
+  if (fnRec && state.chatArgsByIndex.has(idx) && typeof fnRec.arguments === "string") {
+   state.chatArgsByIndex.set(idx, (state.chatArgsByIndex.get(idx) ?? "") + fnRec.arguments);
+  }
+ }
+
+ const flushed: unknown[] = [];
+ for (const [idx, args] of state.chatArgsByIndex) {
+  const name = state.chatNameByIndex.get(idx);
+  if (name === undefined) continue;
+  flushedIndices.add(idx);
+  flushed.push({ index: idx, type: "function", function: { name, arguments: repairToolArguments(name, args, cloak.argSchemas) } });
+ }
+ state.chatArgsByIndex.clear();
+ state.chatNameByIndex.clear();
+
+ if (flushed.length === 0) return false;
+
+ const remaining = (Array.isArray(d.tool_calls) ? d.tool_calls : []).filter((tc) => {
+  if (!tc || typeof tc !== "object" || Array.isArray(tc)) return true;
+  const rec = tc as Record<string, unknown>;
+  const idx = typeof rec.index === "number" ? rec.index : 0;
+  return !flushedIndices.has(idx);
+ });
+ d.tool_calls = [...remaining, ...flushed];
+ return true;
+}
+
 /**
  * Rewrite one Chat Completions SSE block: drop injected delta.tool_calls
  * (including nameless argument continuations via per-index tracking), restore
@@ -489,20 +536,8 @@ function rewriteChatBlock(
   // Indices flushed on this block: their arguments are final, so the
   // per-delta loop below must not buffer them a second time.
   const flushedIndices = new Set<number>();
-  if (c.finish_reason && state.chatArgsByIndex.size > 0) {
-   const flushed: unknown[] = [];
-   for (const [idx, args] of state.chatArgsByIndex) {
-    const name = state.chatNameByIndex.get(idx);
-    if (name === undefined) continue;
-    flushedIndices.add(idx);
-    flushed.push({ index: idx, type: "function", function: { name, arguments: repairToolArguments(name, args, cloak.argSchemas) } });
-   }
-   state.chatArgsByIndex.clear();
-   state.chatNameByIndex.clear();
-   if (flushed.length > 0) {
-    d.tool_calls = [...(Array.isArray(d.tool_calls) ? d.tool_calls : []), ...flushed];
-    changed = true;
-   }
+  if (c.finish_reason && flushChatTerminalToolCalls(d, state, cloak, flushedIndices)) {
+   changed = true;
   }
   if (!Array.isArray(d.tool_calls)) {
    if (Object.keys(d).length > 0) allDeltasEmpty = false;