@fudrouter/fsrouter 0.6.61 → 0.6.63

package/open-sse/utils/bypassHandler.js

@@ -0,0 +1,298 @@
+import { detectFormat } from "../services/provider.js";
+import { translateResponse, initState } from "../translator/index.js";
+import { FORMATS } from "../translator/formats.js";
+import { SKIP_PATTERNS } from "../config/runtimeConfig.js";
+import { formatSSE } from "./stream.js";
+
+/**
+ * Check for bypass patterns - return fake response without calling provider
+ * Only works for Claude CLI requests
+ */
+export function handleBypassRequest(body, model, userAgent = "", ccFilterNaming = false) {
+  if (!userAgent.includes("claude-cli")) return null;
+  if (!body.messages?.length) return null;
+
+  const messages = body.messages;
+  const getText = (content) => {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content.filter(c => c.type === "text").map(c => c.text).join(" ");
+    }
+    return "";
+  };
+
+  let shouldBypass = false;
+  let namingBypass = false;
+
+  // Pattern 1: Title extraction (assistant message = "{")
+  const lastMsg = messages[messages.length - 1];
+  if (lastMsg?.role === "assistant" && lastMsg.content?.[0]?.text === "{") {
+    shouldBypass = true;
+  }
+
+  // Pattern 2: Warmup
+  if (!shouldBypass) {
+    const firstText = getText(messages[0]?.content);
+    if (firstText === "Warmup") {
+      shouldBypass = true;
+    }
+  }
+
+  // Pattern 3: Count
+  if (!shouldBypass && messages.length === 1 && messages[0]?.role === "user") {
+    const firstText = getText(messages[0]?.content);
+    if (firstText === "count") {
+      shouldBypass = true;
+    }
+  }
+
+  // Pattern 4: Skip patterns
+  if (!shouldBypass && SKIP_PATTERNS?.length) {
+    const userMessages = messages.filter(m => m.role === "user");
+    const userText = userMessages.map(m => getText(m.content)).join(" ");
+    if (SKIP_PATTERNS.some(p => userText.includes(p))) {
+      shouldBypass = true;
+    }
+  }
+
+  // Pattern 5: CC naming request (topic title extraction by Claude Code CLI)
+  // Claude format: system is top-level body.system field, not inside messages
+  if (!shouldBypass && ccFilterNaming) {
+    const systemMsg = messages.find(m => m.role === "system");
+    const systemFromMessages = getText(systemMsg?.content);
+    const systemFromBody = Array.isArray(body.system)
+      ? body.system.filter(s => s.type === "text").map(s => s.text).join(" ")
+      : (typeof body.system === "string" ? body.system : "");
+    const systemText = systemFromMessages || systemFromBody;
+    if (systemText.includes("isNewTopic")) {
+      shouldBypass = true;
+      namingBypass = true;
+    }
+  }
+
+  if (!shouldBypass) return null;
+
+  const sourceFormat = detectFormat(body);
+  const stream = body.stream !== false;
+
+  // For naming bypass, generate title from user message
+  if (namingBypass) {
+    const userMsg = messages.find(m => m.role === "user");
+    const userText = getText(userMsg?.content);
+    const title = userText.trim().split(/\s+/).slice(0, 3).join(" ");
+    const namingText = JSON.stringify({ isNewTopic: true, title });
+    return stream
+      ? createStreamingResponse(sourceFormat, model, namingText)
+      : createNonStreamingResponse(sourceFormat, model, namingText);
+  }
+
+  return stream 
+    ? createStreamingResponse(sourceFormat, model)
+    : createNonStreamingResponse(sourceFormat, model);
+}
+
+const DEFAULT_BYPASS_TEXT = "CLI Command Execution: Clear Terminal";
+
+/**
+ * Create OpenAI standard format response
+ */
+function createOpenAIResponse(model, text = DEFAULT_BYPASS_TEXT) {
+  const id = `chatcmpl-${Date.now()}`;
+  const created = Math.floor(Date.now() / 1000);
+
+  return {
+    id,
+    object: "chat.completion",
+    created,
+    model,
+    choices: [{
+      index: 0,
+      message: {
+        role: "assistant",
+        content: text
+      },
+      finish_reason: "stop"
+    }],
+    usage: {
+      prompt_tokens: 1,
+      completion_tokens: 1,
+      total_tokens: 2
+    }
+  };
+}
+
+/**
+ * Create non-streaming response with translation
+ * Use translator to convert OpenAI → sourceFormat
+ */
+function createNonStreamingResponse(sourceFormat, model, text) {
+  const openaiResponse = createOpenAIResponse(model, text);
+
+  // If sourceFormat is OpenAI, return directly
+  if (sourceFormat === FORMATS.OPENAI) {
+    return {
+      success: true,
+      response: new Response(JSON.stringify(openaiResponse), {
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*"
+        }
+      })
+    };
+  }
+
+  // Use translator to convert: simulate streaming then collect all chunks
+  const state = initState(sourceFormat);
+  state.model = model;
+
+  const openaiChunks = createOpenAIStreamingChunks(openaiResponse);
+  const allTranslated = [];
+
+  for (const chunk of openaiChunks) {
+    const translated = translateResponse(FORMATS.OPENAI, sourceFormat, chunk, state);
+    if (translated?.length > 0) {
+      allTranslated.push(...translated);
+    }
+  }
+
+  // Flush remaining
+  const flushed = translateResponse(FORMATS.OPENAI, sourceFormat, null, state);
+  if (flushed?.length > 0) {
+    allTranslated.push(...flushed);
+  }
+
+  // For non-streaming, merge all chunks into final response
+  const finalResponse = mergeChunksToResponse(allTranslated, sourceFormat);
+
+  return {
+    success: true,
+    response: new Response(JSON.stringify(finalResponse), {
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*"
+      }
+    })
+  };
+}
+
+/**
+ * Create streaming response with translation
+ * Use translator to convert OpenAI chunks → sourceFormat
+ */
+function createStreamingResponse(sourceFormat, model, text) {
+  const openaiResponse = createOpenAIResponse(model, text);
+  const state = initState(sourceFormat);
+  state.model = model;
+
+  // Create OpenAI streaming chunks
+  const openaiChunks = createOpenAIStreamingChunks(openaiResponse);
+
+  // Translate each chunk to sourceFormat using translator
+  const translatedChunks = [];
+
+  for (const chunk of openaiChunks) {
+    const translated = translateResponse(FORMATS.OPENAI, sourceFormat, chunk, state);
+    if (translated?.length > 0) {
+      for (const item of translated) {
+        translatedChunks.push(formatSSE(item, sourceFormat));
+      }
+    }
+  }
+
+  // Flush remaining events
+  const flushed = translateResponse(FORMATS.OPENAI, sourceFormat, null, state);
+  if (flushed?.length > 0) {
+    for (const item of flushed) {
+      translatedChunks.push(formatSSE(item, sourceFormat));
+    }
+  }
+
+  // Add [DONE]
+  translatedChunks.push("data: [DONE]\n\n");
+
+  return {
+    success: true,
+    response: new Response(translatedChunks.join(""), {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "Access-Control-Allow-Origin": "*"
+      }
+    })
+  };
+}
+
+/**
+ * Merge translated chunks into final response object (for non-streaming)
+ * Takes the last complete chunk as the final response
+ */
+function mergeChunksToResponse(chunks, sourceFormat) {
+  if (!chunks || chunks.length === 0) {
+    return createOpenAIResponse("unknown");
+  }
+
+  // For most formats, the last chunk before done contains the complete response
+  // Find the most complete chunk (usually the last one with content)
+  let finalChunk = chunks[chunks.length - 1];
+
+  // For Claude format, find the message_stop or final message
+  if (sourceFormat === FORMATS.CLAUDE) {
+    const messageStop = chunks.find(c => c.type === "message_stop");
+    if (messageStop) {
+      // Reconstruct complete message from chunks
+      const contentDelta = chunks.find(c => c.type === "content_block_delta");
+      const messageDelta = chunks.find(c => c.type === "message_delta");
+      const messageStart = chunks.find(c => c.type === "message_start");
+
+      if (messageStart?.message) {
+        finalChunk = messageStart.message;
+        // Merge usage if available
+        if (messageDelta?.usage) {
+          finalChunk.usage = messageDelta.usage;
+        }
+      }
+    }
+  }
+
+  return finalChunk;
+}
+
+/**
+ * Create OpenAI streaming chunks from complete response
+ */
+function createOpenAIStreamingChunks(completeResponse) {
+  const { id, created, model, choices } = completeResponse;
+  const content = choices[0].message.content;
+
+  return [
+    // Chunk with content
+    {
+      id,
+      object: "chat.completion.chunk",
+      created,
+      model,
+      choices: [{
+        index: 0,
+        delta: {
+          role: "assistant",
+          content
+        },
+        finish_reason: null
+      }]
+    },
+    // Final chunk with finish_reason
+    {
+      id,
+      object: "chat.completion.chunk",
+      created,
+      model,
+      choices: [{
+        index: 0,
+        delta: {},
+        finish_reason: "stop"
+      }],
+      usage: completeResponse.usage
+    }
+  ];
+}

