n9router 0.4.47 → 0.4.49

package/app/open-sse/services/usage/grok-cli.js

@@ -0,0 +1,274 @@
+/**
+ * Grok CLI / Grok Build usage handler
+ *
+ * Source of truth: official grok-shell/grok-pager traffic to cli-chat-proxy.grok.com
+ *   GET /v1/billing?format=credits
+ *   GET /v1/user?include=subscription
+ *
+ * Observed billing shape (protobuf-json style `{ val: number }`):
+ * {
+ *   config: {
+ *     currentPeriod: { type: "USAGE_PERIOD_TYPE_WEEKLY", start, end },
+ *     onDemandCap: { val },
+ *     onDemandUsed: { val },
+ *     prepaidBalance: { val },
+ *     isUnifiedBillingUser: true,
+ *     billingPeriodStart, billingPeriodEnd
+ *   }
+ * }
+ *
+ * Exhausted free/promo accounts return cap=0/used=0/prepaid=0 and chat 402s with
+ * personal-team-blocked:spending-limit. Paid/sub accounts surface non-zero cap
+ * or prepaidBalance; richer credit fields are parsed opportunistically if present.
+ */
+
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+import { U, parseResetTime, toFiniteNumber } from "./shared.js";
+
+const USAGE = U("grok-cli");
+const BILLING_URL = USAGE.url || "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+const USER_URL = USAGE.userUrl || "https://cli-chat-proxy.grok.com/v1/user?include=subscription";
+
+/** Unwrap protobuf-json `{ val: n }` or plain numbers/strings. */
+function unwrapVal(value, fallback = 0) {
+  if (value == null) return fallback;
+  if (typeof value === "object" && !Array.isArray(value) && "val" in value) {
+    return toFiniteNumber(value.val, fallback);
+  }
+  return toFiniteNumber(value, fallback);
+}
+
+function buildGrokCliHeaders(accessToken, providerSpecificData = {}) {
+  const psd = providerSpecificData || {};
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    Accept: "application/json",
+    "User-Agent": "grok-pager/0.2.93 grok-shell/0.2.93 (linux; x86_64)",
+    "x-xai-token-auth": "xai-grok-cli",
+    "x-grok-client-identifier": "grok-pager",
+    "x-grok-client-version": "0.2.93",
+  };
+  const email = psd.email;
+  const userId = psd.userId || psd.principalId;
+  if (email) headers["x-email"] = email;
+  if (userId) headers["x-userid"] = userId;
+  return headers;
+}
+
+function resolvePlan(user, config) {
+  const tier = typeof user?.subscriptionTier === "string" ? user.subscriptionTier.trim() : "";
+  if (tier) {
+    return tier
+      .replace(/[_-]+/g, " ")
+      .replace(/\b\w/g, (c) => c.toUpperCase());
+  }
+  if (user?.hasGrokCodeAccess === true) return "Grok Code";
+  if (config?.isUnifiedBillingUser === true) return "Grok Build";
+  return "Grok Build";
+}
+
+function makeQuota({ used, total, resetAt, unlimited = false }) {
+  const safeTotal = Math.max(0, toFiniteNumber(total, 0));
+  const safeUsed = Math.max(0, toFiniteNumber(used, 0));
+  // Do NOT set absolute `remaining` — QuotaTable's getRemainingPercentage treats
+  // `remaining` as a 0–100 percentage (same trap as Qoder credits).
+  if (unlimited || safeTotal === 0) {
+    return {
+      used: safeUsed,
+      total: 0,
+      remainingPercentage: unlimited ? 100 : 0,
+      resetAt: resetAt || null,
+      unlimited: true,
+    };
+  }
+  const remaining = Math.max(0, safeTotal - safeUsed);
+  const remainingPercentage = (remaining / safeTotal) * 100;
+  return {
+    used: safeUsed,
+    total: safeTotal,
+    remainingPercentage,
+    resetAt: resetAt || null,
+    unlimited: false,
+  };
+}
+
+/**
+ * Map billing JSON → normalized quotas object for the dashboard.
+ * Returns { quotas, periodEnd, exhaustedHint } or empty quotas when nothing usable.
+ */
+export function parseGrokCliBilling(billing, user = null) {
+  const root = billing && typeof billing === "object" ? billing : {};
+  const config =
+    root.config && typeof root.config === "object" && !Array.isArray(root.config)
+      ? root.config
+      : root;
+
+  const periodEnd =
+    parseResetTime(config.billingPeriodEnd) ||
+    parseResetTime(config.currentPeriod?.end) ||
+    parseResetTime(root.billingPeriodEnd) ||
+    null;
+
+  const quotas = {};
+
+  // Primary: on-demand spending window (subscription / promo credits)
+  const onDemandCap = unwrapVal(config.onDemandCap ?? root.onDemandCap, NaN);
+  const onDemandUsed = unwrapVal(config.onDemandUsed ?? root.onDemandUsed, NaN);
+  if (Number.isFinite(onDemandCap) && onDemandCap > 0) {
+    const used = Number.isFinite(onDemandUsed) ? Math.max(0, onDemandUsed) : 0;
+    quotas["On-demand"] = makeQuota({
+      used,
+      total: onDemandCap,
+      resetAt: periodEnd,
+    });
+  } else if (Number.isFinite(onDemandCap) && onDemandCap === 0 && Number.isFinite(onDemandUsed)) {
+    // Cap 0 is the exhausted free/promo state (chat returns 402 spending-limit).
+    // UI treats total===0 as unlimited, so use a synthetic 1/1 depleted row.
+    quotas["On-demand"] = {
+      used: 1,
+      total: 1,
+      remainingPercentage: 0,
+      resetAt: periodEnd,
+      unlimited: false,
+    };
+  }
+
+  // Prepaid top-up balance (remaining credits; no fixed allotment known)
+  const prepaid = unwrapVal(config.prepaidBalance ?? root.prepaidBalance, NaN);
+  if (Number.isFinite(prepaid) && prepaid > 0) {
+    // Show full bar against the current balance (0 spent of this remaining pot).
+    quotas["Prepaid"] = {
+      used: 0,
+      total: prepaid,
+      remainingPercentage: 100,
+      resetAt: null,
+      unlimited: false,
+    };
+  }
+
+  // Opportunistic richer credit envelopes (future / other account types)
+  const creditBags = [
+    root.credits,
+    root.creditBalance,
+    root.usage,
+    config.credits,
+    config.includedCredits,
+    config.subscriptionCredits,
+  ].filter((bag) => bag && typeof bag === "object" && !Array.isArray(bag));
+
+  for (const bag of creditBags) {
+    const total = unwrapVal(
+      bag.total ?? bag.limit ?? bag.cap ?? bag.allocation ?? bag.amount,
+      NaN,
+    );
+    const used = unwrapVal(bag.used ?? bag.spent ?? bag.consumed, NaN);
+    const remaining = unwrapVal(bag.remaining ?? bag.balance ?? bag.left, NaN);
+    if (Number.isFinite(total) && total > 0) {
+      const resolvedUsed = Number.isFinite(used)
+        ? used
+        : Number.isFinite(remaining)
+          ? Math.max(0, total - remaining)
+          : 0;
+      if (!quotas.Credits) {
+        quotas.Credits = makeQuota({
+          used: resolvedUsed,
+          total,
+          resetAt: parseResetTime(bag.resetAt || bag.resetsAt || bag.end) || periodEnd,
+        });
+      }
+    } else if (Number.isFinite(remaining) && remaining >= 0 && !quotas.Credits) {
+      quotas.Credits = {
+        used: 0,
+        total: remaining > 0 ? remaining : 1,
+        remainingPercentage: remaining > 0 ? 100 : 0,
+        resetAt: periodEnd,
+        unlimited: false,
+      };
+    }
+  }
+
+  // Exhausted when every finite quota bar is at 0% remaining
+  const exhausted =
+    Object.keys(quotas).length > 0 &&
+    Object.values(quotas).every(
+      (q) => q.unlimited !== true && (q.remainingPercentage ?? 100) <= 0,
+    );
+
+  return {
+    plan: resolvePlan(user, config),
+    quotas,
+    periodEnd,
+    exhausted,
+    rawConfig: config,
+  };
+}
+
+/**
+ * @param {string} accessToken
+ * @param {object|null} providerSpecificData
+ * @param {object|null} proxyOptions
+ */
+export async function getGrokCliUsage(accessToken, providerSpecificData = null, proxyOptions = null) {
+  if (!accessToken) {
+    return { message: "Grok CLI access token not available." };
+  }
+
+  const headers = buildGrokCliHeaders(accessToken, providerSpecificData);
+
+  try {
+    // Fetch billing + user profile in parallel (same pattern as official CLI startup)
+    const [billingRes, userRes] = await Promise.all([
+      proxyAwareFetch(
+        BILLING_URL,
+        { method: "GET", headers },
+        proxyOptions,
+      ),
+      proxyAwareFetch(
+        USER_URL,
+        { method: "GET", headers },
+        proxyOptions,
+      ).catch(() => null),
+    ]);
+
+    if (billingRes.status === 401 || billingRes.status === 403) {
+      return { message: "Grok CLI authentication expired. Please re-authorize." };
+    }
+
+    if (!billingRes.ok) {
+      const errText = await billingRes.text().catch(() => "");
+      const trimmed = errText ? `: ${errText.slice(0, 200)}` : "";
+      return { message: `Grok CLI billing API error (${billingRes.status})${trimmed}` };
+    }
+
+    const billing = await billingRes.json().catch(() => null);
+    if (!billing || typeof billing !== "object") {
+      return { message: "Grok CLI billing response was not JSON." };
+    }
+
+    let user = null;
+    if (userRes?.ok) {
+      user = await userRes.json().catch(() => null);
+    }
+
+    const parsed = parseGrokCliBilling(billing, user);
+
+    if (!parsed.quotas || Object.keys(parsed.quotas).length === 0) {
+      return {
+        plan: parsed.plan,
+        message:
+          "Grok Build connected, but no credit allotment was returned. Free promo may be exhausted — upgrade at https://grok.com/supergrok or add credits at https://grok.com/?_s=usage.",
+        quotas: {},
+      };
+    }
+
+    // Dashboard hides QuotaTable whenever `message` is set, so only attach a
+    // message when there are no quota rows to render. Depleted accounts keep
+    // the 0% On-demand bar without a blocking message.
+    return {
+      plan: parsed.plan,
+      quotas: parsed.quotas,
+    };
+  } catch (error) {
+    return { message: `Grok CLI usage error: ${error.message}` };
+  }
+}

