@amir83nasr/10router 0.1.0

package/open-sse/providers/shared.js

@@ -0,0 +1,114 @@
+import { platform, arch } from "os";
+
+// === OS/Arch helpers (Stainless fingerprint) ===
+export function mapStainlessOs() {
+  switch (platform()) {
+    case "darwin":
+      return "MacOS";
+    case "win32":
+      return "Windows";
+    case "linux":
+      return "Linux";
+    case "freebsd":
+      return "FreeBSD";
+    default:
+      return `Other::${platform()}`;
+  }
+}
+
+export function mapStainlessArch() {
+  switch (arch()) {
+    case "x64":
+      return "x64";
+    case "arm64":
+      return "arm64";
+    case "ia32":
+      return "x86";
+    default:
+      return `other::${arch()}`;
+  }
+}
+
+// Anthropic API version (single source — reused across claude-format providers/executors)
+export const ANTHROPIC_API_VERSION = "2023-06-01";
+export const CLAUDE_CLI_VERSION = "2.1.258";
+
+// Shared Claude-compatible API headers (reused across claude-format providers)
+export const CLAUDE_API_HEADERS = {
+  "Anthropic-Version": ANTHROPIC_API_VERSION,
+  "Anthropic-Beta": "claude-code-20250219,interleaved-thinking-2025-05-14",
+};
+
+// Full Claude CLI fingerprint — required by providers that gate on client identity (e.g. agentrouter)
+export const CLAUDE_CLI_SPOOF_HEADERS = {
+  "Anthropic-Version": ANTHROPIC_API_VERSION,
+  "Anthropic-Beta":
+    "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,advanced-tool-use-2025-11-20,effort-2025-11-24,structured-outputs-2025-12-15,fast-mode-2026-02-01,redact-thinking-2026-02-12,token-efficient-tools-2026-03-28",
+  "Anthropic-Dangerous-Direct-Browser-Access": "true",
+  "User-Agent": `claude-cli/${CLAUDE_CLI_VERSION} (external, sdk-cli)`,
+  "X-App": "cli",
+  "X-Stainless-Helper-Method": "stream",
+  "X-Stainless-Retry-Count": "0",
+  "X-Stainless-Runtime-Version": "v24.14.0",
+  "X-Stainless-Package-Version": "0.80.0",
+  "X-Stainless-Runtime": "node",
+  "X-Stainless-Lang": "js",
+  "X-Stainless-Arch": mapStainlessArch(),
+  "X-Stainless-Os": mapStainlessOs(),
+  "X-Stainless-Timeout": "600",
+};
+
+const ANTHROPIC_BETA_BASE = [
+  "claude-code-20250219",
+  "oauth-2025-04-20",
+  "interleaved-thinking-2025-05-14",
+  "context-management-2025-06-27",
+  "prompt-caching-scope-2026-01-05",
+  "structured-outputs-2025-12-15",
+  "fast-mode-2026-02-01",
+  "redact-thinking-2026-02-12",
+  "token-efficient-tools-2026-03-28",
+];
+const ANTHROPIC_BETA_HEAVY_AGENT = ["advanced-tool-use-2025-11-20", "effort-2025-11-24"];
+
+// Heavy-agent beta flags are gated to opus/sonnet — cheaper models don't need them.
+// `redact-thinking` asks Anthropic to return signature-only thinking blocks, which
+// is right for clients that never render thinking but blanks the summaries a
+// client explicitly requested with `thinking.display: "summarized"`.
+const ANTHROPIC_BETA_REDACT_THINKING = "redact-thinking-2026-02-12";
+
+export function wantsThinkingSummaries(body) {
+  return body?.thinking?.display === "summarized";
+}
+
+export function selectAnthropicBeta(model = "", body = null) {
+  const flags = ANTHROPIC_BETA_BASE.filter(
+    (flag) => flag !== ANTHROPIC_BETA_REDACT_THINKING || !wantsThinkingSummaries(body),
+  );
+  if (/^claude-(opus|sonnet)/.test(model)) flags.push(...ANTHROPIC_BETA_HEAVY_AGENT);
+  return flags.join(",");
+}
+
+// Shared baseUrls
+// Default base for dynamic compat providers (openai-compatible-* / anthropic-compatible-*) when user gives no baseUrl
+export const OPENAI_COMPAT_BASE = "https://api.openai.com/v1";
+export const ANTHROPIC_COMPAT_BASE = "https://api.anthropic.com/v1";
+
+// Official Antigravity IDE Desktop 2.11.0 fingerprint captured from macOS arm64.
+// Keep this static even when 10router runs on Linux: the provider profile is
+// intentionally matching the IDE client, not the server host.
+export const ANTIGRAVITY_IDE_VERSION = "2.11.0";
+export const ANTIGRAVITY_IDE_BASE_URL = "https://daily-cloudcode-pa.googleapis.com";
+export const ANTIGRAVITY_IDE_USER_AGENT = `antigravity/ide/${ANTIGRAVITY_IDE_VERSION} darwin/arm64`;
+
+// Antigravity OAuth client credentials (public CLI client — duplicated in usage.js + src/lib/oauth)
+export const ANTIGRAVITY_OAUTH_CLIENT = {
+  clientId: "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com",
+  clientSecret: "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",
+};
+
+// Gemini (Google) OAuth client credentials (public CLI client — shared by gemini, src/lib/oauth)
+export const GOOGLE_OAUTH_CLIENT = {
+  clientId: "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com",
+  clientSecret: "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",
+};

