pi-freeflow 1.36.1 → 1.36.3

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 1.36.3
+
+### Patch Changes
+
+- Restore OpenCode free models following upstream endpoint and gate migration
+
+  OpenCode free models were failing with HTTP 403 FreeTierError after upstream deprecated the older endpoint and moved free inference traffic to the v1 inference gateway. Upstream also requires public authorization and non-empty schema declarations on compatibility tools.
+
+  Requests now route to the active endpoint with the required public credentials and schema declarations, restoring free model access across both direct connections and deployed relays.
+
+## 1.36.2
+
+### Patch Changes
+
+- Auto-recover OpenCode Zen 403 FreeTierError: when upstream OpenCode Zen refuses a session with `403 FreeTierError` ("OpenCode's free tier can only be used from within OpenCode"), the local proxy now catches the gate error in-flight and transparently fails over to a healthy KiloCode fallback model on the same wire API, rather than bubbling the 403 back to the coding agent.
+- Prune decommissioned `ling-3.1-flash-free` from the active catalog and add it to the exclusion list, locking the verified catalog to 36 models.
+- Update OpenCode version fallback to 1.19.0.
+
 ## 1.36.1
 
 ### Patch Changes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-freeflow",
   "type": "module",
-  "version": "1.36.1",
+  "version": "1.36.3",
   "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

@@ -105,6 +105,12 @@ export const DEAD_MODEL_IDS = new Set<string>([
  "cline-free/deepseek-v4.1-flash",
  "cline-free/kimi-k3",
  "cline-free/solar-pro4",
+ // ling-3.1-flash-free: removed from upstream free docs (2026-10-15).
+ "ling-3.1-flash-free",
+ // inclusionai/ling-3.1-flash: demoted to paid on Kilo (2026-10-15) — answers 401 PAID_MODEL_AUTH_REQUIRED.
+ "inclusionai/ling-3.1-flash",
+ // ovh-free/Mistral-7B-Instruct-v0.3: removed upstream by OVH (2026-10-15) — answers 404 no route matched.
+ "ovh-free/Mistral-7B-Instruct-v0.3",
 ]);
 /**
  * Free-tier allowlist for anything entering the picker via network or stale disk.

package/src/config.ts

@@ -2,7 +2,7 @@
  * Configuration and path resolution for pi-freeflow
  */
 