package/open-sse/utils/cacheControlPolicy.js

@@ -0,0 +1,189 @@
+const DETERMINISTIC_STRATEGIES = /* @__PURE__ */ new Set(["priority", "cost-optimized"]);
+const CACHING_PROVIDERS = /* @__PURE__ */ new Set([
+  "claude",
+  "anthropic",
+  "zai",
+  "qwen",
+  "deepseek",
+  // #3088 — Xiaomi MiMo honors OpenAI-format cache_control breakpoints. Without
+  // this entry, shouldPreserveCacheControl() returns false for Claude Code
+  // clients and filterToOpenAIFormat() strips cache_control, so Xiaomi never
+  // sees the cache hints and every request is a cache miss.
+  "xiaomi-mimo",
+  // #3955 — OpenAI / Codex / Azure-OpenAI use AUTOMATIC prefix caching: the longest
+  // matching prefix of a request is cached upstream WITHOUT any explicit cache_control
+  // markers. They must count as caching providers so the cache-aware compression guard
+  // preserves the cacheable prefix (system prompt / earliest messages) instead of
+  // rewriting it and forcing a cache miss. This also activates the intended
+  // `prompt_cache_key` cache-routing hint for OpenAI in chatCore.
+  "openai",
+  "codex",
+  "azure",
+  // #2069 — Alibaba DashScope's OpenAI-compatible endpoints (alibaba /
+  // alibaba-cn, upstream "alicode"/"alicode-intl") natively honor
+  // `cache_control: {type:"ephemeral"}` breakpoints. Without these entries
+  // shouldPreserveCacheControl() returns false for Claude Code clients and the
+  // OpenAI-format translator strips cache_control, so DashScope never sees the
+  // hints and every request is a cache miss.
+  "alibaba",
+  "alibaba-cn"
+]);
+const OPENAI_FORMAT_CACHE_CONTROL_PROVIDERS = /* @__PURE__ */ new Set([
+  // #2069 — DashScope OpenAI-compatible endpoints accept ephemeral breakpoints.
+  "alibaba",
+  "alibaba-cn",
+  // #3088 — Xiaomi MiMo honors OpenAI-format cache_control breakpoints.
+  "xiaomi-mimo"
+]);
+function providerHonorsOpenAIFormatCacheControl(provider) {
+  if (!provider) return false;
+  return OPENAI_FORMAT_CACHE_CONTROL_PROVIDERS.has(provider.toLowerCase());
+}
+function isClaudeCodeClient(userAgent) {
+  if (!userAgent) return false;
+  const ua = userAgent.toLowerCase();
+  if (ua.includes("claude-code") || ua.includes("claude_code")) return true;
+  if (ua.includes("claude-cli/")) return true;
+  if (ua.includes("sdk-cli")) return true;
+  if (ua.includes("anthropic") && ua.includes("cli")) return true;
+  return false;
+}
+function providerSupportsCaching(provider, targetFormat) {
+  if (!provider) return false;
+  if (CACHING_PROVIDERS.has(provider.toLowerCase())) return true;
+  if (targetFormat === "claude") return true;
+  return false;
+}
+function isDeterministicStrategy(strategy) {
+  if (!strategy) return false;
+  return DETERMINISTIC_STRATEGIES.has(strategy);
+}
+function shouldPreserveCacheControl({
+  userAgent,
+  isCombo,
+  comboStrategy,
+  targetProvider,
+  targetFormat,
+  settings
+}) {
+  if (settings?.alwaysPreserveClientCache === "always") {
+    return true;
+  }
+  if (settings?.alwaysPreserveClientCache === "never") {
+    return false;
+  }
+  if (!isClaudeCodeClient(userAgent)) {
+    return false;
+  }
+  if (!providerSupportsCaching(targetProvider, targetFormat)) {
+    return false;
+  }
+  if (!isCombo) {
+    return true;
+  }
+  return isDeterministicStrategy(comboStrategy);
+}
+function trackCacheMetrics({
+  preserved,
+  provider,
+  strategy,
+  metrics,
+  inputTokens,
+  cachedTokens,
+  cacheCreationTokens
+}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (!metrics) {
+    metrics = {
+      totalRequests: 0,
+      requestsWithCacheControl: 0,
+      totalInputTokens: 0,
+      totalCachedTokens: 0,
+      totalCacheCreationTokens: 0,
+      tokensSaved: 0,
+      estimatedCostSaved: 0,
+      byProvider: {},
+      byStrategy: {},
+      lastUpdated: now
+    };
+  }
+  metrics.totalRequests++;
+  const input = inputTokens || 0;
+  const cached = cachedTokens || 0;
+  const creation = cacheCreationTokens || 0;
+  metrics.totalInputTokens += input;
+  metrics.totalCachedTokens += cached;
+  metrics.totalCacheCreationTokens += creation;
+  if (cached > 0) {
+    metrics.tokensSaved += cached;
+  }
+  if (preserved) {
+    metrics.requestsWithCacheControl++;
+    if (!metrics.byProvider[provider]) {
+      metrics.byProvider[provider] = {
+        requests: 0,
+        inputTokens: 0,
+        cachedTokens: 0,
+        cacheCreationTokens: 0
+      };
+    }
+    metrics.byProvider[provider].requests++;
+    metrics.byProvider[provider].inputTokens += input;
+    metrics.byProvider[provider].cachedTokens += cached;
+    metrics.byProvider[provider].cacheCreationTokens += creation;
+    if (strategy && !metrics.byStrategy[strategy]) {
+      metrics.byStrategy[strategy] = {
+        requests: 0,
+        inputTokens: 0,
+        cachedTokens: 0,
+        cacheCreationTokens: 0
+      };
+    }
+    if (strategy) {
+      metrics.byStrategy[strategy].requests++;
+      metrics.byStrategy[strategy].inputTokens += input;
+      metrics.byStrategy[strategy].cachedTokens += cached;
+      metrics.byStrategy[strategy].cacheCreationTokens += creation;
+    }
+  }
+  metrics.lastUpdated = now;
+  return metrics;
+}
+function updateCacheTokenMetrics({
+  metrics,
+  provider,
+  strategy,
+  inputTokens,
+  cachedTokens,
+  cacheCreationTokens,
+  costSaved
+}) {
+  metrics.totalCachedTokens += cachedTokens;
+  metrics.totalCacheCreationTokens += cacheCreationTokens;
+  metrics.totalInputTokens += inputTokens;
+  metrics.tokensSaved += cachedTokens;
+  if (costSaved !== void 0) {
+    metrics.estimatedCostSaved += costSaved;
+  }
+  if (metrics.byProvider[provider]) {
+    metrics.byProvider[provider].cachedTokens += cachedTokens;
+    metrics.byProvider[provider].cacheCreationTokens += cacheCreationTokens;
+    metrics.byProvider[provider].inputTokens += inputTokens;
+  }
+  if (strategy && metrics.byStrategy[strategy]) {
+    metrics.byStrategy[strategy].cachedTokens += cachedTokens;
+    metrics.byStrategy[strategy].cacheCreationTokens += cacheCreationTokens;
+    metrics.byStrategy[strategy].inputTokens += inputTokens;
+  }
+  metrics.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  return metrics;
+}
+export {
+  isClaudeCodeClient,
+  isDeterministicStrategy,
+  providerHonorsOpenAIFormatCacheControl,
+  providerSupportsCaching,
+  shouldPreserveCacheControl,
+  trackCacheMetrics,
+  updateCacheTokenMetrics
+};