package/open-sse/providers/thinkingLevels.js

@@ -0,0 +1,74 @@
+// Resolve valid thinking levels per model — drives UI level picker (suffix "model(level)").
+// Reuses capabilities.js (thinkingFormat/canDisable) so this file only maps format→levels (DRY).
+import { getCapabilitiesForModel } from "./capabilities.js";
+import { matchPattern } from "./pricing.js";
+
+// Shared level sets (deduped) — verified against provider docs + wire in thinkingUnified.applyFormat.
+const L = {
+  base: ["none", "low", "medium", "high"], // qwen, step, hunyuan, gemini-budget
+  onOff: ["none", "thinking"], // zai (binary), minimax (adaptive)
+  openai: ["none", "minimal", "low", "medium", "high", "xhigh"], // GPT-5.x / o-series (no "max")
+  levelMax: ["none", "low", "medium", "high", "max"], // claude-adaptive, kimi
+  budgetX: ["none", "low", "medium", "high", "xhigh", "max"], // claude-budget
+  gemini: ["minimal", "low", "medium", "high"], // gemini-3 thinkingLevel (no disable)
+  hiMax: ["none", "high", "max"], // deepseek (low/med→high, xhigh→max)
+};
+
+// thinkingFormat → valid selectable levels (source of truth for UI options).
+const FORMAT_LEVELS = {
+  openai: L.openai,
+  "claude-adaptive": L.levelMax,
+  "claude-budget": L.budgetX,
+  "gemini-level": L.gemini,
+  "gemini-budget": L.base,
+  zai: L.onOff,
+  qwen: L.base,
+  kimi: L.levelMax, // legacy format key (provider removed) — kept for model-name compat
+  deepseek: L.hiMax,
+  commandcode: ["none", "low", "medium", "high", "xhigh", "max"],
+  minimax: L.onOff,
+  hunyuan: L.base,
+  step: L.base,
+};
+
+const CODEX_GPT_5_6_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+
+// Model-name pattern overrides (glob, first match wins) — more precise than format default.
+const PATTERN_THINKING = [
+  { provider: "codex", pattern: "*gpt-6*", levels: CODEX_GPT_5_6_LEVELS },
+  { provider: "codex", pattern: "*gpt-5.6-sol*", levels: [...CODEX_GPT_5_6_LEVELS, "ultra"] },
+  { provider: "codex", pattern: "*gpt-5.6-terra*", levels: [...CODEX_GPT_5_6_LEVELS, "ultra"] },
+  { provider: "codex", pattern: "*gpt-5.6-luna*", levels: CODEX_GPT_5_6_LEVELS },
+  { pattern: "*codex*", levels: ["low", "medium", "high", "xhigh"] }, // codex cannot disable thinking
+  // DeepSeek v4.* (Alibaba MaaS, probed live): effort low|medium|high|xhigh|max
+  // all 200 via output_config.effort; "none" is a 400 on the anthropic route
+  // (disable thinking instead). none kept for the picker = disable.
+  { pattern: "*deepseek-v4.*", levels: ["none", "low", "medium", "high", "xhigh", "max"] },
+  // codebuddy-cn per-model effort sets — the server's product-config payload
+  // publishes `reasoning.supportedEfforts` per model. NOTE: the chat endpoint
+  // accepts any level you send (probed none/minimal/low/medium/high/xhigh/max
+  // → all 200), but values outside a model's supportedEfforts are silently
+  // clamped, so the declared set stays authoritative for the picker. Models
+  // that publish no supportedEfforts (glm-5.1 / glm-5v-turbo / kimi-k2.x /
+  // kimi-k3-1 / minimax-m3) fall through to the openai format default.
+  { provider: "codebuddy-cn", pattern: "glm-5.3*", levels: ["low", "high", "max"] },
+  { provider: "codebuddy-cn", pattern: "glm-5.2", levels: ["high", "xhigh"] },
+  { provider: "codebuddy-cn", pattern: "deepseek-v4*", levels: ["low", "high", "xhigh"] },
+  { provider: "codebuddy-cn", pattern: "hy3*", levels: ["low", "high"] },
+  { provider: "codebuddy-cn", pattern: "hy4*", levels: ["high"] },
+  // codebuddy-intl rides the same gateway catalog, so its deepseek levels match.
+  { provider: "codebuddy-intl", pattern: "deepseek-v4*", levels: ["low", "high", "xhigh"] },
+];
+
+// Returns valid thinking levels for a model, or null when the model has no reasoning.
+export function getThinkingLevels(provider, model) {
+  const caps = getCapabilitiesForModel(provider, model);
+  if (!caps.reasoning) return null;
+  const hit = PATTERN_THINKING.find(
+    (entry) =>
+      (!entry.provider || entry.provider === provider) && matchPattern(entry.pattern, model),
+  );
+  let levels = hit?.levels || FORMAT_LEVELS[caps.thinkingFormat] || L.base;
+  if (caps.thinkingCanDisable === false) levels = levels.filter((l) => l !== "none");
+  return levels;
+}