-import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { homedir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -21,7 +21,7 @@ try {
 export { PKG_VERSION };
 
 // ── Upstream endpoints ──────────────────────────────────────────────
-export const UPSTREAM_OPENCODE = "https://opencode.ai/zen";
+export const UPSTREAM_OPENCODE = "https://opencode.ai/inference";
 export const KILO_CHAT_URL = "https://api.kilo.ai/api/gateway/chat/completions";
 export const KILO_RESPONSES_URL = "https://api.kilo.ai/api/gateway/responses";
 export const OPENCODE_API_URL = `${UPSTREAM_OPENCODE}/v1`;
@@ -74,7 +74,7 @@ export const PORT = resolvePort();
 // OPENCODE_VERSION_FLOOR pins the minimum; OPENCODE_VERSION_FALLBACK is the
 // last-known-good npm version used when the live lookup is stale/offline.
 export const OPENCODE_VERSION_FLOOR = "1.17.0";
-export const OPENCODE_VERSION_FALLBACK = "1.18.34";
+export const OPENCODE_VERSION_FALLBACK = "1.19.0";
 /** Live npm lookup TTL: 6h — within one window the cached UA is reused. */
 export const OPENCODE_VERSION_TTL_MS = 6 * 60 * 60 * 1_000;
 /** Env override: exact `opencode/<version>` UA (or bare version) for tests/pins. */
@@ -250,14 +250,19 @@ export const OPENCODE_SESSION = createOpenCodeSessionId();
 
 export function opencodeHeaders(): Record<string, string> {
  const sessionId = OPENCODE_SESSION;
+ // Real OpenCode CLI (captured 2.0.28) does NOT send x-opencode-request on
+ // /inference/v1. Emitting msg_* there is treated as a non-OpenCode client and
+ // returns 403 FreeTierError — keep the helper for ID-shape tests, but omit
+ // the header on the wire.
  return {
+  Authorization: "Bearer public",
   "User-Agent": getOpenCodeUserAgent(),
   "x-opencode-client": OPENCODE_CLIENT,
   "x-opencode-project": OPENCODE_PROJECT,
   "x-opencode-session": sessionId,
   "x-opencode-session-id": sessionId,
   "x-session-affinity": sessionId,
-  "x-opencode-request": createOpenCodeRequestId(),
+  "x-session-id": sessionId,
  };
 }
 

package/src/index.ts

@@ -185,6 +185,7 @@ export default async function(pi: ExtensionAPI): Promise<void> {
    buildProviderConfig(models, actualPort),
   );
  };
+ registerCatalog(registeredCatalog);
  const ensureDaemon = async (ui?: ExtensionUIContext): Promise<void> => {
   const reattach = (port: number): void => {
    if (port !== actualPort) {

package/src/models.ts

@@ -1,18 +1,18 @@
 /**
  * Static model definitions and upstream routing catalogs for pi-freeflow
  *
- * Defines the 37 verified free models (live-verified 2026-10-13):
- * - 11 OpenCode Zen models (2 Responses API + 9 Chat Completions)
- * - 15 KiloCode Keyless Gateway models (OpenRouter format)
+ * Defines the 34 verified free models (live-verified 2026-10-15):
+ * - 10 OpenCode Zen models (2 Responses API + 8 Chat Completions)
+ * - 14 KiloCode Keyless Gateway models (OpenRouter format)
  * - 2 Cline direct-only models (per-user pool)
- * - 9 OVHcloud AI Endpoints models (keyless, direct-only)
+ * - 8 OVHcloud AI Endpoints models (keyless, direct-only)
  */
 
 import type { ModelDef, ThinkingLevelMap, Upstream } from "./types.ts";
 
 /**
  * OpenCode Zen free models verified against the live catalog and inference APIs.
- * Endpoint: https://opencode.ai/zen/v1
+ * Endpoint: https://opencode.ai/inference/v1
  */
 export const OPENCODE_MODELS: ModelDef[] = [
  {
@@ -200,23 +200,6 @@ export const OPENCODE_MODELS: ModelDef[] = [
   max: null,
  },
  },
- {
-  id: "ling-3.1-flash-free",
-  name: "Ling 3.1 Flash Free [OpenCode]",
-  reasoning: true,
-  contextWindow: 262_144,
-  maxTokens: 32_768,
-  input: ["text"],
-  thinkingLevelMap: {
-   off: null,
-   minimal: "minimal",
-   low: "low",
-   medium: "medium",
-   high: "high",
-   xhigh: "xhigh",
-   max: "max",
-  },
- },
 ];
 
 /**
@@ -386,17 +369,6 @@ export const KILO_MODELS: ModelDef[] = [
   thinkingFormat: "openrouter",
   thinkingLevelMap: KILO_REASONING_MAP,
  },
- {
-  // Added 2026-10-07: live on Kilo free list (isFree:true, 0/0 pricing, 262K ctx)
-  id: "inclusionai/ling-3.1-flash",
-  name: "Ling 3.1 Flash [Kilo]",
-  reasoning: true,
-  contextWindow: 262_144,
-  maxTokens: 32_768,
-  input: ["text"],
-  thinkingFormat: "openrouter",
-  thinkingLevelMap: KILO_REASONING_MAP,
- },
 ];
 
 /**
@@ -569,14 +541,6 @@ export const OVH_MODELS: ModelDef[] = [
   maxTokens: 16_384,
   input: ["text", "image"],
  },
- {
-  id: "ovh-free/Mistral-7B-Instruct-v0.3",
-  name: "Mistral 7B Instruct v0.3 [OVH]",
-  reasoning: false,
-  contextWindow: 65_536,
-  maxTokens: 65_536,
-  input: ["text"],
- },
  {
   id: "ovh-free/Meta-Llama-3_3-70B-Instruct",
   name: "Meta Llama 3.3 70B Instruct [OVH]",
@@ -625,8 +589,6 @@ export const MODEL_ALIASES: Record<string, string> = {
  "longcat-2.5-preview": "longcat-2.5-preview-free",
  "longcat": "longcat-2.5-preview-free",
  "step-5-preview": "step-5-preview-free",
- "ling-3.1-flash": "ling-3.1-flash-free",
- "ling-3.1-flash:kilo": "inclusionai/ling-3.1-flash",
  // provider-prefixed short aliases (slash-normalized)
  "laguna-s-2.1:free": "poolside/laguna-s-2.1:free",
  "laguna-xs-2.1:free": "poolside/laguna-xs-2.1:free",
@@ -640,7 +602,6 @@ export const MODEL_ALIASES: Record<string, string> = {
 "qwen3.6-27b": "ovh-free/Qwen3.6-27B",
 "qwen3.8-27b": "ovh-free/Qwen3.8-27B",
 "mistral-small-3.2": "ovh-free/Mistral-Small-3.2-24B-Instruct-2506",
-"mistral-7b-v0.3": "ovh-free/Mistral-7B-Instruct-v0.3",
 "llama-3.3-70b": "ovh-free/Meta-Llama-3_3-70B-Instruct",
 };
 

package/src/opencode-fingerprint.ts

@@ -26,6 +26,7 @@
  * per-request map (never module-global).
  */
 import {
+ COMPAT_FINGERPRINT_SCHEMAS,
  COMPAT_TOOL_DESCRIPTION,
  OMP_FINGERPRINT_DEFS,
  OPENCODE_FINGERPRINT_TOOLS,
@@ -105,7 +106,7 @@ export function isPlaceholderToolName(name: unknown): boolean {
  * functions below.
  */
 function fingerprintFill(name: FingerprintToolName, omp: boolean): { description: string; schema: Record<string, unknown> } {
- if (!omp || name === "edit") return { description: COMPAT_TOOL_DESCRIPTION, schema: { type: "object", properties: {} } };
+ if (!omp || name === "edit") return { description: COMPAT_TOOL_DESCRIPTION, schema: COMPAT_FINGERPRINT_SCHEMAS[name] };
  const def = OMP_FINGERPRINT_DEFS[name];
  return { description: def.description, schema: { ...(def.parameters as Record<string, unknown>) } };
 }

package/src/probe.ts

@@ -1,4 +1,4 @@
-import { opencodeHeaders } from "./config.ts";
+import { OPENCODE_API_URL, opencodeHeaders } from "./config.ts";
 import { ensureChatFingerprintTools } from "./opencode-fingerprint.ts";
 
 /**
@@ -17,7 +17,7 @@ export interface RelayProbeOptions {
  /**
   * Probe mode:
   * - "models" (default): GET /v1/models (reachability probe)
-  * - "chat": POST /zen/v1/chat/completions (verifies free tier inference & spoofing)
+ * - "chat": POST /inference/v1/chat/completions (verifies free tier inference & spoofing)
   */
  endpoint?: "models" | "chat";
  /** Model to use for chat probe (defaults to "nemotron-3.5-lightning-free") */
@@ -76,7 +76,7 @@ async function probeRelayOnce(
 
   if (isDirectOpenCode) {
    if (isChat) {
-    fetchUrl = "https://opencode.ai/zen/v1/chat/completions";
+    fetchUrl = `${OPENCODE_API_URL}/chat/completions`;
     method = "POST";
     headers["content-type"] = "application/json";
     const probePayload: Record<string, unknown> = {
@@ -88,15 +88,15 @@ async function probeRelayOnce(
     ensureChatFingerprintTools(probePayload);
     body = JSON.stringify(probePayload);
    } else {
-    fetchUrl = "https://opencode.ai/zen/v1/models";
+    fetchUrl = `${OPENCODE_API_URL}/models`;
    }
   } else {
    if (isChat) {
-    fetchUrl = `${cleanUrl}/zen/v1/chat/completions`;
+    fetchUrl = `${cleanUrl}/inference/v1/chat/completions`;
     method = "POST";
     headers["content-type"] = "application/json";
     headers["x-relay-target"] = "https://opencode.ai";
-    headers["x-relay-path"] = "/zen/v1/chat/completions";
+    headers["x-relay-path"] = "/inference/v1/chat/completions";
     const probePayload: Record<string, unknown> = {
      model: opts?.model || "nemotron-3.5-lightning-free",
      max_tokens: 1,
@@ -108,7 +108,7 @@ async function probeRelayOnce(
    } else {
     fetchUrl = `${cleanUrl}/v1/models`;
     headers["x-relay-target"] = "https://opencode.ai";
-    headers["x-relay-path"] = "/zen/v1/models";
+    headers["x-relay-path"] = "/inference/v1/models";
    }
   }
 

package/src/proxy.ts

@@ -80,6 +80,7 @@ import {
 import { pipeUpstreamStream, type StreamCloakOptions } from "./stream-pipe.ts";
 import {
  decideZenRoute,
+ isFreeTierGate,
  isUnprovenSession,
  isUpstreamGated,
  pickFailoverModel,
@@ -563,6 +564,172 @@ async function handleOvhRequest(opts: {
  }
 }
 
+/**
+ * Keyless gateway handling for Kilo models (both direct Kilo models and
+ * Zen sessions failed over to Kilo). Serves chat completions and responses
+ * natively, repairs tool arguments, and recovers from 400 token overflows.
+ */
+async function handleKiloRequest(opts: {
+ parsedBody: Record<string, unknown>;
+ pathname: string;
+ req: http.IncomingMessage;
+ res: http.ServerResponse;
+ reqId: string;
+ clientRequestedStream: boolean;
+ sessionKey?: string | null;
+}): Promise<void> {
+ const { parsedBody, pathname, req, res, reqId, clientRequestedStream, sessionKey } = opts;
+ const isStream = clientRequestedStream;
+ const kiloController = new AbortController();
+ const kiloArgSchemas = buildArgRepairSchemas(Array.isArray(parsedBody.tools) ? parsedBody.tools : []);
+ const kiloTimeoutId = setTimeout(
+  () => kiloController.abort(upstreamTimeoutError()),
+  UPSTREAM_HEADER_TIMEOUT_MS,
+ );
+ const abortKiloOnClientGone = () => {
+  if (!res.writableEnded) kiloController.abort();
+ };
+ res.once("close", abortKiloOnClientGone);
+ req.once("error", abortKiloOnClientGone);
+ let response: Response;
+ const kiloUrl = pathname.endsWith("/responses") ? KILO_RESPONSES_URL : KILO_CHAT_URL;
+ try {
+  response = await relayFetch(
+   kiloUrl,
+   {
+    method: "POST",
+    headers: {
+     "Content-Type": "application/json",
+    },
+    body: JSON.stringify(parsedBody),
+    signal: kiloController.signal,
+   },
+   reqId,
+  );
+  if (response.status === 400 && !res.writableEnded) {
+   const retryBody = { ...parsedBody };
+   let changed = false;
+   if (typeof retryBody.max_output_tokens === "number" && retryBody.max_output_tokens > 4096) {
+    retryBody.max_output_tokens = 4096;
+    changed = true;
+   }
+   if (typeof retryBody.max_tokens === "number" && retryBody.max_tokens > 4096) {
+    retryBody.max_tokens = 4096;
+    changed = true;
+   }
+   if (retryBody.model === "dots-studio/dots-3-note-preview:free") {
+    retryBody.model = "nvidia/nemotron-3.5-lightning:free";
+    changed = true;
+   }
+   if (changed) {
+    log("warn", `kilo 400 for model ${String(parsedBody.model)} — retrying with clamped tokens`, { model: parsedBody.model }, reqId);
+    try {
+     const retryRes = await relayFetch(
+      kiloUrl,
+      {
+       method: "POST",
+       headers: {
+        "Content-Type": "application/json",
+       },
+       body: JSON.stringify(retryBody),
+       signal: kiloController.signal,
+      },
+      reqId,
+     );
+     if (retryRes.ok) {
+      log("info", `kilo 400 recovery succeeded with model ${String(retryBody.model)}`, { model: retryBody.model }, reqId);
+      response = retryRes;
+     }
+    } catch { }
+   }
+  }
+ } finally {
+  clearTimeout(kiloTimeoutId);
+  res.off("close", abortKiloOnClientGone);
+  req.off("error", abortKiloOnClientGone);
+ }
+ if (response.ok) recordUpstreamSuccess("kilo", { sessionKey });
+
+ if (isStream && response.ok && response.body) {
+  const ct = response.headers.get("content-type") || "text/event-stream";
+  res.writeHead(response.status, {
+   "content-type": ct,
+   "cache-control": "no-cache, no-transform",
+   connection: "keep-alive",
+   "x-accel-buffering": "no",
+  });
+  pipeUpstreamStream(
+   Readable.fromWeb(
+    response.body as unknown as WebReadableStream,
+   ),
+   res,
+   req,
+   reqId,
+   undefined,
+   kiloArgSchemas.size > 0
+    ? {
+     callerHadTools: true,
+     argSchemas: kiloArgSchemas,
+     pathname: pathname.endsWith("/responses") ? "/v1/responses" : "/v1/chat/completions",
+    }
+    : undefined,
+  );
+ } else {
+  let rawText = await response.text();
+  if (response.ok && kiloArgSchemas.size > 0) {
+   rawText = convertSseToJson(rawText, pathname, true, undefined, undefined, undefined, kiloArgSchemas);
+   rawText = repairJsonToolArguments(rawText, pathname, kiloArgSchemas);
+  }
+  const data = withRateLimitHint(response.status, rawText);
+  const ct = response.headers.get("content-type") || "application/json";
+  res.writeHead(response.status, { "content-type": ct });
+  res.end(data);
+ }
+}
+
+/**
+ * In-flight auto-recovery for Zen 403 FreeTierError: immediately fail over
+ * the current request to a healthy Kilo model instead of surfacing 403 to the caller.
+ * Returns true when recovery was dispatched; false when failover is impossible.
+ */
+async function tryZenGateAutoFailover(opts: {
+ parsedBody: Record<string, unknown> | null;
+ pathname: string;
+ req: http.IncomingMessage;
+ res: http.ServerResponse;
+ reqId: string;
+ clientRequestedStream: boolean;
+ sessionKey?: string | null;
+}): Promise<boolean> {
+ const { parsedBody, pathname, req, res, reqId, clientRequestedStream, sessionKey } = opts;
+ if (!parsedBody || res.headersSent || res.writableEnded) return false;
+ const fallbackModel = pickFailoverModel(parsedBody.model);
+ if (!fallbackModel) return false;
+ try {
+  const fromModel = String(parsedBody.model ?? "?");
+  parsedBody.model = fallbackModel;
+  if (pathname.endsWith("/responses")) {
+   prepareResponsesFailoverBody(parsedBody);
+  } else {
+   prepareChatFailoverBody(parsedBody);
+  }
+  log("warn", `zen 403 FreeTierError auto-fixed: failing over ${fromModel} -> ${fallbackModel}`, { model: fromModel, failover: fallbackModel }, reqId);
+  await handleKiloRequest({
+   parsedBody,
+   pathname,
+   req,
+   res,
+   reqId,
+   clientRequestedStream,
+   sessionKey,
+  });
+  return true;
+ } catch (err) {
+  log("warn", `zen 403 FreeTierError auto-failover failed: ${String(err)}`, { error: String(err) }, reqId);
+  return false;
+ }
+}
+
 /**
  * Relay eligibility: only free-catalog models ride relay egress. Returns true
  * when the model is a non-empty string present in MODEL_MAP or KILO_MODEL_IDS
@@ -690,11 +857,11 @@ export function sanitizeHeaders(
  sanitized.connection = "keep-alive";
  return sanitized;
 }
-export async function isProxyAlive(port: number): Promise<boolean> {
+export async function isProxyAlive(port: number, timeoutMs = 600): Promise<boolean> {
  if (!Number.isInteger(port) || port < 1 || port > 65535) return false;
  try {
   const res = await fetch(`http://${HOST}:${port}/v1/models`, {
-   signal: AbortSignal.timeout(1500),
+   signal: AbortSignal.timeout(timeoutMs),
   });
   const ct = res.headers.get("content-type") || "";
   return res.ok && ct.includes("application/json");
@@ -1277,133 +1444,15 @@ export function startProxy(
      // token: the proxy only passes the body and maps the answer.
      await handleClineRequest({ parsedBody, pathname: target.pathname, req, res, reqId, clientRequestedStream });
     } else if (isKilo && parsedBody) {
-     // Header-wait timeout + client-disconnect abort: once headers
-     // arrive the timer is cleared so a long stream is not killed at
-     // the timeout ceiling; the stream phase is owned by
-     // pipeUpstreamStream and its close handling.
-     const kiloController = new AbortController();
-     // Kilo bodies ride verbatim, but its models malform arguments the same
-     // way: capture the caller's schemas so the reply can be repaired too.
-     const kiloArgSchemas = buildArgRepairSchemas(Array.isArray(parsedBody.tools) ? parsedBody.tools : []);
-     const kiloTimeoutId = setTimeout(
-      () => kiloController.abort(upstreamTimeoutError()),
-      UPSTREAM_HEADER_TIMEOUT_MS,
-     );
-     const abortKiloOnClientGone = () => {
-      if (!res.writableEnded) kiloController.abort();
-     };
-     res.once("close", abortKiloOnClientGone);
-     req.once("error", abortKiloOnClientGone);
-     let response: Response;
-     // Kilo serves both wire APIs natively: responses-shaped bodies go to
-     // its responses endpoint, chat bodies to chat completions. Sending a
-     // responses body to the chat URL (or vice versa) would 400.
-     const kiloUrl = target.pathname.endsWith("/responses") ? KILO_RESPONSES_URL : KILO_CHAT_URL;
-     try {
-      response = await relayFetch(
-       kiloUrl,
-       {
-        method: "POST",
-        headers: {
-         // Keyless, like Zen: Kilo's gateway rejects a placeholder bearer
-         // (live 2026-09-22 — "Bearer kilo-free" answers 401 INVALID_TOKEN,
-         // omitting Authorization answers 200 for every free catalog model).
-         "Content-Type": "application/json",
-        },
-        body: JSON.stringify(parsedBody),
-        signal: kiloController.signal,
-       },
-       reqId,
-      );
-      // Kilo 400 recovery: if upstream Kilo rejected the body with 400 (e.g.
-      // prompt + max_output_tokens exceeded model's operational context limit),
-      // retry once with clamped max tokens and fallback to a 1M model.
-      if (response.status === 400 && !res.writableEnded) {
-       const retryBody = { ...parsedBody };
-       let changed = false;
-       if (typeof retryBody.max_output_tokens === "number" && retryBody.max_output_tokens > 4096) {
-        retryBody.max_output_tokens = 4096;
-        changed = true;
-       }
-       if (typeof retryBody.max_tokens === "number" && retryBody.max_tokens > 4096) {
-        retryBody.max_tokens = 4096;
-        changed = true;
-       }
-       if (retryBody.model === "dots-studio/dots-3-note-preview:free") {
-        retryBody.model = "nvidia/nemotron-3.5-lightning:free";
-        changed = true;
-       }
-       if (changed) {
-        log("warn", `kilo 400 for model ${String(parsedBody.model)} — retrying with clamped tokens`, { model: parsedBody.model }, reqId);
-        try {
-         const retryRes = await relayFetch(
-          kiloUrl,
-          {
-           method: "POST",
-           headers: {
-            "Content-Type": "application/json",
-           },
-           body: JSON.stringify(retryBody),
-           signal: kiloController.signal,
-          },
-          reqId,
-         );
-         if (retryRes.ok) {
-          log("info", `kilo 400 recovery succeeded with model ${String(retryBody.model)}`, { model: retryBody.model }, reqId);
-          response = retryRes;
-         }
-        } catch { }
-       }
-      }
-     } finally {
-      clearTimeout(kiloTimeoutId);
-      res.off("close", abortKiloOnClientGone);
-      req.off("error", abortKiloOnClientGone);
-     }
-     if (response.ok) recordUpstreamSuccess("kilo", { sessionKey });
-
-     if (isStream && response.ok && response.body) {
-      const ct =
-       response.headers.get("content-type") || "text/event-stream";
-      res.writeHead(response.status, {
-       "content-type": ct,
-       "cache-control": "no-cache, no-transform",
-       connection: "keep-alive",
-       "x-accel-buffering": "no",
-      });
-      // Kilo is fetched directly (not via the relay pool), so pass undefined as
-      // the issuer: attributing kilo-side stream failures to an unrelated
-      // opencode relay would mark a healthy relay as failed.
-      pipeUpstreamStream(
-       Readable.fromWeb(
-        response.body as unknown as WebReadableStream,
-       ),
-       res,
-       req,
-       reqId,
-       undefined,
-       kiloArgSchemas.size > 0
-        ? {
-         callerHadTools: true,
-         argSchemas: kiloArgSchemas,
-         pathname: target.pathname.endsWith("/responses") ? "/v1/responses" : "/v1/chat/completions",
-        }
-        : undefined,
-      );
-     } else {
-      let rawText = await response.text();
-      if (response.ok && kiloArgSchemas.size > 0) {
-       // Kilo passes `stream` through verbatim, so a non-streaming caller gets
-       // a plain JSON body: the SSE aggregator is a no-op on it, and the JSON
-       // repair is what actually applies here.
-       rawText = convertSseToJson(rawText, target.pathname, true, undefined, undefined, undefined, kiloArgSchemas);
-       rawText = repairJsonToolArguments(rawText, target.pathname, kiloArgSchemas);
-      }
-      const data = withRateLimitHint(response.status, rawText);
-      const ct = response.headers.get("content-type") || "application/json";
-      res.writeHead(response.status, { "content-type": ct });
-      res.end(data);
-     }
+     await handleKiloRequest({
+      parsedBody,
+      pathname: target.pathname,
+      req,
+      res,
+      reqId,
+      clientRequestedStream,
+      sessionKey,
+     });
    } else if (isOvh && parsedBody) {
     // OVH serves chat upstream only (see handleOvhRequest): direct, keyless,
     // no fingerprint, and a responses-path body translated to chat and back.
@@ -1666,6 +1715,18 @@ export function startProxy(
           log("warn", `upstream ${response.status} for model ${String((parsedBody as Record<string, unknown> | null)?.model ?? "?")} via ${servedRelay === "direct" ? "direct upstream" : `relay ${servedRelay}`}`, { status: response.status, model: (parsedBody as Record<string, unknown> | null)?.model, path: req.url, relay: servedRelay }, reqId);
          }
          let rawText = await response.text();
+         if (response.status === 403 && isFreeTierGate(403, rawText)) {
+          const recovered = await tryZenGateAutoFailover({
+           parsedBody: parsedBody as Record<string, unknown> | null,
+           pathname: target.pathname,
+           req,
+           res,
+           reqId,
+           clientRequestedStream,
+           sessionKey,
+          });
+          if (recovered) return;
+         }
          let ct =
           response.headers.get("content-type") ||
           "application/json";
@@ -1824,14 +1885,28 @@ export function startProxy(
       // Gated upstream: a 403 free-tier gate is a final answer, not a
       // stream — buffer it and attach the recovery hint instead of
       // piping it through as a stream body.
+      // Gated upstream: a 403 free-tier gate is auto-recovered via Kilo failover.
+      // If failover is impossible, buffer it and attach the recovery hint.
       if (upstreamRes.status === 403) {
-       const data = withFreeTierHint(403, await upstreamRes.text());
+       const rawText403 = await upstreamRes.text();
+       if (isFreeTierGate(403, rawText403)) {
+        const recovered = await tryZenGateAutoFailover({
+         parsedBody: parsedBody as Record<string, unknown> | null,
+         pathname: target.pathname,
+         req,
+         res,
+         reqId,
+         clientRequestedStream,
+         sessionKey,
+        });
+        if (recovered) return;
+       }
+       const data = withFreeTierHint(403, rawText403);
        const ct403 = upstreamRes.headers.get("content-type") || "application/json";
        res.writeHead(403, { "content-type": ct403 });
        res.end(data);
        return;
       }
-
       const outHeaders: Record<string, string> = {};
       for (const h of ["content-type", "cache-control", "x-request-id"] as const) {
        const v = upstreamRes.headers.get(h);

package/src/tool-translation.ts

@@ -190,6 +190,39 @@ export const OMP_FINGERPRINT_DEFS: Record<Exclude<FingerprintToolName, "edit">,
  },
 };
 
+/** Minimal valid schemas for injected compat tools to satisfy upstream inference gate. */
+export const COMPAT_FINGERPRINT_SCHEMAS: Record<FingerprintToolName, Record<string, unknown>> = {
+ bash: {
+  type: "object",
+  properties: { command: { type: "string", description: "Shell command to run." } },
+  required: ["command"],
+ },
+ read: {
+  type: "object",
+  properties: { path: { type: "string", description: "File path to read." } },
+  required: ["path"],
+ },
+ glob: {
+  type: "object",
+  properties: { path: { type: "string", description: "Search path." } },
+ },
+ grep: {
+  type: "object",
+  properties: { pattern: { type: "string", description: "Search pattern." } },
+  required: ["pattern"],
+ },
+ edit: {
+  type: "object",
+  properties: { path: { type: "string", description: "File path to edit." } },
+  required: ["path"],
+ },
+ write: {
+  type: "object",
+  properties: { path: { type: "string", description: "File path to write." } },
+  required: ["path"],
+ },
+};
+
 /** Caller tool names that only an OMP host sends (never Pi). */
 export const OMP_CALLER_MARKERS = ["ask", "task", "todo", "hub", "lsp"] as const;
 
@@ -757,8 +790,51 @@ export function chatResponsesJsonFromChatCompletion(chat: Record<string, unknown
  */
 export function chatResponsesSseFromChatCompletion(resp: Record<string, unknown>): string {
  const head = { type: "response.created", response: { id: resp.id, object: "response", model: resp.model } };
+ let out = `event: response.created\ndata: ${JSON.stringify(head)}\n\n`;
+ const output = resp.output;
+ if (Array.isArray(output)) {
+  for (let idx = 0; idx < output.length; idx++) {
+   const item = output[idx] as Record<string, unknown>;
+   if (item && item.type === "message" && Array.isArray(item.content)) {
+    for (const part of item.content) {
+     const p = part as Record<string, unknown>;
+     if (p && p.type === "output_text" && typeof p.text === "string" && p.text.length > 0) {
+      out += `event: response.output_text.delta\ndata: ${JSON.stringify({
+       type: "response.output_text.delta",
+       output_index: idx,
+       delta: p.text,
+      })}\n\n`;
+     }
+    }
+   } else if (item && item.type === "function_call") {
+    out += `event: response.output_item.added\ndata: ${JSON.stringify({
+     type: "response.output_item.added",
+     output_index: idx,
+     item: {
+      type: "function_call",
+      id: item.id,
+      call_id: item.call_id,
+      name: item.name,
+      arguments: "",
+     },
+    })}\n\n`;
+    if (typeof item.arguments === "string" && item.arguments.length > 0) {
+     out += `event: response.function_call_arguments.delta\ndata: ${JSON.stringify({
+      type: "response.function_call_arguments.delta",
+      output_index: idx,
+      delta: item.arguments,
+     })}\n\n`;
+    }
+    out += `event: response.output_item.done\ndata: ${JSON.stringify({
+     type: "response.output_item.done",
+     output_index: idx,
+     item,
+    })}\n\n`;
+   }
+  }
+ }
  const done = { type: "response.completed", response: resp };
- return `event: response.created\ndata: ${JSON.stringify(head)}\n\n` +
-  `event: response.completed\ndata: ${JSON.stringify(done)}\n\n` +
-  `data: [DONE]\n\n`;
+ out += `event: response.completed\ndata: ${JSON.stringify(done)}\n\n`;
+ out += `data: [DONE]\n\n`;
+ return out;
 }