@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/rtk/index.js

@@ -0,0 +1,155 @@
+// RTK port: compress tool_result content in LLM request bodies
+// Injected at the top of translateRequest (before any format translation)
+import { RAW_CAP, MIN_COMPRESS_SIZE } from "./constants.js";
+import { autoDetectFilter } from "./autodetect.js";
+import { safeApply } from "./applyFilter.js";
+
+// Compress tool_result content in-place. Returns stats or null if disabled/failed.
+export function compressMessages(body, enabled) {
+  if (!enabled) return null;
+  if (!body) return null;
+
+  // Kiro format: conversationState.history + conversationState.currentMessage
+  if (body.conversationState) {
+    return compressKiroFormat(body, enabled);
+  }
+
+  // Support both OpenAI/Claude "messages" and OpenAI Responses "input"
+  const items = Array.isArray(body.messages) ? body.messages
+    : Array.isArray(body.input) ? body.input
+    : null;
+  if (!items) return null;
+
+  const stats = { bytesBefore: 0, bytesAfter: 0, hits: [] };
+  try {
+    for (let i = 0; i < items.length; i++) {
+      const msg = items[i];
+      if (!msg) continue;
+
+      // Shape 4: OpenAI Responses — top-level { type:"function_call_output", output: string | [{type:"input_text", text}] }
+      if (msg.type === "function_call_output") {
+        if (typeof msg.output === "string") {
+          msg.output = compressText(msg.output, stats, "openai-responses-string");
+        } else if (Array.isArray(msg.output)) {
+          for (let k = 0; k < msg.output.length; k++) {
+            const part = msg.output[k];
+            if (part && part.type === "input_text" && typeof part.text === "string") {
+              part.text = compressText(part.text, stats, "openai-responses-array");
+            }
+          }
+        }
+        continue;
+      }
+
+      // Shape 1: OpenAI tool message — { role:"tool", content: "string" }
+      if (msg.role === "tool" && typeof msg.content === "string") {
+        msg.content = compressText(msg.content, stats, "openai-tool");
+        continue;
+      }
+
+      if (!Array.isArray(msg.content)) continue;
+
+      // Shape 1b: OpenAI tool message — { role:"tool", content:[{type:"text", text:"..."}] }
+      if (msg.role === "tool") {
+        for (let k = 0; k < msg.content.length; k++) {
+          const part = msg.content[k];
+          if (part && part.type === "text" && typeof part.text === "string") {
+            part.text = compressText(part.text, stats, "openai-tool-array");
+          }
+        }
+        continue;
+      }
+
+      // Shape 2/3: blocks array with tool_result entries
+      for (let j = 0; j < msg.content.length; j++) {
+        const block = msg.content[j];
+        if (!block || block.type !== "tool_result") continue;
+        if (block.is_error === true) continue; // preserve error traces
+
+        if (typeof block.content === "string") {
+          // Shape 2: claude string form
+          block.content = compressText(block.content, stats, "claude-string");
+        } else if (Array.isArray(block.content)) {
+          // Shape 3: claude array form — compress each text part
+          for (let k = 0; k < block.content.length; k++) {
+            const part = block.content[k];
+            if (part && part.type === "text" && typeof part.text === "string") {
+              part.text = compressText(part.text, stats, "claude-array");
+            }
+          }
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("[RTK] compressMessages error:", e.message);
+    return null;
+  }
+  return stats;
+}
+
+// Compress Kiro format: conversationState.history[].userInputMessage.userInputMessageContext.toolResults[].content[].text
+function compressKiroFormat(body, enabled) {
+  const stats = { bytesBefore: 0, bytesAfter: 0, hits: [] };
+  try {
+    const state = body.conversationState;
+    const allMessages = [...(Array.isArray(state?.history) ? state.history : [])];
+    if (state?.currentMessage) allMessages.push(state.currentMessage);
+
+    for (const msg of allMessages) {
+      const toolResults = msg?.userInputMessage?.userInputMessageContext?.toolResults;
+      if (!Array.isArray(toolResults)) continue;
+
+      for (const tr of toolResults) {
+        if (tr.status === "error") continue; // preserve error traces
+        if (!Array.isArray(tr.content)) continue;
+
+        for (const part of tr.content) {
+          if (part && typeof part.text === "string") {
+            part.text = compressText(part.text, stats, "kiro-tool-result");
+          }
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("[RTK] compressKiroFormat error:", e.message);
+    return null;
+  }
+  return stats;
+}
+
+function compressText(text, stats, shape) {
+  const bytesIn = text.length;
+  stats.bytesBefore += bytesIn;
+
+  if (bytesIn < MIN_COMPRESS_SIZE || bytesIn > RAW_CAP) {
+    stats.bytesAfter += bytesIn;
+    return text;
+  }
+
+  const fn = autoDetectFilter(text);
+  if (!fn) {
+    stats.bytesAfter += bytesIn;
+    return text;
+  }
+
+  const out = safeApply(fn, text);
+
+  // Safety: never return empty, never grow the input
+  if (!out || out.length === 0 || out.length >= bytesIn) {
+    stats.bytesAfter += bytesIn;
+    return text;
+  }
+
+  stats.bytesAfter += out.length;
+  stats.hits.push({ shape, filter: fn.filterName || fn.name, saved: bytesIn - out.length });
+  return out;
+}
+
+// Convenience: format a log line from stats
+export function formatRtkLog(stats) {
+  if (!stats || !stats.hits || stats.hits.length === 0) return null;
+  const saved = stats.bytesBefore - stats.bytesAfter;
+  const pct = stats.bytesBefore > 0 ? ((saved / stats.bytesBefore) * 100).toFixed(1) : "0";
+  const filters = Array.from(new Set(stats.hits.map(h => h.filter))).join(",");
+  return `[RTK] saved ${saved}B / ${stats.bytesBefore}B (${pct}%) via [${filters}] hits=${stats.hits.length}`;
+}

package/open-sse/rtk/paleo.js

@@ -0,0 +1,47 @@
+/**
+ * Paleo Token Saver — inject system prompt to minimize output tokens.
+ * Inspired by github.com/mocasus/paleo
+ * 
+ * Levels:
+ *   lite   — gentle hints to be concise
+ *   full   — strong compression instructions
+ *   ultra  — extreme telegraphic, max savings
+ */
+
+import { injectSystemPrompt } from "./systemInject.js";
+
+const PALEO_PROMPTS = {
+  lite: [
+    "Be concise. Skip filler phrases, unnecessary preambles, and redundant explanations. Get to the point directly.",
+    "Do not repeat information already provided. Use minimal words to convey maximum meaning.",
+  ].join("\n"),
+
+  full: [
+    "You are in token-saving mode. Follow these rules strictly:",
+    "- NO filler: skip 'Certainly', 'Sure', 'Here is', 'Let me', 'I will', preamble, disclaimers.",
+    "- NO repetition: never restate what the user said or what you already said.",
+    "- Compress: use fragments, abbreviations, and terse phrasing when clarity permits.",
+    "- Code: output ONLY the changed lines with minimal context. No full-file rewrites unless asked.",
+    "- Lists: use short bullets, not full sentences.",
+    "- If the answer is a single value, output ONLY that value.",
+    "- Arrow causality for reasoning: X → Y → Z, not 'Because X, therefore Y, which leads to Z'.",
+  ].join("\n"),
+
+  ultra: [
+    "TOKEN-SAVING ULTRA MODE. Rules enforced:",
+    "- Absolute minimum output. Every token costs money.",
+    "- Fragments OK. Articles/determiners optional (a, the, this).",
+    "- No greeting, no sign-off, no filler, no hedging.",
+    "- Code: diffs/patches only. No explanations unless asked.",
+    "- Data: raw values, no wrapping prose.",
+    "- If yes/no suffices, output only yes/no.",
+    "- Chain reasoning: A→B→C. No connective tissue.",
+    "- Max 50% of what you'd normally output. Prefer shorter.",
+  ].join("\n"),
+};
+
+export function injectPaleo(body, format, level) {
+  const prompt = PALEO_PROMPTS[level];
+  if (!prompt) return;
+  injectSystemPrompt(body, format, prompt);
+}

package/open-sse/rtk/ponytail.js

@@ -0,0 +1,9 @@
+// Ponytail injector: appends the "lazy senior dev" instruction into the system
+// message of the final request body, just before dispatch to the provider executor.
+
+import { injectSystemPrompt } from "./systemInject.js";
+import { PONYTAIL_PROMPTS } from "./ponytailPrompts.js";
+
+export function injectPonytail(body, format, level) {
+  injectSystemPrompt(body, format, PONYTAIL_PROMPTS[level]);
+}

package/open-sse/rtk/ponytailPrompt.js

@@ -0,0 +1,52 @@
+// Ponytail intensity-level prompts injected into system message to bias toward minimal code.
+// Adapted from ponytail skill (https://github.com/DietrichGebert/ponytail).
+
+export const PONYTAIL_LEVELS = {
+  LITE: "lite",
+  FULL: "full",
+  ULTRA: "ultra",
+};
+
+const SHARED_PERSONA = "You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.";
+
+const SHARED_LADDER = "Before writing code, stop at the first rung that holds: 1) Does this need to exist at all? (YAGNI) 2) Stdlib does it? Use it. 3) Native platform feature covers it? Use it (CSS over JS, DB constraint over app code). 4) Already-installed dependency solves it? Use it; never add a new one for what a few lines can do. 5) Can it be one line? One line. 6) Only then: the minimum code that works.";
+
+const SHARED_RULES = "No unrequested abstractions (no interface with one implementation, no factory for one product, no config for a value that never changes). No boilerplate or scaffolding \"for later\". Deletion over addition. Boring over clever. Fewest files possible; shortest working diff wins. Two stdlib options the same size: take the edge-case-correct one. Mark deliberate simplifications with a `ponytail:` comment naming the ceiling and upgrade path.";
+
+const SHARED_OUTPUT = "Code first. Then at most three short lines: what was skipped, when to add it. No essays or design notes. Pattern: `[code] → skipped: [X], add when [Y].`";
+
+const SHARED_NOT_LAZY = "Never simplify away: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind (an assert-based self-check or one small test file; no frameworks). Trivial one-liners need no test.";
+
+const SHARED_PERSISTENCE = "ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if unsure.";
+
+export const PONYTAIL_PROMPTS = {
+  [PONYTAIL_LEVELS.LITE]: [
+    SHARED_PERSONA,
+    "Lite: build what's asked, but name the lazier alternative in one line. User picks.",
+    SHARED_LADDER,
+    SHARED_RULES,
+    SHARED_OUTPUT,
+    SHARED_NOT_LAZY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [PONYTAIL_LEVELS.FULL]: [
+    SHARED_PERSONA,
+    "Full: the ladder enforced. Stdlib and native first. Shortest diff, shortest explanation.",
+    SHARED_LADDER,
+    SHARED_RULES,
+    SHARED_OUTPUT,
+    SHARED_NOT_LAZY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [PONYTAIL_LEVELS.ULTRA]: [
+    SHARED_PERSONA,
+    "Ultra: YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same response.",
+    SHARED_LADDER,
+    SHARED_RULES,
+    SHARED_OUTPUT,
+    SHARED_NOT_LAZY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+};

package/open-sse/rtk/ponytailPrompts.js

@@ -0,0 +1,76 @@
+// Ponytail intensity-level prompts injected into the system message to reduce
+// OUTPUT tokens by writing less code (YAGNI / stdlib-first / one-line-first).
+// Adapted from the ponytail skill (https://github.com/DietrichGebert/ponytail).
+//
+// Orthogonal to Caveman: ponytail governs WHAT the model builds (code
+// minimalism); caveman governs HOW it talks (terse prose). The ponytail author
+// explicitly recommends pairing the two ("Ponytail governs what you build, not
+// how you talk — pair with Caveman for terse prose").
+
+const PONYTAIL_LEVELS = {
+  LITE: "lite",
+  FULL: "full",
+  ULTRA: "ultra",
+};
+
+// The decision ladder is identical across levels; intensity changes how
+// aggressively unrequested scope is challenged.
+const SHARED_LADDER = [
+  "You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.",
+  "Before writing code, stop at the first rung that holds:",
+  "1. Does this need to exist at all? Speculative need = skip it, say so in one line (YAGNI).",
+  "2. Stdlib does it? Use it.",
+  "3. Native platform feature covers it? Use it (native input over a picker lib, CSS over JS, DB constraint over app code).",
+  "4. Already-installed dependency solves it? Use it. Never add a new dependency for what a few lines can do.",
+  "5. Can it be one line? One line.",
+  "6. Only then: the minimum code that works.",
+].join(" ");
+
+const SHARED_RULES = [
+  "No unrequested abstractions (no interface with one implementation, no factory for one product, no config for a value that never changes).",
+  "No boilerplate or scaffolding 'for later'. Deletion over addition. Boring over clever. Fewest files possible; shortest working diff wins.",
+  "Two stdlib options the same size? Take the one correct on edge cases — lazy means less code, not the flimsier algorithm.",
+  "Mark deliberate simplifications with a `ponytail:` comment naming the ceiling and upgrade path (e.g. `// ponytail: global lock, per-account locks if throughput matters`).",
+].join(" ");
+
+// Hard boundaries — never simplified away. Mirrors caveman's safety stance.
+const SHARED_BOUNDARIES = "Never simplify away: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, or anything explicitly requested. If the user insists on the full version, build it without re-arguing.";
+
+// Skeptical verification — no false claims, no assumptions.
+const SHARED_SKEPTICAL = "now is 2026, Be skeptical: never claim 'fixed', 'working', or 'correct' without concrete proof (test output, diff, reproducible verification). If a test passes, verify it tests what you think it tests. Check for side effects. Never fabricate reports ('all tests pass' without running them). Distinguish pre-existing bugs from ones you caused — run tests BEFORE and AFTER, diff the results. Report honestly: if broken and can't fix, say so. If skipped, explain why. If caveats, state them. Verify before declaring done — run relevant tests AFTER changes, show actual output.";
+
+const SHARED_OUTPUT = "Code first. Then at most three short lines: what was skipped and when to add it. Pattern: [code] then skipped: [X], add when [Y]. If the explanation is longer than the code, delete the explanation.";
+
+const SHARED_PERSISTENCE = "ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if unsure.";
+
+export const PONYTAIL_PROMPTS = {
+  [PONYTAIL_LEVELS.LITE]: [
+    SHARED_LADDER,
+    "Level: lite. Build what's asked, but name the lazier alternative in one line — the user picks.",
+    SHARED_RULES,
+    SHARED_OUTPUT,
+    SHARED_BOUNDARIES,
+    SHARED_SKEPTICAL,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [PONYTAIL_LEVELS.FULL]: [
+    SHARED_LADDER,
+    "Level: full. The ladder is enforced — stdlib and native first, shortest diff, shortest explanation. Ship the lazy version and question unrequested scope in the same response.",
+    SHARED_RULES,
+    SHARED_OUTPUT,
+    SHARED_BOUNDARIES,
+    SHARED_SKEPTICAL,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [PONYTAIL_LEVELS.ULTRA]: [
+    SHARED_LADDER,
+    "Level: ultra. YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same breath. No feature until a profiler or a real requirement demands it.",
+    SHARED_RULES,
+    SHARED_OUTPUT,
+    SHARED_BOUNDARIES,
+    SHARED_SKEPTICAL,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+};

package/open-sse/rtk/pxpipe.js

@@ -0,0 +1,104 @@
+// PXPIPE: render bulky Claude-format context as dense PNGs via pxpipe-proxy's
+// library API (transformAnthropicMessages). Fail-open like every token saver:
+// any error/timeout returns { body: null, summary } and leaves the request untouched.
+import { FORMATS } from "../translator/formats.js";
+
+const DEFAULT_TIMEOUT_MS = 15000;
+const DEFAULT_MIN_CHARS = 25000;
+// pxpipe's own profitability gate assumes ~4 chars/token; reuse it for the
+// estimated before/after numbers surfaced in stats (marked "estimated" in UI).
+const EST_CHARS_PER_TOKEN = 4;
+
+function bodyChars(body) {
+  try {
+    return JSON.stringify(body)?.length || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function estTokens(chars) {
+  return Math.round(chars / EST_CHARS_PER_TOKEN);
+}
+
+function skipped(reason, extra = {}) {
+  return { body: null, summary: { applied: false, reason, ...extra } };
+}
+
+// Transform a Claude-format request body through pxpipe. Returns
+// { body: <new body object> | null, summary } — body is null when nothing changed.
+// opts.transform is injected by the host (src side) so open-sse stays free of
+// filesystem/install concerns and remains usable standalone.
+export async function compressWithPxpipe(body, { enabled, format, model, minChars, timeoutMs, transform } = {}) {
+  if (!enabled) return skipped("disabled");
+  if (typeof transform !== "function") return skipped("not_installed");
+  if (!body) return skipped("missing_body");
+  if (format !== FORMATS.CLAUDE) return skipped("unsupported_format", { detail: format });
+
+  const startedAt = Date.now();
+  const originalChars = bodyChars(body);
+  const threshold = Number(minChars) > 0 ? Number(minChars) : DEFAULT_MIN_CHARS;
+  if (originalChars < threshold) {
+    return skipped("below_threshold", { originalChars, threshold });
+  }
+
+  try {
+    const encoded = new TextEncoder().encode(JSON.stringify(body));
+    const budget = Number(timeoutMs) > 0 ? Number(timeoutMs) : DEFAULT_TIMEOUT_MS;
+    // transformAnthropicMessages is local CPU work and can't be aborted; race a
+    // timer and discard the result if it loses (input body is never mutated).
+    const result = await Promise.race([
+      transform({
+        body: encoded,
+        model,
+        options: { minCompressChars: threshold },
+      }),
+      new Promise((resolve) => setTimeout(() => resolve(null), budget)),
+    ]);
+    if (!result) return skipped("timeout", { originalChars, durationMs: Date.now() - startedAt });
+    if (!result.applied) {
+      return skipped(result.reason || "passthrough", {
+        detail: result.detail,
+        originalChars,
+        durationMs: Date.now() - startedAt,
+      });
+    }
+
+    const newBody = JSON.parse(new TextDecoder().decode(result.body));
+    const compressedBodyChars = bodyChars(newBody);
+    const info = result.info || {};
+    const imagedChars = info.compressedChars || 0;
+    // The transformed body is BIGGER in bytes (base64 PNGs) but cheaper in tokens:
+    // images bill by pixels (Anthropic: pixels/750), not by encoded length. So the
+    // after-estimate is remaining-text tokens + image tokens — never chars/4 of the
+    // new body. Provider-billed usage recorded per request stays the ground truth.
+    const imageTokensEst = info.imageTokens
+      || (info.imagePixels ? Math.round(info.imagePixels / 750) : (info.imageCount || 0) * 4761);
+    const summary = {
+      applied: true,
+      reason: "applied",
+      originalChars,
+      compressedBodyChars,
+      imagedChars,
+      imageCount: info.imageCount || 0,
+      imageBytes: info.imageBytes || 0,
+      tokensBeforeEst: info.baselineTokens || estTokens(originalChars),
+      tokensAfterEst: estTokens(Math.max(0, originalChars - imagedChars)) + imageTokensEst,
+      durationMs: Date.now() - startedAt,
+      cacheOwnsControl: result.cache?.ownsCacheControl === true,
+    };
+    summary.tokensSavedEst = Math.max(0, summary.tokensBeforeEst - summary.tokensAfterEst);
+    summary.savedPct = summary.tokensBeforeEst > 0
+      ? +((summary.tokensSavedEst / summary.tokensBeforeEst) * 100).toFixed(2)
+      : 0;
+    return { body: newBody, summary };
+  } catch (e) {
+    return skipped("transform_error", { detail: e?.message || String(e), originalChars, durationMs: Date.now() - startedAt });
+  }
+}
+
+export function formatPxpipeLog(summary) {
+  if (!summary) return null;
+  if (!summary.applied) return null;
+  return `imaged ${summary.imagedChars}ch → ${summary.imageCount} image(s) | est ${summary.tokensBeforeEst}→${summary.tokensAfterEst} tokens (-${summary.savedPct}%) | ${summary.durationMs}ms`;
+}

package/open-sse/rtk/registry.js

@@ -0,0 +1,38 @@
+import { FILTERS } from "./constants.js";
+import { gitDiff } from "./filters/gitDiff.js";
+import { gitStatus } from "./filters/gitStatus.js";
+import { grep } from "./filters/grep.js";
+import { find } from "./filters/find.js";
+import { dedupLog } from "./filters/dedupLog.js";
+import { ls } from "./filters/ls.js";
+import { tree } from "./filters/tree.js";
+import { smartTruncate } from "./filters/smartTruncate.js";
+import { readNumbered } from "./filters/readNumbered.js";
+import { searchList } from "./filters/searchList.js";
+
+const REGISTRY = {
+  [FILTERS.GIT_DIFF]: gitDiff,
+  [FILTERS.GIT_STATUS]: gitStatus,
+  [FILTERS.GREP]: grep,
+  [FILTERS.FIND]: find,
+  [FILTERS.DEDUP_LOG]: dedupLog,
+  [FILTERS.LS]: ls,
+  [FILTERS.TREE]: tree,
+  [FILTERS.SMART_TRUNCATE]: smartTruncate,
+  [FILTERS.READ_NUMBERED]: readNumbered,
+  [FILTERS.SEARCH_LIST]: searchList
+};
+
+// Rust resolve_filter aliases (pipe_cmd.rs): grep|rg, find|fd
+const ALIASES = {
+  rg: grep,
+  fd: find
+};
+
+export function resolveFilter(name) {
+  return REGISTRY[name] || ALIASES[name] || null;
+}
+
+export function allFilters() {
+  return REGISTRY;
+}

package/open-sse/rtk/systemInject.js

@@ -0,0 +1,98 @@
+// Shared system-prompt injector: appends an instruction into the system message of
+// the final request body, dispatching by format so it works for translated and
+// native-passthrough flows. Used by caveman.js and ponytail.js.
+
+import { FORMATS } from "../translator/formats.js";
+
+const SEP = "\n\n";
+
+export function injectSystemPrompt(body, format, prompt) {
+  if (!body || !prompt) return;
+
+  switch (format) {
+    case FORMATS.CLAUDE:
+      injectClaudeSystem(body, prompt);
+      return;
+    case FORMATS.GEMINI:
+    case FORMATS.GEMINI_CLI:
+    case FORMATS.VERTEX:
+    case FORMATS.ANTIGRAVITY:
+      // Antigravity wraps Gemini shape in body.request → injectGeminiSystem handles it
+      injectGeminiSystem(body, prompt);
+      return;
+    default:
+      // OpenAI and OpenAI-shaped formats (responses/codex/cursor/kiro/ollama)
+      injectMessagesSystem(body, prompt);
+  }
+}
+
+// OpenAI-shaped: messages[] (chat) or input[] (responses) or instructions (responses string)
+function injectMessagesSystem(body, prompt) {
+  // OpenAI Responses API: top-level string field
+  if (typeof body.instructions === "string") {
+    body.instructions = body.instructions
+      ? `${body.instructions}${SEP}${prompt}`
+      : prompt;
+    return;
+  }
+
+  const arr = Array.isArray(body.messages) ? body.messages
+    : Array.isArray(body.input) ? body.input
+    : null;
+  if (!arr) return;
+
+  const idx = arr.findIndex(m => m && (m.role === "system" || m.role === "developer"));
+  if (idx >= 0) {
+    appendToOpenAIMessage(arr[idx], prompt);
+  } else {
+    arr.unshift({ role: "system", content: prompt });
+  }
+}
+
+function appendToOpenAIMessage(msg, prompt) {
+  if (typeof msg.content === "string") {
+    msg.content = `${msg.content}${SEP}${prompt}`;
+  } else if (Array.isArray(msg.content)) {
+    // Responses-style array of parts {type:"input_text"|"text", text}
+    msg.content.push({ type: "input_text", text: prompt });
+  } else {
+    msg.content = prompt;
+  }
+}
+
+// Claude shape: body.system as string | array of {type:"text", text}
+// Insert before the last cache_control block to keep injection inside the cached prefix.
+function injectClaudeSystem(body, prompt) {
+  if (typeof body.system === "string" && body.system.length > 0) {
+    body.system = `${body.system}${SEP}${prompt}`;
+    return;
+  }
+  if (Array.isArray(body.system)) {
+    const block = { type: "text", text: prompt };
+    let lastCacheIdx = -1;
+    for (let i = body.system.length - 1; i >= 0; i--) {
+      if (body.system[i]?.cache_control) { lastCacheIdx = i; break; }
+    }
+    if (lastCacheIdx >= 0) {
+      body.system.splice(lastCacheIdx, 0, block);
+    } else {
+      body.system.push(block);
+    }
+    return;
+  }
+  body.system = prompt;
+}
+
+// Gemini shape: body.system_instruction | body.systemInstruction | body.request.systemInstruction
+// Each shape: { parts: [{ text }] }
+function injectGeminiSystem(body, prompt) {
+  const target = body.request && typeof body.request === "object" ? body.request : body;
+  const useSnake = Object.prototype.hasOwnProperty.call(target, "system_instruction");
+  const key = useSnake ? "system_instruction" : "systemInstruction";
+  const sys = target[key];
+  if (sys && Array.isArray(sys.parts)) {
+    sys.parts.push({ text: prompt });
+    return;
+  }
+  target[key] = { parts: [{ text: prompt }] };
+}