@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/utils/bypassHandler.js

@@ -1,298 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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;
-}