package/open-sse/providers/visionPatterns.js

@@ -0,0 +1,58 @@
+// Name-based vision detection — last resort when neither the catalog file nor
+// the capability tables know a model. Vendors put the modality in the id
+// ("qwen3-vl-plus", "glm-4.6v", "deepseek-v4-flash-vision-exp"), so a custom or
+// freshly released model still gets image input instead of silently dropping it.
+//
+// Only ever turns vision ON. Never used to turn a declared capability off.
+
+const SEP = "[-_/:.]";
+
+// Image GENERATION, video generation, and non-chat models also carry these
+// words but take no image input — checked first so they can never match.
+const NOT_VISION = new RegExp(
+  [
+    `(^|${SEP})(image|img)(${SEP}|$)`,
+    "stable-image",
+    "gen[0-9]_image",
+    "nanobanana",
+    "imagine",
+    "t2v",
+    "i2v",
+    "flux",
+    "dall",
+    "sdxl",
+    "diffusion",
+    "embed",
+    "rerank",
+    "guard",
+    "moderation",
+    "tts",
+    "stt",
+    "whisper",
+    "voice",
+    "speech",
+    "audio",
+  ].join("|"),
+  "i",
+);
+
+// Explicit modality words, plus the "<digit>v" suffix vendors use for vision
+// variants (glm-4.6v, glm-5v-turbo). The digit-v branch requires a dotted
+// version so the never-shipped `gpt-4v` cannot match.
+const VISION_NAME = new RegExp(
+  [
+    `(^|${SEP})(vision|vl|vlm|multimodal|omni|visual)(${SEP}|$)`,
+    `[0-9]\\.[0-9]+v(${SEP}|$)`,
+    `(^|${SEP})glm-[0-9]+v(${SEP}|$)`,
+    "(^|[-_/:.])(llava|pixtral|internvl|cogvlm|minicpm-v|moondream|idefics|fuyu)",
+  ].join("|"),
+  "i",
+);
+
+// Does this model id look like a vision model? Name signal only.
+export function looksLikeVisionModel(modelId) {
+  if (!modelId) return false;
+  const id = String(modelId).toLowerCase();
+  if (NOT_VISION.test(id)) return false;
+  return VISION_NAME.test(id);
+}