package/app/open-sse/services/usage.js

@@ -11,6 +11,7 @@ export { consumeCodexRateLimitResetCredit, getCodexRateLimitResetCredits };
 import { getKiroUsage } from "./usage/kiro.js";
 import { getMiniMaxUsage } from "./usage/minimax.js";
 import { getCodeBuddyCnUsage } from "./usage/codebuddy-cn.js";
+import { getGrokCliUsage } from "./usage/grok-cli.js";
 import {
   getQwenUsage,
   getIflowUsage,
@@ -43,6 +44,7 @@ const USAGE_HANDLERS = {
   "minimax-cn": (c) => getMiniMaxUsage(c.apiKey, c.provider, c.proxyOptions),
   "vercel-ai-gateway": (c) => getVercelAiGatewayUsage(c.apiKey, c.proxyOptions),
   "codebuddy-cn": (c) => getCodeBuddyCnUsage(c.accessToken, c.apiKey, c.providerSpecificData, c.proxyOptions),
+  "grok-cli": (c) => getGrokCliUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
 };
 
 export async function getUsageForProvider(connection, proxyOptions = null) {

package/app/open-sse/translator/concerns/paramSupport.js

@@ -1,3 +1,5 @@
+import { getCapabilitiesForModel } from "../../providers/capabilities.js";
+
 // Strip request params a given provider/model rejects upstream (e.g. HTTP 400).
 // Config-driven: add a rule instead of scattering `delete body.x` across executors.
 
@@ -12,6 +14,13 @@ const STRIP_RULES = [
   { provider: "github", match: (m) => /claude/i.test(m) && !/claude.*(opus|sonnet).*4\.6/i.test(m), drop: ["thinking", "reasoning_effort"] },
   // Cloudflare Workers AI: content must be plain string, rejects OpenAI content-part array (#1926)
   { provider: "cloudflare-ai", flattenContent: true },
+  { provider: "volcengine-ark", match: /glm-5/i, clampToModelMaxOutput: true },
+  // VolcEngine Ark caps the Kimi family at max_tokens <= 32768, but the model's
+  // advertised ceiling is far higher (Kimi-K2.7-Code resolves to maxOutput 262144),
+  // so clampToModelMaxOutput alone leaves it uncapped and the request 400s with
+  // "integer above maximum value, expected <= 32768". Pin an explicit endpoint cap;
+  // min() with the model ceiling still applies if a variant's own limit is lower.
+  { provider: "volcengine-ark", match: /kimi/i, maxOutputCap: 32768, clampToModelMaxOutput: true },
 ];
 
 // Test a rule's match (regex or predicate) against the model id.
@@ -20,6 +29,12 @@ function matches(rule, model) {
   return typeof rule.match === "function" ? rule.match(model) : rule.match.test(model);
 }
 
+function clampNumber(body, key, ceiling) {
+  if (typeof body[key] === "number" && Number.isFinite(body[key]) && body[key] > ceiling) {
+    body[key] = ceiling;
+  }
+}
+
 // Remove unsupported params from body in place; returns body.
 export function stripUnsupportedParams(provider, model, body) {
   if (!model || !body || typeof body !== "object") return body;
@@ -39,6 +54,22 @@ export function stripUnsupportedParams(provider, model, body) {
         }
       }
     }
+    if (rule.clampToModelMaxOutput || Number.isFinite(rule.maxOutputCap)) {
+      const modelCeiling = getCapabilitiesForModel(provider, model).maxOutput;
+      const candidates = [];
+      if (rule.clampToModelMaxOutput && Number.isFinite(modelCeiling) && modelCeiling > 0) {
+        candidates.push(modelCeiling);
+      }
+      if (Number.isFinite(rule.maxOutputCap) && rule.maxOutputCap > 0) {
+        candidates.push(rule.maxOutputCap);
+      }
+      if (candidates.length > 0) {
+        const ceiling = Math.min(...candidates);
+        clampNumber(body, "max_tokens", ceiling);
+        clampNumber(body, "max_completion_tokens", ceiling);
+        clampNumber(body, "max_output_tokens", ceiling);
+      }
+    }
   }
   return body;
 }

