@olares/lares-core 0.15.7 → 0.15.9

package/router/catalog-sync.js

@@ -18,6 +18,8 @@ function messageOf(err) {
 }
 
 let adapterRevision = 0;
+/** What the last successful refresh wrote, so periodic reconciles stay quiet. */
+let publishedModels = null;
 /** @type {Set<(revision: number) => void>} */
 const revisionListeners = new Set();
 
@@ -45,9 +47,8 @@ function bumpRevision() {
  */
 async function performRefresh(ports) {
   const previous = catalogCache.snapshot();
-  catalogCache.invalidate();
   try {
-    const { payload } = await catalogCache.get();
+    const { payload } = await catalogCache.get({ refresh: true });
     const models = chatModelsFromRouterCatalog(payload);
     await ports.mutateSettings(LLM_SETTINGS_NS, catalogSettingsOps(models));
     const current = ports.currentSelection();
@@ -55,7 +56,11 @@ async function performRefresh(ports) {
       await ports.saveSelection({ provider: ROUTER_PROVIDER_ID, model: pickDefaultModel(models).id });
     }
     forgetSttModel();
-    bumpRevision();
+    const serialized = JSON.stringify(models);
+    if (serialized !== publishedModels) {
+      publishedModels = serialized;
+      bumpRevision();
+    }
     return models;
   } catch (err) {
     catalogCache.restore(previous);

package/router/catalog.d.ts

@@ -4,12 +4,17 @@ export interface RouterCatalogRow {
   mode: string | null;
   /** Whether Router declares native image input for this chat model. */
   supportsVision: boolean;
+  /** Speech recognition, from `stt` / `stt_stream`. */
+  supportsStt: boolean;
+  /** Speech playback, from `tts`. */
+  supportsTts: boolean;
   /** pi-ai level → Router wire spelling, or null when the model takes no effort. */
   reasoningEfforts: Record<string, string> | null;
   /** Tokens one request may span, or null when Router states none. */
   contextWindow: number | null;
-  /** Longest reply the model can produce, or null when Router states none. */
+  /** Output tokens a turn may reserve: Router's limit capped at a quarter of the window. */
   maxTokens: number | null;
 }
 
+export function outputTokenBudget(declared: number | null, contextWindow: number | null): number | null;
 export function routerCatalogRows(payload: unknown): RouterCatalogRow[];

package/router/catalog.js

@@ -49,6 +49,19 @@ function tokenCount(value) {
   return Number.isInteger(value) && value > 0 ? value : null;
 }
 
+/**
+ * Output tokens a turn may ask for. A local engine reports its whole context
+ * as max_output_tokens, and a request that reserves all of it cannot fit
+ * beside its own prompt: the engine's KV budget refuses it or, worse, admits
+ * it and evicts every other request. A quarter of the window leaves room for
+ * the prompt and still exceeds any reply a chat turn writes.
+ */
+export function outputTokenBudget(declared, contextWindow) {
+  if (contextWindow === null) return declared;
+  const cap = Math.max(1, Math.floor(contextWindow / 4));
+  return declared === null ? cap : Math.min(declared, cap);
+}
+
 export function routerCatalogRows(payload) {
   if (!payload || typeof payload !== "object" || !Array.isArray(payload.data)) return [];
   const rows = [];
@@ -59,14 +72,17 @@ export function routerCatalogRows(payload) {
     if (!SAFE_MODEL_ID.test(id) || seen.has(id)) continue;
     seen.add(id);
     const flags = capabilities(item);
+    const contextWindow = tokenCount(item.context_size);
     rows.push({
       id,
       name: id,
       mode: String(item.mode ?? "").trim().toLowerCase() || null,
       supportsVision: flags.has("vision"),
+      supportsStt: flags.has("stt") || flags.has("stt_stream"),
+      supportsTts: flags.has("tts"),
       reasoningEfforts: reasoningEfforts(item, flags),
-      contextWindow: tokenCount(item.context_size),
-      maxTokens: tokenCount(item.max_output_tokens),
+      contextWindow,
+      maxTokens: outputTokenBudget(tokenCount(item.max_output_tokens), contextWindow),
     });
   }
   return rows;

package/router/gateway.d.ts

@@ -1,4 +1,12 @@
 export function routerGatewayUrl(env?: NodeJS.ProcessEnv): string;
 export function routerShimBaseUrl(env?: NodeJS.ProcessEnv): string;
-export function routerAuthHeaders(apiKey: string | null | undefined, olaresAppId: string | null | undefined): Record<string, string>;
+export function routerEndUser(
+  env?: NodeJS.ProcessEnv,
+  incoming?: Record<string, string | string[] | undefined>,
+): string;
+export function routerAuthHeaders(
+  apiKey: string | null | undefined,
+  olaresAppId: string | null | undefined,
+  olaresUser?: string | null,
+): Record<string, string>;
 export function routerHeaders(env?: NodeJS.ProcessEnv): Record<string, string>;

package/router/gateway.js

@@ -1,3 +1,6 @@
+import { olaresUsername } from "../olares/identity.js";
+import { getLatestIdentity } from "../olares/session-identity.js";
+
 export function routerGatewayUrl(env = process.env) {
   return (env.LLM_GATEWAY_URL ?? "http://router-svc.router-shared/v1").replace(/\/+$/, "");
 }
@@ -8,14 +11,47 @@ export function routerShimBaseUrl(env = process.env) {
   return `http://127.0.0.1:${env.PORT ?? 8080}/llm/v1`;
 }
 
-export function routerAuthHeaders(apiKey, olaresAppId) {
-  if (apiKey?.trim()) return { authorization: `Bearer ${apiKey.trim()}` };
-  return { "x-caller-appid": olaresAppId?.trim() || "lares" };
+/**
+ * End user for Router/FlowStudio: the person logged into this Lares, not the
+ * shared FlowStudio chart owner. Session identity wins; chart install user is
+ * the fallback for background fetches with no request.
+ */
+export function routerEndUser(env = process.env, incoming = {}) {
+  const fromHeaders = incomingUser(incoming);
+  if (fromHeaders) return fromHeaders;
+  const fromSession = olaresUsername(getLatestIdentity()?.user);
+  if (fromSession) return fromSession;
+  return olaresUsername(env.OLARES_USERNAME || env.BFL_USERNAME || "");
+}
+
+function incomingUser(incoming) {
+  if (!incoming || typeof incoming !== "object") return "";
+  const get = (name) => {
+    const raw = incoming[name] ?? incoming[name.toLowerCase()];
+    if (Array.isArray(raw)) return raw[0] ?? "";
+    return raw ?? "";
+  };
+  return olaresUsername(
+    get("x-bfl-user") || get("remote-user") || get("authelia-remote-user") || "",
+  );
+}
+
+export function routerAuthHeaders(apiKey, olaresAppId, olaresUser) {
+  /** @type {Record<string, string>} */
+  const headers = apiKey?.trim()
+    ? { authorization: `Bearer ${apiKey.trim()}` }
+    : { "x-caller-appid": olaresAppId?.trim() || "lares" };
+  const user = olaresUsername(olaresUser);
+  if (user) {
+    headers["x-bfl-user"] = user;
+    headers["remote-user"] = user;
+  }
+  return headers;
 }
 
 export function routerHeaders(env = process.env) {
   return {
-    ...routerAuthHeaders(env.LARES_ROUTER_API_KEY, env.OLARES_APP_ID),
+    ...routerAuthHeaders(env.LARES_ROUTER_API_KEY, env.OLARES_APP_ID, routerEndUser(env)),
     accept: "application/json",
   };
 }

package/router/gemini-schema.js

@@ -0,0 +1,125 @@
+/**
+ * Gemini's OpenAI-compat endpoint copies each tool's `parameters` onto the
+ * Generative Language Schema proto. That proto has no `additionalProperties`,
+ * `oneOf`, `const`, or OpenAI `strict`, so a normal tool list 400s before the
+ * model speaks. Full JSON Schema stays intact for every other model on the
+ * same route.
+ *
+ * Allowed fields are the Schema message:
+ * https://ai.google.dev/api/caching#Schema
+ */
+
+const SCHEMA_FIELDS = new Set([
+  "anyOf",
+  "default",
+  "description",
+  "enum",
+  "example",
+  "format",
+  "items",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "maximum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "minimum",
+  "nullable",
+  "pattern",
+  "properties",
+  "propertyOrdering",
+  "required",
+  "title",
+  "type",
+]);
+
+/** @param {unknown} model */
+export function isGeminiModel(model) {
+  return String(model ?? "")
+    .split(/[/@]/)
+    .some((part) => part.toLowerCase().startsWith("gemini"));
+}
+
+/**
+ * @param {unknown} schema
+ * @returns {unknown}
+ */
+export function geminiSchema(schema) {
+  if (Array.isArray(schema)) return schema.map((item) => geminiSchema(item));
+  if (schema == null || typeof schema !== "object") return schema;
+
+  const source = { ...schema };
+  if (source.const !== undefined && source.enum === undefined) {
+    source.enum = [source.const];
+  }
+  if (source.oneOf !== undefined && source.anyOf === undefined) {
+    source.anyOf = source.oneOf;
+  }
+  if (Array.isArray(source.type)) {
+    const types = source.type.filter((item) => item !== "null");
+    if (source.type.includes("null")) source.nullable = true;
+    if (types.length === 1) source.type = types[0];
+    else if (types.length > 1 && source.anyOf === undefined) {
+      source.anyOf = types.map((type) => ({ type }));
+      delete source.type;
+    } else {
+      delete source.type;
+    }
+  }
+
+  /** @type {Record<string, unknown>} */
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (!SCHEMA_FIELDS.has(key)) continue;
+    if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
+      /** @type {Record<string, unknown>} */
+      const properties = {};
+      for (const [name, property] of Object.entries(value)) properties[name] = geminiSchema(property);
+      out.properties = properties;
+      continue;
+    }
+    if (key === "items") {
+      out.items = geminiSchema(value);
+      continue;
+    }
+    if (key === "anyOf" && Array.isArray(value)) {
+      out.anyOf = value.map((item) => geminiSchema(item));
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+/**
+ * @param {unknown} payload
+ * @returns {unknown}
+ */
+export function adaptGeminiChatBody(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return payload;
+  if (!isGeminiModel(payload.model) || !Array.isArray(payload.tools)) return payload;
+  return {
+    ...payload,
+    tools: payload.tools.map((tool) => {
+      if (!tool || tool.type !== "function" || !tool.function || typeof tool.function !== "object") return tool;
+      const fn = { ...tool.function };
+      delete fn.strict;
+      if (fn.parameters && typeof fn.parameters === "object") fn.parameters = geminiSchema(fn.parameters);
+      return { ...tool, function: fn };
+    }),
+  };
+}
+
+/** @param {Buffer} body @returns {Buffer} */
+export function adaptGeminiChatBuffer(body) {
+  let payload;
+  try {
+    payload = JSON.parse(body.toString("utf8"));
+  } catch {
+    return body;
+  }
+  const next = adaptGeminiChatBody(payload);
+  if (next === payload) return body;
+  return Buffer.from(JSON.stringify(next));
+}

package/router/generation-guard.js

@@ -0,0 +1,82 @@
+/**
+ * Keep the agent from generating on FlowStudio around the in-process shim.
+ *
+ * Only the shim (`$LARES_LLM_BASE_URL`, also what `olares-cli router call` and
+ * the `media_generate` tool use) stamps the logged-in user as an encrypted
+ * `sref`. A shell call straight to Router's data plane or to FlowStudio lands
+ * the job, and its files, under the shared chart owner instead, where this
+ * user cannot open them. This is a text check on what the agent is about to
+ * run: it stops the obvious routes the skills used to allow, and the skills
+ * say the same thing in words.
+ */
+
+const GENERATION_PATH =
+  /\/(?:v1\/)?(?:images\/generations|images\/edits|videos|music\/generations|generations)(?![a-z0-9_-])/i;
+
+/** FlowStudio's own API or service, which no skill has a reason to call directly. */
+const FLOWSTUDIO_DIRECT = [
+  /flowstudio-svc/i,
+  /flowstudio-shared/i,
+  /\/api\/v1\/generations/i,
+  /\/api\/jobs(?![a-z0-9_-])/i,
+  /\/api\/projects\/[^\s"']*\/(?:run|jobs|generate)/i,
+];
+
+const ROUTER_VARIABLE = /\$\{?LLM_GATEWAY_URL\}?/;
+const ROUTER_SERVICE = /router-svc(?:\.router-shared)?/i;
+
+export const GENERATION_BYPASS_REASON =
+  "Generate through the media_generate tool or $LARES_LLM_BASE_URL (the in-process Router shim) only. " +
+  "A direct call to Router's data plane or to FlowStudio files the job under the shared app owner, " +
+  "so this user can neither see the job nor open its files. Do not retry another way; " +
+  "if the shim is unavailable, tell the user generation is unavailable right now.";
+
+function routerHosts(env) {
+  const hosts = [];
+  try {
+    const raw = env.LLM_GATEWAY_URL?.trim();
+    if (raw) hosts.push(new URL(raw).host.toLowerCase());
+  } catch {
+    // An unparsable gateway URL only removes one pattern; the others still apply.
+  }
+  return hosts;
+}
+
+function mentionsRouter(text, env) {
+  if (ROUTER_VARIABLE.test(text) || ROUTER_SERVICE.test(text)) return true;
+  const lower = text.toLowerCase();
+  return routerHosts(env).some((host) => lower.includes(host));
+}
+
+/**
+ * @param {string} text a shell command, code snippet, or URL the agent will run
+ * @returns {string | null} the refusal reason, or null when the text is fine
+ */
+export function detectGenerationBypass(text, env = process.env) {
+  if (typeof text !== "string" || text.trim() === "") return null;
+  if (FLOWSTUDIO_DIRECT.some((pattern) => pattern.test(text))) return GENERATION_BYPASS_REASON;
+  if (mentionsRouter(text, env) && GENERATION_PATH.test(text)) return GENERATION_BYPASS_REASON;
+  return null;
+}
+
+/** Tools whose arguments are something the agent executes or fetches. */
+const GUARDED_TOOLS = new Map([
+  ["bash", ["command"]],
+  ["pwsh", ["command"]],
+  ["web_fetch", ["url"]],
+]);
+
+/**
+ * Pre-execute decision for one tool call; `prior` is what later listeners decided.
+ * @returns {{ kind: string, reason?: string }}
+ */
+export function decideGenerationGuard({ name, args, prior }, env = process.env) {
+  if (prior && prior.kind === "deny") return prior;
+  const fields = GUARDED_TOOLS.get(name);
+  if (!fields || args == null || typeof args !== "object") return prior;
+  for (const field of fields) {
+    const reason = detectGenerationBypass(args[field], env);
+    if (reason) return { kind: "deny", reason };
+  }
+  return prior;
+}

package/router/models.d.ts

@@ -1,6 +1,12 @@
 import type { RouterCatalogRow } from "./catalog.js";
 
 export type RouterModelEntry = RouterCatalogRow;
+export const ROUTER_RETRY_POLICY: Readonly<{
+  mode: "normal";
+  maxRetries: number;
+  retryableCodes: string[];
+  backoff: { initialDelayMs: number; maxDelayMs: number; jitterRatio: number };
+}>;
 export function isChatModelId(id: string): boolean;
 export function isChatModel(model: RouterModelEntry): boolean;
 export function modelsFromRouterCatalog(payload: unknown): RouterModelEntry[];

package/router/models.js

@@ -1,6 +1,6 @@
 import { writeCatalogSeed } from "./catalog-cache.js";
 import { routerCatalogRows } from "./catalog.js";
-import { routerAuthHeaders, routerGatewayUrl, routerShimBaseUrl } from "./gateway.js";
+import { routerAuthHeaders, routerEndUser, routerGatewayUrl, routerShimBaseUrl } from "./gateway.js";
 
 export const ROUTER_PROVIDER_ID = "olares-router";
 export const LLM_SETTINGS_NS = "llm-pi-ai";
@@ -8,6 +8,21 @@ export const LLM_SETTINGS_NS = "llm-pi-ai";
 const NON_CHAT_HINTS = /embed|whisper|tts|speech|ocr|clip|stt|asr|transcri/i;
 const PLACEHOLDER_MODEL = /^(?:default|deepseek-v4-(?:flash|pro))$/i;
 
+/**
+ * Model-request retries on the Router route. The dsh default gives up after
+ * five tries and refuses any Retry-After over ten seconds, which is shorter
+ * than a local single-slot engine stays busy with a title or compaction
+ * request, so a turn failed on a model that was about to be free. Waits here
+ * reach a minute each and several minutes in total; every wait is an
+ * `llm/retry` event the conversation shows while it lasts.
+ */
+export const ROUTER_RETRY_POLICY = Object.freeze({
+  mode: "normal",
+  maxRetries: 12,
+  retryableCodes: ["EMPTY_RESPONSE", "RATE_LIMIT", "SERVER", "TIMEOUT", "TRANSPORT"],
+  backoff: { initialDelayMs: 1_000, maxDelayMs: 60_000, jitterRatio: 0.1 },
+});
+
 export function isChatModelId(id) {
   return !NON_CHAT_HINTS.test(id);
 }
@@ -73,10 +88,14 @@ export async function fetchChatModels() {
  */
 export async function fetchRouterModels(env) {
   const routerUrl = String(env.routerUrl ?? "").replace(/\/+$/, "") || routerGatewayUrl();
-  const res = await fetch(`${routerUrl}/models?include_not_ready=true`, {
+  const res = await fetch(`${routerUrl}/models`, {
     method: "GET",
     headers: {
-      ...routerAuthHeaders(env.routerApiKey, env.olaresAppId),
+      ...routerAuthHeaders(
+        env.routerApiKey,
+        env.olaresAppId,
+        env.olaresUsername || routerEndUser(),
+      ),
       accept: "application/json",
     },
     signal: AbortSignal.timeout(15_000),

package/router/search.js

@@ -22,6 +22,13 @@ export function searchWebErrorCode(code) {
   return SEARCH_WEB_CODES[code] ?? "WEB_PROVIDER_ERROR";
 }
 
+/**
+ * Router's own default-search category. Sending it defers the choice to the
+ * Router console, which is where the search services are configured; Router
+ * refuses it outright when nothing stands behind it.
+ */
+export const ROUTER_DEFAULT_SEARCH_ROUTE = "default-search";
+
 export function searchModelsFromRouterCatalog(payload) {
   return routerCatalogRows(payload)
     .filter((model) => model.mode === "search")
@@ -57,8 +64,9 @@ export function searchSourcesFromRouter(payload) {
 
 const DEFAULT_TIMEOUT_MS = 20_000;
 
-export async function fetchRouterSearchModels() {
-  const { payload } = await catalogCache.get();
+/** @param {{ refresh?: boolean }} [options] */
+export async function fetchRouterSearchModels(options = {}) {
+  const { payload } = await catalogCache.get(options);
   return searchModelsFromRouterCatalog(payload);
 }
 

package/router/session-model.js

@@ -117,6 +117,59 @@ export function effortMenuItems(reasoning) {
   return items;
 }
 
+/** The selection the composer shows: the session's pending choice, else the catalog default. */
+export function sessionModelSelection(projection, catalogDefault) {
+  const next = projection?.next;
+  if (next && typeof next.provider === "string" && typeof next.model === "string") return next;
+  if (
+    catalogDefault
+    && typeof catalogDefault.provider === "string"
+    && typeof catalogDefault.model === "string"
+  ) {
+    return catalogDefault;
+  }
+  return null;
+}
+
+/**
+ * `session.modelCatalog` → the flat list the composer already renders.
+ * Reasoning stays on the model; that is the same metadata the desktop menu reads.
+ */
+export function composerModelsFromCatalog(catalog, selection) {
+  if (!catalog || typeof catalog !== "object") return null;
+  const models = [];
+  for (const group of Array.isArray(catalog.groups) ? catalog.groups : []) {
+    const provider = typeof group?.id === "string" ? group.id : "";
+    if (!provider) continue;
+    for (const model of group.models ?? []) {
+      if (!model?.id) continue;
+      models.push({
+        provider,
+        providerName: group.name || provider,
+        id: model.id,
+        name: model.name || model.id,
+        ...(model.description ? { description: model.description } : {}),
+        ...(model.reasoning ? { reasoning: model.reasoning } : {}),
+      });
+    }
+  }
+  const current = selection ?? null;
+  const routable = Boolean(
+    current
+    && models.some((model) => model.provider === current.provider && model.id === current.model),
+  );
+  return {
+    default: current,
+    routable,
+    failures: (Array.isArray(catalog.failures) ? catalog.failures : []).map((entry) => ({
+      provider: entry.provider ?? entry.id,
+      name: entry.name,
+      message: entry.message,
+    })),
+    models,
+  };
+}
+
 export function selectionKey(selection) {
   return `${selection.provider}\u0000${selection.model ?? selection.id}`;
 }

package/router/shim.js

@@ -1,10 +1,13 @@
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { readBody, sendError, sendJson } from "../tools/http.js";
+import { attachFlowstudioFilesPaths } from "../drive/flowstudio-files.js";
 import { catalogCache } from "./catalog-cache.js";
 import { carriesWebpImage, transcodeWebpImages } from "../media/router-images.js";
-import { routerAuthHeaders, routerGatewayUrl } from "./gateway.js";
+import { routerAuthHeaders, routerEndUser, routerGatewayUrl } from "./gateway.js";
 import { STT_MAX_AUDIO_BYTES } from "./stt.js";
+import { adaptGeminiChatBuffer } from "./gemini-schema.js";
+import { isGenerationCreateRoute, withSrefBuffer } from "./sref.js";
 
 export const SHIM_PATH = "/llm/v1";
 export const SHIM_CHAT_TIMEOUT_MS = 120_000;
@@ -33,6 +36,11 @@ export function isAudioShimPath(suffix) {
   return /(^|\/)audio(\/|$)/.test(suffix);
 }
 
+/** GET /generations/:id — not /content, not create. */
+export function isGenerationPoll(suffix) {
+  return /^generations\/[^/]+$/.test(String(suffix ?? "").replace(/\/+$/, ""));
+}
+
 export function shimBudget(suffix) {
   const audio = isAudioShimPath(suffix);
   return {
@@ -53,7 +61,11 @@ export function shimRequestHeaders(incoming, env = process.env) {
   }
   Object.assign(
     headers,
-    routerAuthHeaders(env.LARES_ROUTER_API_KEY?.trim() || null, env.OLARES_APP_ID?.trim() || "lares"),
+    routerAuthHeaders(
+      env.LARES_ROUTER_API_KEY?.trim() || null,
+      env.OLARES_APP_ID?.trim() || "lares",
+      routerEndUser(env, incoming),
+    ),
   );
   return headers;
 }
@@ -139,7 +151,78 @@ function downstreamCancellation(req, res) {
   return controller;
 }
 
-export function proxyToRouter(req, res, env = process.env) {
+function isJsonContentType(value) {
+  return String(value ?? "").toLowerCase().includes("application/json");
+}
+
+function collectStream(stream, maxBytes, signal) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    const onAbort = () => {
+      stream.destroy();
+      reject(signal?.reason instanceof Error ? signal.reason : new Error("aborted"));
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    stream.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > maxBytes) {
+        stream.destroy();
+        reject(new Error("generation poll body exceeded the read limit"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    stream.on("end", () => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve(Buffer.concat(chunks));
+    });
+    stream.on("error", (err) => {
+      signal?.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+  });
+}
+
+async function enrichGenerationPoll(up, res, req, env, cancellation, deps) {
+  const status = up.statusCode ?? 502;
+  const headers = shimResponseHeaders(up.headers);
+  let raw;
+  try {
+    raw = await collectStream(up, SHIM_CHAT_MAX_BYTES, cancellation.signal);
+  } catch (err) {
+    if (cancellation.signal.aborted || res.headersSent) return;
+    sendError(res, err, "llm_proxy_failed");
+    return;
+  }
+  if (cancellation.signal.aborted || res.headersSent) return;
+  const json = status === 200 && isJsonContentType(headers["content-type"] ?? up.headers["content-type"]);
+  if (!json) {
+    res.writeHead(status, headers);
+    res.end(raw);
+    return;
+  }
+  let payload;
+  try {
+    payload = JSON.parse(raw.toString("utf8"));
+  } catch {
+    res.writeHead(status, headers);
+    res.end(raw);
+    return;
+  }
+  const enriched = await attachFlowstudioFilesPaths(payload, routerEndUser(env, req.headers), {
+    signal: cancellation.signal,
+    cat: deps.catFiles,
+  });
+  if (cancellation.signal.aborted || res.headersSent) return;
+  sendJson(res, status, enriched);
+}
+
+export function proxyToRouter(req, res, env = process.env, deps = {}) {
   if (isModelsGet(req)) {
     serveCachedModels(req, res);
     return;
@@ -154,6 +237,7 @@ export function proxyToRouter(req, res, env = process.env) {
   const transport = target.protocol === "https:" ? httpsRequest : httpRequest;
   const method = (req.method ?? "GET").toUpperCase();
   const cancellation = downstreamCancellation(req, res);
+  const enrichPoll = method === "GET" && isGenerationPoll(suffix);
 
   const run = async () => {
     let body;
@@ -163,6 +247,12 @@ export function proxyToRouter(req, res, env = process.env) {
         message: budget.tooLargeMessage,
       });
       if (!budget.audio && carriesWebpImage(body)) body = await transcodeWebpImages(body);
+      if (method === "POST" && isGenerationCreateRoute(suffix)) {
+        body = withSrefBuffer(body, routerEndUser(env, req.headers), env);
+      }
+      if (method === "POST" && suffix.replace(/\/+$/, "") === "chat/completions") {
+        body = adaptGeminiChatBuffer(body);
+      }
       headers["content-length"] = String(body.length);
     }
     if (cancellation.signal.aborted) return;
@@ -175,6 +265,17 @@ export function proxyToRouter(req, res, env = process.env) {
           up.destroy();
           return;
         }
+        if (enrichPoll) {
+          void enrichGenerationPoll(up, res, req, env, cancellation, deps).catch((err) => {
+            if (cancellation.signal.aborted) return;
+            if (res.headersSent) {
+              res.destroy();
+              return;
+            }
+            sendError(res, err, "llm_proxy_failed");
+          });
+          return;
+        }
         res.writeHead(up.statusCode ?? 502, shimResponseHeaders(up.headers));
         up.pipe(res);
       },