package/open-sse/rtk/applyFilter.js

@@ -0,0 +1,17 @@
+// Port of apply_filter (rtk/src/cmds/system/pipe_cmd.rs) — catch_unwind equivalent
+// On panic/error: passthrough raw output + warn to stderr
+export function safeApply(fn, text) {
+  if (typeof fn !== "function") return text;
+  try {
+    const out = fn(text);
+    if (typeof out !== "string") return text;
+    return out;
+  } catch (err) {
+    // Rust: eprintln!("[rtk] warning: filter panicked — passing through raw output")
+    const name = fn.filterName || fn.name || "anonymous";
+    console.warn(
+      `[rtk] warning: filter '${name}' panicked — passing through raw output: ${err?.message || err}`,
+    );
+    return text;
+  }
+}

package/open-sse/rtk/autodetect.js

@@ -0,0 +1,124 @@
+// Port of auto_detect_filter (rtk/src/cmds/system/pipe_cmd.rs:132-188) + JS extras
+// Detection order: git-log → git-diff → git-status → build-output → grep → find → tree → ls → search-list
+//                  → read-numbered → dedup-log → smart-truncate → null
+import {
+  DETECT_WINDOW,
+  READ_NUMBERED_MIN_HIT_RATIO,
+  SMART_TRUNCATE_MIN_LINES,
+} from "./constants.js";
+import { gitDiff } from "./filters/gitDiff.js";
+import { gitStatus } from "./filters/gitStatus.js";
+import { gitLog } from "./filters/gitLog.js";
+import { buildOutput } from "./filters/buildOutput.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, READ_NUMBERED_LINE_RE } from "./filters/readNumbered.js";
+import { searchList, SEARCH_LIST_HEADER_RE } from "./filters/searchList.js";
+
+const RE_GIT_DIFF = /^diff --git /m;
+const RE_GIT_DIFF_HUNK = /^@@ /m;
+const RE_GIT_STATUS = /^On branch |^nothing to commit|^Changes (not |to be )|^Untracked files:/m;
+const RE_GIT_LOG = /^[*|/\\ ]*commit [0-9a-f]{7,40}$/m;
+const RE_PORCELAIN = /^[ MADRCU?!][ MADRCU?!] \S/m;
+const RE_BUILD_OUTPUT =
+  /^(npm (warn|error|ERR!)|yarn (warn|error)|\s*Compiling\s+\S+|\s*Downloading\s+\S+|added \d+ package|\[ERROR\]|BUILD (SUCCESS|FAILED)|\s*Finished\s+|Successfully (installed|built)|ERROR:)/im;
+const RE_TREE_GLYPH = /[├└]──|│  /;
+const RE_LS_ROW = /^[-dlbcps][rwx-]{9}/m;
+const RE_LS_TOTAL = /^total \d+$/m;
+
+export function autoDetectFilter(text) {
+  // Rust: floor_char_boundary to avoid UTF-8 split — JS .slice() by char is safe
+  const head = text.length > DETECT_WINDOW ? text.slice(0, DETECT_WINDOW) : text;
+
+  if (RE_GIT_LOG.test(head)) return gitLog;
+  if (RE_GIT_DIFF.test(head) || RE_GIT_DIFF_HUNK.test(head)) return gitDiff;
+  if (RE_GIT_STATUS.test(head)) return gitStatus;
+
+  // Build output BEFORE porcelain check: prevents cargo "Compiling" misdetection as git-status
+  if (RE_BUILD_OUTPUT.test(head)) return buildOutput;
+
+  if (isMostlyPorcelain(head)) return gitStatus;
+
+  const lines = head.split("\n");
+  const nonEmpty = lines.filter((l) => l.trim().length > 0);
+
+  // Rust grep rule: first 5 non-empty lines, ANY matches "file:number:content"
+  const first5 = nonEmpty.slice(0, 5);
+  if (first5.some(isGrepLine)) return grep;
+
+  // Rust find rule: ALL non-empty lines path-like (no ':'), >=3 lines
+  if (nonEmpty.length >= 3 && nonEmpty.every(isPathLike)) return find;
+
+  // Tree: contains box-drawing glyphs typical of `tree` command
+  if (RE_TREE_GLYPH.test(head)) return tree;
+
+  // ls -la: has "total N" header or >=3 rows starting with perms string
+  if (RE_LS_TOTAL.test(head) || countMatches(head, RE_LS_ROW) >= 3) return ls;
+
+  // Cursor Glob search list header
+  if (SEARCH_LIST_HEADER_RE.test(head)) return searchList;
+
+  // Line-numbered file dump ("  N|content") — fire only if many lines match
+  if (lines.length >= SMART_TRUNCATE_MIN_LINES && isLineNumbered(lines)) {
+    return readNumbered;
+  }
+
+  // Fallback: dedupLog for generic multi-line noise with duplicates
+  if (nonEmpty.length >= 5) return dedupLog;
+
+  // Last resort: big blob with no structure — smart truncate
+  if (text.split("\n").length >= SMART_TRUNCATE_MIN_LINES) return smartTruncate;
+
+  return null;
+}
+
+function isGrepLine(line) {
+  // Rust: splitn(3, ':') → parts.len()==3 && parts[1].parse::<usize>().is_ok()
+  const first = line.indexOf(":");
+  if (first === -1) return false;
+  const second = line.indexOf(":", first + 1);
+  if (second === -1) return false;
+  const lineno = line.slice(first + 1, second);
+  return /^\d+$/.test(lineno);
+}
+
+function isPathLike(line) {
+  const t = line.trim();
+  if (t.length === 0) return false;
+  // A drive-letter prefix (e.g. "C:\Users\me" or "C:/Users/me") marks a
+  // Windows absolute path, so treat the whole line as path-like. Trailing
+  // colons (e.g. "C:\path\file.js:10") are tolerated, matching grep-style
+  // suffixes on Windows dumps.
+  if (/^[A-Za-z]:[\\/]/.test(t)) return true;
+  if (t.includes(":")) return false;
+  return t.startsWith(".") || t.startsWith("/") || t.includes("/");
+}
+
+function isMostlyPorcelain(head) {
+  const lines = head.split("\n").filter((l) => l.trim());
+  if (lines.length < 3) return false;
+  const hits = lines.filter((l) => RE_PORCELAIN.test(l)).length;
+  return hits / lines.length >= 0.6;
+}
+
+function isLineNumbered(lines) {
+  let hits = 0;
+  let nonEmpty = 0;
+  const sample = lines.slice(0, 100);
+  for (const l of sample) {
+    if (l.length === 0) continue;
+    nonEmpty++;
+    if (READ_NUMBERED_LINE_RE.test(l)) hits++;
+  }
+  if (nonEmpty < 5) return false;
+  return hits / nonEmpty >= READ_NUMBERED_MIN_HIT_RATIO;
+}
+
+function countMatches(text, re) {
+  const g = new RegExp(re.source, re.flags.includes("g") ? re.flags : re.flags + "g");
+  return (text.match(g) || []).length;
+}