package/app/open-sse/translator/concerns/thinkingUnified.js

@@ -20,6 +20,13 @@ const FORMAT_TO_NATIVE = {
   kiro: "kiro",
 };
 
+// Strip a trailing thinking suffix "model(value)" → "model" (no-op when absent).
+export function stripThinkingSuffix(model) {
+  if (typeof model !== "string") return model;
+  const m = model.match(/^(.*)\([^()]+\)\s*$/);
+  return m ? m[1].trim() : model;
+}
+
 // Parse model-name suffix "model(value)" → { cleanModel, override }.
 // value: level name (high) | number (8192) | auto | none. null override when absent.
 export function parseSuffix(model) {
@@ -132,18 +139,66 @@ function toGeminiThinkingLevel(cfg) {
   return effortToThinkingLevel(raw);
 }
 
+function toKimiReasoningEffort(cfg) {
+  const level = toLevel(cfg);
+  if (level === "auto") return "high";
+  if (level === "minimal") return "low";
+  if (level === "xhigh") return "max";
+  if (["low", "medium", "high", "max"].includes(level)) return level;
+  return null;
+}
+
+const GEMINI_LEVEL_OUTPUT_FLOOR = {
+  minimal: 4096,
+  low: 8192,
+  medium: 16384,
+  high: 65535,
+};
+
+function geminiBudgetOutputFloor(budget) {
+  if (budget === -1) return 32768;
+  if (!Number.isFinite(budget)) return 32768;
+  if (budget <= 1024) return 8192;
+  if (budget <= 8192) return 16384;
+  if (budget <= 24576) return 32768;
+  return 65535;
+}
+
+function geminiLevelOutputFloor(level) {
+  return GEMINI_LEVEL_OUTPUT_FLOOR[level] || GEMINI_LEVEL_OUTPUT_FLOOR.high;
+}
+
 // Gemini nests thinkingConfig under generationConfig. gemini-cli / antigravity wrap
 // the whole request in a { request: { generationConfig } } envelope — target the
 // envelope's generationConfig when present, else the top-level one.
+function getGeminiGenerationConfig(body) {
+  if (body.request && typeof body.request === "object") {
+    if (!body.request.generationConfig || typeof body.request.generationConfig !== "object") {
+      body.request.generationConfig = {};
+    }
+    return body.request.generationConfig;
+  }
+  if (!body.generationConfig || typeof body.generationConfig !== "object") {
+    body.generationConfig = {};
+  }
+  return body.generationConfig;
+}
+
 function setGeminiThinking(body, tc) {
-  const gc = body.request?.generationConfig
-    ? body.request.generationConfig
-    : (body.generationConfig && typeof body.generationConfig === "object"
-        ? body.generationConfig
-        : (body.generationConfig = {}));
+  const gc = getGeminiGenerationConfig(body);
   gc.thinkingConfig = tc;
 }
 
+function ensureGeminiOutputFloor(body, floor, caps) {
+  const cap = Number.isFinite(caps?.maxOutput) ? caps.maxOutput : floor;
+  const target = Math.min(floor, cap);
+  const gc = getGeminiGenerationConfig(body);
+  const current = Number(gc.maxOutputTokens);
+  if (!Number.isFinite(current) || current < target) {
+    gc.maxOutputTokens = target;
+  }
+}
+
 // Strip every known thinking field from a body (used before re-applying / when unsupported).
 function stripAll(body) {
   delete body.thinking;
@@ -168,7 +223,8 @@ function applyFormat(fmt, body, cfg, caps) {
     case "openai": {
       if (none && canDisable) { body.reasoning_effort = "none"; break; }
       const level = toLevel(eff);
-      if (level) body.reasoning_effort = level;
+      // OpenAI reasoning_effort enum caps at "xhigh" (no "max"); clamp Claude Code's "max".
+      if (level) body.reasoning_effort = level === "max" ? "xhigh" : level;
       break;
     }
     case "claude-adaptive": {
@@ -186,12 +242,14 @@ function applyFormat(fmt, body, cfg, caps) {
     case "gemini-level": {
       const level = none ? "minimal" : toGeminiThinkingLevel(eff);
       setGeminiThinking(body, { thinkingLevel: level, includeThoughts: level !== "minimal" });
+      ensureGeminiOutputFloor(body, geminiLevelOutputFloor(level), caps);
       break;
     }
     case "gemini-budget": {
       if (none && canDisable) { setGeminiThinking(body, { thinkingBudget: 0, includeThoughts: false }); break; }
       const budget = toBudget(eff, caps.thinkingRange);
       setGeminiThinking(body, { thinkingBudget: budget ?? -1, includeThoughts: true });
+      ensureGeminiOutputFloor(body, geminiBudgetOutputFloor(budget ?? -1), caps);
       break;
     }
     case "zai": {
@@ -217,8 +275,8 @@ function applyFormat(fmt, body, cfg, caps) {
     }
     case "kimi": {
       if (none && canDisable) { body.thinking = { type: "disabled" }; break; }
-      const level = toLevel(eff);
-      if (level) body.reasoning_effort = level === "max" ? "high" : level;
+      const effort = toKimiReasoningEffort(eff);
+      if (effort) body.reasoning_effort = effort;
       break;
     }
     case "minimax": {

package/app/open-sse/translator/formats/claude.js

@@ -192,10 +192,27 @@ export function prepareClaudeRequest(body, provider = null, apiKey = null, conne
     delete body.output_config;
   }
 
-  // Clamp max_tokens to the model output ceiling (never above DEFAULT_MAX_TOKENS)
+  // Clamp max_tokens to the model's real output ceiling. Models whose caps
+  // declare a higher maxOutput (e.g. Opus 4.8 / Sonnet 4.6 = 128000) are allowed
+  // up to it, so max-effort thinking gets full budget; others fall back to the
+  // conservative 64000 default.
   if (body.max_tokens) {
-    const ceiling = Math.min(getCapabilitiesForModel(provider, body.model).maxOutput, DEFAULT_MAX_TOKENS);
+    const ceiling = getCapabilitiesForModel(provider, body.model).maxOutput || DEFAULT_MAX_TOKENS;
     if (body.max_tokens > ceiling) body.max_tokens = ceiling;
+
+    // Reconcile against thinking budget. applyThinking (thinkingUnified.js) runs
+    // AFTER adjustMaxTokens capped max_tokens, and the claude-budget format maps
+    // max effort → budget_tokens 128000 — larger than the clamped max_tokens.
+    // Anthropic requires max_tokens strictly greater than budget_tokens (else 400).
+    // Prefer raising max_tokens to preserve the requested thinking depth; if the
+    // budget alone meets/exceeds the ceiling, cap output and shrink the budget so
+    // some tokens remain for the answer.
+    if (body.thinking?.type === "enabled" && body.thinking.budget_tokens && body.thinking.budget_tokens >= body.max_tokens) {
+      body.max_tokens = Math.min(body.thinking.budget_tokens + 1024, ceiling);
+      if (body.thinking.budget_tokens >= body.max_tokens) {
+        body.thinking.budget_tokens = Math.max(1024, body.max_tokens - 1024);
+      }
+    }
   }
 
   // 1. System: remove all cache_control, add only to last block with ttl 1h

package/app/open-sse/translator/formats/maxTokens.js

@@ -3,9 +3,13 @@ import { DEFAULT_MAX_TOKENS, DEFAULT_MIN_TOKENS } from "../../config/runtimeConf
 /**
  * Adjust max_tokens based on request context
  * @param {object} body - Request body
+ * @param {number} [ceiling=DEFAULT_MAX_TOKENS] - Upper bound for max_tokens.
+ *   Callers with model context (e.g. openai-to-claude) pass the model's real
+ *   maxOutput so high-output models (Opus 4.8 = 128000) aren't pre-clamped to
+ *   the conservative 64000 default before the model-aware step sees them.
  * @returns {number} Adjusted max_tokens
  */
-export function adjustMaxTokens(body) {
+export function adjustMaxTokens(body, ceiling = DEFAULT_MAX_TOKENS) {
   let maxTokens = body.max_tokens || DEFAULT_MAX_TOKENS;
 
   // Auto-increase for tool calling to prevent truncated arguments (min never above max)
@@ -16,14 +20,14 @@ export function adjustMaxTokens(body) {
   }
 
   // Ensure max_tokens > thinking.budget_tokens (Claude API requirement)
-  // Claude API requires strictly greater, so add buffer instead of using DEFAULT_MAX_TOKENS
-  // which could equal budget_tokens when budget_tokens >= 64000
+  // Claude API requires strictly greater, so add buffer instead of using the
+  // ceiling which could equal budget_tokens when budget_tokens >= ceiling
   if (body.thinking?.budget_tokens && maxTokens <= body.thinking.budget_tokens) {
     maxTokens = body.thinking.budget_tokens + 1024;
   }
 
-  // Never exceed the global ceiling
-  if (maxTokens > DEFAULT_MAX_TOKENS) maxTokens = DEFAULT_MAX_TOKENS;
+  // Never exceed the ceiling
+  if (maxTokens > ceiling) maxTokens = ceiling;
 
   return maxTokens;
 }

package/app/open-sse/translator/request/claude-to-kiro.js

@@ -404,7 +404,10 @@ export function claudeToKiroRequest(model, body, stream, credentials) {
 
   let finalContent = currentMessage?.userInputMessage?.content || "";
 
-  // System prompt → prepend to the user content.
+  // System prompt: pass via native systemInstruction field (Kiro/Q API supports it)
+  // and also prepend as <instructions> in user content as fallback for upstreams
+  // that don't support the native field.
+  let systemInstruction = undefined;
   if (body.system) {
     let systemText = "";
     if (typeof body.system === "string") {
@@ -412,7 +415,10 @@ export function claudeToKiroRequest(model, body, stream, credentials) {
     } else if (Array.isArray(body.system)) {
       systemText = body.system.map((s) => s.text || "").join("\n");
     }
-    if (systemText) finalContent = `${systemText}\n\n${finalContent}`;
+    if (systemText) {
+      systemInstruction = systemText;
+      finalContent = `<instructions>\n${systemText}\n</instructions>\n\n${finalContent}`;
+    }
   }
 
   // Prefix order: thinking_mode tag, timestamp marker, then agentic prompt.
@@ -423,23 +429,29 @@ export function claudeToKiroRequest(model, body, stream, credentials) {
   if (agentic) prefixParts.push(KIRO_AGENTIC_SYSTEM_PROMPT);
   finalContent = `${prefixParts.join("\n\n")}\n\n${finalContent}`;
 
+  const userInputMessage = {
+    content: finalContent,
+    modelId: upstreamModel,
+    origin: "AI_EDITOR",
+    ...(currentMessage?.userInputMessage?.userInputMessageContext && {
+      userInputMessageContext:
+        currentMessage.userInputMessage.userInputMessageContext,
+    }),
+    ...(currentMessage?.userInputMessage?.images && {
+      images: currentMessage.userInputMessage.images,
+    }),
+  };
+
+  if (systemInstruction) {
+    userInputMessage.systemInstruction = systemInstruction;
+  }
+
   const payload = {
     conversationState: {
       chatTriggerType: "MANUAL",
       conversationId: uuidv4(),
       currentMessage: {
-        userInputMessage: {
-          content: finalContent,
-          modelId: upstreamModel,
-          origin: "AI_EDITOR",
-          ...(currentMessage?.userInputMessage?.userInputMessageContext && {
-            userInputMessageContext:
-              currentMessage.userInputMessage.userInputMessageContext,
-          }),
-          ...(currentMessage?.userInputMessage?.images && {
-            images: currentMessage.userInputMessage.images,
-          }),
-        },
+        userInputMessage,
       },
       history,
     },

package/app/open-sse/translator/request/claude-to-openai.js

@@ -129,14 +129,15 @@ function fixMissingToolResponsesOpenAI(messages) {
   }
 }
 
-// Wrap mid-conversation system text so it ends as a user turn (avoids Anthropic prefill 400)
+// Wrap mid-conversation system text so it ends as a user turn (avoids Anthropic prefill 400).
+// Uses <instructions> tags that Claude models treat as authoritative directives.
 function systemReminderText(content) {
   const parts = Array.isArray(content)
     ? content.filter(c => c?.type === CLAUDE_BLOCK.TEXT).map(c => c.text || "")
     : [typeof content === "string" ? content : ""];
   const text = parts.filter(Boolean).join("\n");
   if (!text.trim()) return "";
-  return `<system-reminder>\n${text}\n</system-reminder>`;
+  return `<instructions>\n${text}\n</instructions>`;
 }
 
 // Convert single Claude message - returns single message or array of messages