package/open-sse/utils/claudeCloaking.js

@@ -0,0 +1,155 @@
+import { createHash, randomBytes, randomUUID } from "crypto";
+import { CLAUDE_TOOL_SUFFIX, CC_DEFAULT_TOOLS } from "../config/appConstants.js";
+
+const CLAUDE_VERSION = "2.1.92";
+const CC_ENTRYPOINT = "sdk-cli";
+
+// Generate billing header matching real Claude Code 2.1.92+ format:
+// x-anthropic-billing-header: cc_version=<ver>.<build>; cc_entrypoint=sdk-cli; cch=<hash>;
+function generateBillingHeader(payload) {
+  const content = JSON.stringify(payload);
+  const cch = createHash("sha256").update(content).digest("hex").slice(0, 5);
+  const buildHash = randomBytes(2).toString("hex").slice(0, 3);
+  return `x-anthropic-billing-header: cc_version=${CLAUDE_VERSION}.${buildHash}; cc_entrypoint=${CC_ENTRYPOINT}; cch=${cch};`;
+}
+
+// Generate fake user ID in Claude Code 2.1.92+ JSON format:
+// {"device_id":"<64hex>","account_uuid":"<uuid>","session_id":"<uuid>"}
+function generateFakeUserID(sessionId) {
+  const deviceId = randomBytes(32).toString("hex");
+  const accountUuid = randomUUID();
+  const sessionUuid = sessionId || randomUUID();
+  return `{"device_id":"${deviceId}","account_uuid":"${accountUuid}","session_id":"${sessionUuid}"}`;
+}
+
+/**
+ * Cloak tools before sending to Claude provider (anti-ban):
+ * - Rename non-CC client tools with _cc suffix in tools[] and messages[]
+ * - Skip tools that are already CC default names (they become decoys as-is)
+ * - Inject CC_DECOY_TOOLS after client tools
+ * Returns { body, toolNameMap } where toolNameMap maps suffixed → original
+ * @param {object} body - Claude API request body
+ * @returns {{ body: object, toolNameMap: Map|null }}
+ */
+export function cloakClaudeTools(body) {
+  const tools = body.tools;
+  if (!tools || tools.length === 0) return { body, toolNameMap: null };
+
+  const suffix = (name) => `${name}${CLAUDE_TOOL_SUFFIX}`;
+  const toolNameMap = new Map();
+  const clientToolNames = new Set();
+  const clientDeclarations = [];
+
+  // All client tools get renamed with suffix
+  for (const tool of tools) {
+    const suffixed = suffix(tool.name);
+    toolNameMap.set(suffixed, tool.name);
+    clientToolNames.add(tool.name);
+    clientDeclarations.push({ ...tool, name: suffixed });
+  }
+
+  // Client tools first, then CC decoy tools (no overlap: client tools all have _cc suffix)
+  const allTools = [...clientDeclarations, ...CC_DECOY_TOOLS];
+
+  // Rename tool_use in message history (all client tools get suffix)
+  const renamedMessages = body.messages?.map(msg => {
+    if (!Array.isArray(msg.content)) return msg;
+    const renamedContent = msg.content.map(block =>
+      block.type === "tool_use" ? { ...block, name: suffix(block.name) } : block
+    );
+    return { ...msg, content: renamedContent };
+  });
+
+  const cloakedBody = { ...body, tools: allTools, messages: renamedMessages || body.messages };
+
+  // A forced tool_choice ({ type: "tool", name }) must point at the suffixed
+  // tool name, otherwise Claude rejects it: "Tool '<name>' not found in provided tools".
+  // Only rewrite when the choice targets one of the client tools we actually
+  // renamed — never a decoy/built-in name (those are sent unsuffixed).
+  if (
+    body.tool_choice?.type === "tool" &&
+    clientToolNames.has(body.tool_choice.name)
+  ) {
+    cloakedBody.tool_choice = { ...body.tool_choice, name: suffix(body.tool_choice.name) };
+  }
+
+  return {
+    body: cloakedBody,
+    toolNameMap: toolNameMap.size > 0 ? toolNameMap : null
+  };
+}
+
+// Decloak tool_use names in non-streaming Claude response body (INPUT side)
+export function decloakToolNames(body, toolNameMap) {
+  if (!toolNameMap?.size || !Array.isArray(body?.content)) return body;
+  const content = body.content.map(block => {
+    if (block?.type === "tool_use" && toolNameMap.has(block.name)) {
+      return { ...block, name: toolNameMap.get(block.name) };
+    }
+    return block;
+  });
+  return { ...body, content };
+}
+
+// CC decoy tools — Claude Code native tool names, marked unavailable
+const CC_DECOY_TOOLS = [
+  { name: "Task", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskOutput", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskStop", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskCreate", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskGet", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskUpdate", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskList", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Bash", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Glob", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Grep", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Read", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Edit", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Write", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "NotebookEdit", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "WebFetch", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "WebSearch", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "AskUserQuestion", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Skill", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "EnterPlanMode", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "ExitPlanMode", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+];
+
+/**
+ * Apply Claude cloaking to request body:
+ * 1. Inject billing header as first system block
+ * 2. Inject fake user ID into metadata (JSON format, session_id aligned with X-Claude-Code-Session-Id)
+ * Only applies when using OAuth token (sk-ant-oat).
+ * @param {object} body - Claude API request body
+ * @param {string} apiKey - API key or OAuth token
+ * @param {string} [sessionId] - Session ID to align with X-Claude-Code-Session-Id header
+ * @returns {object} Modified body
+ */
+export function applyCloaking(body, apiKey, sessionId) {
+  if (!apiKey || !apiKey.includes("sk-ant-oat")) return body;
+
+  const result = { ...body };
+
+  // Inject billing header as system[0], preserve existing system blocks
+  const billingText = generateBillingHeader(body);
+  const billingBlock = { type: "text", text: billingText };
+
+  if (Array.isArray(result.system)) {
+    // Skip if already injected
+    if (!result.system[0]?.text?.startsWith("x-anthropic-billing-header:")) {
+      result.system = [billingBlock, ...result.system];
+    }
+  } else if (typeof result.system === "string") {
+    result.system = [billingBlock, { type: "text", text: result.system }];
+  } else {
+    result.system = [billingBlock];
+  }
+
+  // Inject fake user ID into metadata (session_id must match X-Claude-Code-Session-Id)
+  const existingUserId = result.metadata?.user_id;
+  if (!existingUserId) {
+    result.metadata = { ...result.metadata, user_id: generateFakeUserID(sessionId) };
+  }
+
+  return result;
+}