package/open-sse/rtk/caveman.js

@@ -0,0 +1,9 @@
+// Caveman injector: appends a caveman-style instruction into the system message
+// of the final request body, just before it is dispatched to the provider executor.
+
+import { injectSystemPrompt } from "./systemInject.js";
+import { CAVEMAN_PROMPTS } from "./cavemanPrompts.js";
+
+export function injectCaveman(body, format, level) {
+  injectSystemPrompt(body, format, CAVEMAN_PROMPTS[level]);
+}

package/open-sse/rtk/cavemanPrompts.js

@@ -0,0 +1,118 @@
+// Caveman intensity-level prompts injected into system message to reduce output tokens.
+// Adapted from caveman skill (https://github.com/JuliusBrussee/caveman).
+
+export const CAVEMAN_LEVELS = {
+  LITE: "lite",
+  FULL: "full",
+  ULTRA: "ultra",
+  WENYAN_LITE: "wenyan-lite",
+  WENYAN: "wenyan",
+  WENYAN_ULTRA: "wenyan-ultra",
+};
+
+const SHARED_BOUNDARIES =
+  "Code blocks, file paths, commands, errors, URLs: keep exact. Security warnings, irreversible action confirmations, multi-step ordered sequences: write normal. Resume terse style after.";
+
+const SHARED_EXAMPLES =
+  'Not: "Sure! I\'d be happy to help you with that. The issue you\'re experiencing is likely caused by..." Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"';
+
+const SHARED_AUTO_CLARITY =
+  "Auto-Clarity: drop caveman for security warnings, irreversible actions, multi-step sequences where fragment ambiguity risks misread, or when user repeats a question. Resume after the clear part.";
+
+const SHARED_PERSISTENCE =
+  "ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active if unsure.";
+
+const SHARED_NO_INVENTED_ABBREV =
+  "No invented abbreviations. Standard well-known tech acronyms (DB, API, HTTP, URL, JSON, ID, OS, CPU) OK. Names of code symbols, function names, API names, error strings: keep verbatim.";
+
+const SHARED_PRESERVE_LANGUAGE =
+  "Preserve the user's dominant language. User wrote Vietnamese, reply Vietnamese. User wrote English, reply English. Wenyan/classical-Chinese levels override this language-preservation rule. Code identifiers, error strings, file paths, commands: keep in their original form regardless of language.";
+
+const SHARED_NO_SELF_REFERENCE =
+  'No self-reference. Do not name or announce the style (no "caveman mode", no "me caveman think", no "compressed mode active"). Just respond.';
+
+const SHARED_NO_DECORATION =
+  'No decorative emoji. No narrating tool calls ("I will now search", "I used X to find Y"). No status phrases ("Sure!", "Of course!", "I\'d be happy to"). No causal arrow shorthand ("A -> B -> fails"). State the thing, the action, the reason. Then next step.';
+
+export const CAVEMAN_PROMPTS = {
+  [CAVEMAN_LEVELS.LITE]: [
+    "Respond tersely. Keep grammar and full sentences but drop filler, hedging and pleasantries (just/really/basically/sure/of course/I'd be happy to).",
+    "Pattern: state the thing, the action, the reason. Then next step.",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+    SHARED_NO_INVENTED_ABBREV,
+    SHARED_PRESERVE_LANGUAGE,
+    SHARED_NO_SELF_REFERENCE,
+    SHARED_NO_DECORATION,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.FULL]: [
+    "Respond like terse caveman. All technical substance stay exact, only fluff die.",
+    "Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries, hedging. Fragments OK. Short synonyms (big not extensive, fix not implement a solution for).",
+    "Pattern: [thing] [action] [reason]. [next step].",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+    SHARED_NO_INVENTED_ABBREV,
+    SHARED_PRESERVE_LANGUAGE,
+    SHARED_NO_SELF_REFERENCE,
+    SHARED_NO_DECORATION,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.ULTRA]: [
+    "Respond ultra-terse. Maximum compression. Telegraphic.",
+    "Strip conjunctions. One word when one word enough.",
+    "Pattern: [thing] [action] [reason]. [next step].",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+    SHARED_NO_INVENTED_ABBREV,
+    SHARED_PRESERVE_LANGUAGE,
+    SHARED_NO_SELF_REFERENCE,
+    SHARED_NO_DECORATION,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.WENYAN_LITE]: [
+    "Respond semi-classical. Drop filler/hedging but keep grammar structure, classical register.",
+    "Use classical Chinese sentence patterns where natural. Keep English for technical terms.",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+    SHARED_NO_INVENTED_ABBREV,
+    SHARED_PRESERVE_LANGUAGE,
+    SHARED_NO_SELF_REFERENCE,
+    SHARED_NO_DECORATION,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.WENYAN]: [
+    "Respond classical Chinese (文言文). Maximum classical terseness. 80-90% character reduction.",
+    "Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其).",
+    "Keep English for code, commands, function names, API names, error strings.",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+    SHARED_NO_INVENTED_ABBREV,
+    SHARED_PRESERVE_LANGUAGE,
+    SHARED_NO_SELF_REFERENCE,
+    SHARED_NO_DECORATION,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.WENYAN_ULTRA]: [
+    "Respond extreme classical compression (文言文 ultra). Maximum compression, ultra terse.",
+    "Same classical rules as wenyan-full but even more compressed. One classical particle per clause.",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+    SHARED_NO_INVENTED_ABBREV,
+    SHARED_PRESERVE_LANGUAGE,
+    SHARED_NO_SELF_REFERENCE,
+    SHARED_NO_DECORATION,
+  ].join(" "),
+};

package/open-sse/rtk/constants.js

@@ -0,0 +1,78 @@
+// RTK port constants (mirror Rust defaults)
+export const RAW_CAP = 10 * 1024 * 1024; // 10 MiB
+export const MIN_COMPRESS_SIZE = 500; // bytes; skip tiny blobs
+export const DETECT_WINDOW = 1024; // autodetect peeks first N chars
+export const GIT_DIFF_HUNK_MAX_LINES = 100; // per-hunk line cap
+export const GIT_DIFF_CONTEXT_KEEP = 3; // context lines around changes
+export const GIT_LOG_MAX_LINES = 200; // gitLog line cap
+export const DEDUP_LINE_MAX = 2000; // dedupLog truncation cap
+
+// Rust pipe_cmd.rs parity caps
+export const GREP_PER_FILE_MAX = 10; // match rust: matches.iter().take(10)
+export const FIND_PER_DIR_MAX = 10; // match rust: files.iter().take(10)
+export const FIND_TOTAL_DIR_MAX = 20; // match rust: dirs.iter().take(20)
+
+// git status caps (rust config::limits())
+export const STATUS_MAX_FILES = 10; // config::limits().status_max_files
+export const STATUS_MAX_UNTRACKED = 10; // config::limits().status_max_untracked
+
+// ls compact_ls (rtk/src/cmds/system/ls.rs)
+export const LS_EXT_SUMMARY_TOP = 5; // top-N extensions in summary
+export const LS_NOISE_DIRS = [
+  "node_modules",
+  ".git",
+  "target",
+  "__pycache__",
+  ".next",
+  "dist",
+  "build",
+  ".cache",
+  ".turbo",
+  ".vercel",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".tox",
+  ".venv",
+  "venv",
+  "env", // Python legacy virtualenv; .env (dotenv) intentionally excluded
+  "coverage",
+  ".nyc_output",
+  ".DS_Store",
+  "Thumbs.db",
+  ".idea",
+  ".vscode",
+  ".vs",
+  "*.egg-info",
+  ".eggs",
+];
+
+// tree filter_tree_output cap (no rust cap, we add one to be safe)
+export const TREE_MAX_LINES = 200;
+
+// Cursor Glob "Result of search in '...' (total N files):" list
+export const SEARCH_LIST_PER_DIR_MAX = 10;
+export const SEARCH_LIST_TOTAL_DIR_MAX = 20;
+
+// Smart truncate (port of filter.rs smart_truncate fallback)
+export const SMART_TRUNCATE_HEAD = 120; // lines kept from top
+export const SMART_TRUNCATE_TAIL = 60; // lines kept from bottom
+export const SMART_TRUNCATE_MIN_LINES = 250; // only kick in above this
+
+// readNumbered (files with "  N|content" lines, e.g. Cursor read_file)
+export const READ_NUMBERED_MIN_HIT_RATIO = 0.7;
+
+// Filter name strings (Rust parity + JS extras)
+export const FILTERS = {
+  GIT_DIFF: "git-diff",
+  GIT_STATUS: "git-status",
+  GIT_LOG: "git-log",
+  GREP: "grep",
+  FIND: "find",
+  LS: "ls",
+  TREE: "tree",
+  DEDUP_LOG: "dedup-log",
+  SMART_TRUNCATE: "smart-truncate",
+  READ_NUMBERED: "read-numbered",
+  SEARCH_LIST: "search-list",
+  BUILD_OUTPUT: "build-output",
+};