@xortex/xcode 3.0.0

package/services/api/metricsOptOut.ts

@@ -0,0 +1,159 @@
+import axios from 'src/utils/axios.js'
+import { hasProfileScope, isClaudeAISubscriber } from '../../utils/auth.js'
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { errorMessage } from '../../utils/errors.js'
+import { getAuthHeaders, withOAuth401Retry } from '../../utils/http.js'
+import { logError } from '../../utils/log.js'
+import { memoizeWithTTLAsync } from '../../utils/memoize.js'
+import { isEssentialTrafficOnly } from '../../utils/privacyLevel.js'
+import { getClaudeCodeUserAgent } from '../../utils/userAgent.js'
+
+type MetricsEnabledResponse = {
+  metrics_logging_enabled: boolean
+}
+
+type MetricsStatus = {
+  enabled: boolean
+  hasError: boolean
+}
+
+// In-memory TTL — dedupes calls within a single process
+const CACHE_TTL_MS = 60 * 60 * 1000
+
+// Disk TTL — org settings rarely change. When disk cache is fresher than this,
+// we skip the network entirely (no background refresh). This is what collapses
+// N `claude -p` invocations into ~1 API call/day.
+const DISK_CACHE_TTL_MS = 24 * 60 * 60 * 1000
+
+/**
+ * Internal function to call the API and check if metrics are enabled
+ * This is wrapped by memoizeWithTTLAsync to add caching behavior
+ */
+async function _fetchMetricsEnabled(): Promise<MetricsEnabledResponse> {
+  const authResult = getAuthHeaders()
+  if (authResult.error) {
+    throw new Error(`Auth error: ${authResult.error}`)
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'User-Agent': getClaudeCodeUserAgent(),
+    ...authResult.headers,
+  }
+
+  const endpoint = `https://api.anthropic.com/api/claude_code/organizations/metrics_enabled`
+  const response = await axios.get<MetricsEnabledResponse>(endpoint, {
+    headers,
+    timeout: 5000,
+  })
+  return response.data
+}
+
+async function _checkMetricsEnabledAPI(): Promise<MetricsStatus> {
+  // Incident kill switch: skip the network call when nonessential traffic is disabled.
+  // Returning enabled:false sheds load at the consumer (bigqueryExporter skips
+  // export). Matches the non-subscriber early-return shape below.
+  if (isEssentialTrafficOnly()) {
+    return { enabled: false, hasError: false }
+  }
+
+  try {
+    const data = await withOAuth401Retry(_fetchMetricsEnabled, {
+      also403Revoked: true,
+    })
+
+    logForDebugging(
+      `Metrics opt-out API response: enabled=${data.metrics_logging_enabled}`,
+    )
+
+    return {
+      enabled: data.metrics_logging_enabled,
+      hasError: false,
+    }
+  } catch (error) {
+    logForDebugging(
+      `Failed to check metrics opt-out status: ${errorMessage(error)}`,
+    )
+    logError(error)
+    return { enabled: false, hasError: true }
+  }
+}
+
+// Create memoized version with custom error handling
+const memoizedCheckMetrics = memoizeWithTTLAsync(
+  _checkMetricsEnabledAPI,
+  CACHE_TTL_MS,
+)
+
+/**
+ * Fetch (in-memory memoized) and persist to disk on change.
+ * Errors are not persisted — a transient failure should not overwrite a
+ * known-good disk value.
+ */
+async function refreshMetricsStatus(): Promise<MetricsStatus> {
+  const result = await memoizedCheckMetrics()
+  if (result.hasError) {
+    return result
+  }
+
+  const cached = getGlobalConfig().metricsStatusCache
+  const unchanged = cached !== undefined && cached.enabled === result.enabled
+  // Skip write when unchanged AND timestamp still fresh — avoids config churn
+  // when concurrent callers race past a stale disk entry and all try to write.
+  if (unchanged && Date.now() - cached.timestamp < DISK_CACHE_TTL_MS) {
+    return result
+  }
+
+  saveGlobalConfig(current => ({
+    ...current,
+    metricsStatusCache: {
+      enabled: result.enabled,
+      timestamp: Date.now(),
+    },
+  }))
+  return result
+}
+
+/**
+ * Check if metrics are enabled for the current organization.
+ *
+ * Two-tier cache:
+ * - Disk (24h TTL): survives process restarts. Fresh disk cache → zero network.
+ * - In-memory (1h TTL): dedupes the background refresh within a process.
+ *
+ * The caller (bigqueryExporter) tolerates stale reads — a missed export or
+ * an extra one during the 24h window is acceptable.
+ */
+export async function checkMetricsEnabled(): Promise<MetricsStatus> {
+  // Service key OAuth sessions lack user:profile scope → would 403.
+  // API key users (non-subscribers) fall through and use x-api-key auth.
+  // This check runs before the disk read so we never persist auth-state-derived
+  // answers — only real API responses go to disk. Otherwise a service-key
+  // session would poison the cache for a later full-OAuth session.
+  if (isClaudeAISubscriber() && !hasProfileScope()) {
+    return { enabled: false, hasError: false }
+  }
+
+  const cached = getGlobalConfig().metricsStatusCache
+  if (cached) {
+    if (Date.now() - cached.timestamp > DISK_CACHE_TTL_MS) {
+      // saveGlobalConfig's fallback path (config.ts:731) can throw if both
+      // locked and fallback writes fail — catch here so fire-and-forget
+      // doesn't become an unhandled rejection.
+      void refreshMetricsStatus().catch(logError)
+    }
+    return {
+      enabled: cached.enabled,
+      hasError: false,
+    }
+  }
+
+  // First-ever run on this machine: block on the network to populate disk.
+  return refreshMetricsStatus()
+}
+
+// Export for testing purposes only
+export const _clearMetricsEnabledCacheForTesting = (): void => {
+  memoizedCheckMetrics.cache.clear()
+}

package/services/api/openRouterClient.ts

@@ -0,0 +1,453 @@
+// OpenRouter client wrapper that mimics the Anthropic SDK interface
+import type { BetaRawMessageStreamEvent, BetaToolUnion, BetaMessageParam } from '@anthropic-ai/sdk/resources/beta/messages/messages.mjs';
+import type { Stream } from '@anthropic-ai/sdk/streaming.mjs';
+import { randomUUID } from 'crypto';
+import { redaxios } from 'redaxios';
+
+const OPENROUTER_API_URL = 'https://openrouter.ai/api/v1';
+
+// Model mappings from OpenRouter to our internal names
+const OPENROUTER_MODEL_MAP: Record<string, string> = {
+  // kimi k2.5 series
+  'kimi': 'moonshotai/kimi-k2-5',
+  'kimi2.5': 'moonshotai/kimi-k2-5',
+  'kimi-k2.5': 'moonshotai/kimi-k2-5',
+
+  // DeepSeek V3.2 series
+  'deepseek': 'deepseek/deepseek-v3.2',
+  'deepseek-v3.2': 'deepseek/deepseek-v3.2',
+  'deepseek-v3': 'deepseek/deepseek-v3.2',
+
+  // Gemini 2.5 Pro (top coding model)
+  'gemini': 'google/gemini-2.5-pro-preview',
+  'gemini-pro': 'google/gemini-2.5-pro-preview',
+  'gemini-2.5': 'google/gemini-2.5-pro-preview',
+  'gemini-2.5-pro': 'google/gemini-2.5-pro-preview',
+};
+
+// Convert Anthropic tools to OpenRouter/OpenAI format
+function convertTools(tools: BetaToolUnion[] | undefined): any[] | undefined {
+  if (!tools || tools.length === 0) return undefined;
+
+  return tools.map((tool: any) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.input_schema || { type: 'object', properties: {} },
+    },
+  }));
+}
+
+// Convert Anthropic messages to OpenRouter format
+function convertMessages(messages: BetaMessageParam[]): any[] {
+  return messages.map(msg => {
+    const role = msg.role === 'assistant' ? 'assistant' : msg.role;
+
+    if (Array.isArray(msg.content)) {
+      const contentParts: any[] = [];
+      const toolCalls: any[] = [];
+      const toolResults: any[] = [];
+
+      for (const block of msg.content as any[]) {
+        if (block.type === 'text') {
+          contentParts.push({ type: 'text', text: block.text });
+        } else if (block.type === 'tool_use') {
+          toolCalls.push({
+            id: block.id,
+            type: 'function',
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(block.input),
+            },
+          });
+        } else if (block.type === 'tool_result') {
+          toolResults.push({
+            tool_call_id: block.tool_use_id,
+            role: 'tool',
+            content: typeof block.content === 'string'
+              ? block.content
+              : JSON.stringify(block.content),
+          });
+        }
+      }
+
+      // OpenRouter expects tool results as separate messages
+      if (toolResults.length > 0) {
+        return [
+          {
+            role,
+            content: contentParts.length > 0 ? contentParts : null,
+            tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+          },
+          ...toolResults,
+        ];
+      }
+
+      return {
+        role,
+        content: contentParts.length > 0 ? contentParts : null,
+        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+      };
+    } else if (typeof msg.content === 'string') {
+      return { role, content: msg.content };
+    }
+
+    return { role, content: '' };
+  }).flat();
+}
+
+// Create a stream that converts OpenRouter SSE stream to Anthropic format
+async function* createOpenRouterStream(
+  model: string,
+  systemPrompt: string | undefined,
+  messages: BetaMessageParam[],
+  tools: BetaToolUnion[] | undefined,
+  maxTokens: number,
+  apiKey: string,
+  signal?: AbortSignal
+): AsyncGenerator<BetaRawMessageStreamEvent> {
+  const openRouterTools = convertTools(tools);
+  const openRouterMessages = systemPrompt
+    ? [{ role: 'system', content: systemPrompt }, ...convertMessages(messages)]
+    : convertMessages(messages);
+
+  // Map model name to OpenRouter model ID
+  const openRouterModel = OPENROUTER_MODEL_MAP[model] || model;
+
+  const requestBody = {
+    model: openRouterModel,
+    messages: openRouterMessages,
+    tools: openRouterTools,
+    max_tokens: maxTokens,
+    stream: true,
+    // OpenRouter specific headers will be sent in the request
+  };
+
+  // Yield message_start
+  yield {
+    type: 'message_start',
+    message: {
+      id: `msg_${randomUUID()}`,
+      type: 'message',
+      role: 'assistant',
+      content: [],
+      model,
+      stop_reason: null,
+      stop_sequence: null,
+      usage: {
+        input_tokens: 0,
+        output_tokens: 0,
+      },
+    },
+  };
+
+  try {
+    const response = await fetch(`${OPENROUTER_API_URL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'HTTP-Referer': 'https://claude-code.xmem.ai',
+        'X-OpenRouter-Title': 'Claude Code with XMem',
+      },
+      body: JSON.stringify(requestBody),
+      signal,
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenRouter API error: ${response.status} - ${error}`);
+    }
+
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error('No response body from OpenRouter');
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let contentBlockIndex = 0;
+    let hasToolUse = false;
+    let currentToolCall: any = null;
+
+    while (true) {
+      if (signal?.aborted) {
+        throw new Error('Request was aborted.');
+      }
+
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.trim() || !line.startsWith('data: ')) continue;
+
+        const data = line.slice(6);
+        if (data === '[DONE]') continue;
+
+        try {
+          const chunk = JSON.parse(data);
+          const delta = chunk.choices?.[0]?.delta;
+
+          if (!delta) continue;
+
+          // Handle text content
+          if (delta.content) {
+            if (contentBlockIndex === 0 && !hasToolUse) {
+              yield {
+                type: 'content_block_start',
+                index: contentBlockIndex,
+                content_block: { type: 'text', text: '' },
+              };
+            }
+
+            yield {
+              type: 'content_block_delta',
+              index: contentBlockIndex,
+              delta: { type: 'text_delta', text: delta.content },
+            };
+          }
+
+          // Handle tool calls
+          if (delta.tool_calls) {
+            for (const toolCall of delta.tool_calls) {
+              if (toolCall.index !== undefined) {
+                if (!currentToolCall || toolCall.index !== currentToolCall.index) {
+                  // Start new tool call
+                  if (currentToolCall) {
+                    // Finish previous tool call
+                    yield {
+                      type: 'content_block_stop',
+                      index: currentToolCall.index,
+                    };
+                  }
+
+                  currentToolCall = {
+                    index: toolCall.index,
+                    id: toolCall.id || `toolu_${randomUUID()}`,
+                    name: toolCall.function?.name || '',
+                    arguments: toolCall.function?.arguments || '',
+                  };
+
+                  hasToolUse = true;
+
+                  yield {
+                    type: 'content_block_start',
+                    index: toolCall.index,
+                    content_block: {
+                      type: 'tool_use',
+                      id: currentToolCall.id,
+                      name: currentToolCall.name,
+                      input: {},
+                    },
+                  };
+                } else {
+                  // Continue current tool call - accumulate arguments
+                  if (toolCall.function?.arguments) {
+                    currentToolCall.arguments += toolCall.function.arguments;
+
+                    try {
+                      const parsedArgs = JSON.parse(currentToolCall.arguments);
+                      yield {
+                        type: 'content_block_delta',
+                        index: toolCall.index,
+                        delta: {
+                          type: 'input_json_delta',
+                          partial_json: toolCall.function.arguments,
+                        },
+                      };
+                    } catch {
+                      // Arguments not complete yet, send as partial JSON
+                      yield {
+                        type: 'content_block_delta',
+                        index: toolCall.index,
+                        delta: {
+                          type: 'input_json_delta',
+                          partial_json: toolCall.function.arguments,
+                        },
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+
+          // Handle finish reason
+          if (chunk.choices?.[0]?.finish_reason) {
+            const finishReason = chunk.choices[0].finish_reason;
+
+            // Stop current content block if any
+            if (contentBlockIndex === 0 && !hasToolUse) {
+              yield {
+                type: 'content_block_stop',
+                index: 0,
+              };
+            }
+
+            // Stop current tool call if any
+            if (currentToolCall) {
+              yield {
+                type: 'content_block_stop',
+                index: currentToolCall.index,
+              };
+
+              // Parse final tool input
+              try {
+                const finalInput = JSON.parse(currentToolCall.arguments);
+                // We already yielded the deltas, the tool_use block has the final input
+              } catch {
+                // Invalid JSON, but we already sent what we had
+              }
+            }
+
+            // Yield message_delta
+            yield {
+              type: 'message_delta',
+              delta: {
+                stop_reason: finishReason === 'tool_calls' ? 'tool_use' : finishReason,
+                stop_sequence: null,
+              },
+              usage: chunk.usage ? {
+                input_tokens: chunk.usage.prompt_tokens || 0,
+                output_tokens: chunk.usage.completion_tokens || 0,
+              } : undefined,
+            };
+          }
+
+        } catch (e) {
+          // Skip malformed JSON
+          continue;
+        }
+      }
+    }
+
+    // Yield message_stop
+    yield { type: 'message_stop' };
+
+  } catch (error) {
+    if (signal?.aborted) {
+      throw new Error('Request was aborted.');
+    }
+    throw error;
+  }
+}
+
+// OpenRouter Anthropic-compatible client
+export class OpenRouterAnthropicClient {
+  private apiKey: string;
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  messages = {
+    create: async (params: {
+      model: string;
+      max_tokens: number;
+      messages: BetaMessageParam[];
+      tools?: BetaToolUnion[];
+      system?: string;
+      signal?: AbortSignal;
+    }): Promise<any> => {
+      // Non-streaming implementation
+      const openRouterTools = convertTools(params.tools);
+      const openRouterMessages = params.system
+        ? [{ role: 'system', content: params.system }, ...convertMessages(params.messages)]
+        : convertMessages(params.messages);
+
+      const openRouterModel = OPENROUTER_MODEL_MAP[params.model] || params.model;
+
+      const requestBody = {
+        model: openRouterModel,
+        messages: openRouterMessages,
+        tools: openRouterTools,
+        max_tokens: params.maxTokens,
+        stream: false,
+      };
+
+      const response = await fetch(`${OPENROUTER_API_URL}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`,
+          'Content-Type': 'application/json',
+          'HTTP-Referer': 'https://claude-code.xmem.ai',
+          'X-OpenRouter-Title': 'Claude Code with XMem',
+        },
+        body: JSON.stringify(requestBody),
+        signal: params.signal,
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`OpenRouter API error: ${response.status} - ${error}`);
+      }
+
+      const result = await response.json();
+
+      // Convert OpenRouter response to Anthropic format
+      const message = result.choices?.[0]?.message;
+      const content: any[] = [];
+
+      if (message.content) {
+        if (typeof message.content === 'string') {
+          content.push({ type: 'text', text: message.content });
+        } else if (Array.isArray(message.content)) {
+          for (const part of message.content) {
+            if (part.type === 'text') {
+              content.push({ type: 'text', text: part.text });
+            }
+          }
+        }
+      }
+
+      if (message.tool_calls) {
+        for (const toolCall of message.tool_calls) {
+          content.push({
+            type: 'tool_use',
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: JSON.parse(toolCall.function.arguments || '{}'),
+          });
+        }
+      }
+
+      return {
+        id: result.id || `msg_${randomUUID()}`,
+        type: 'message',
+        role: 'assistant',
+        content,
+        model: params.model,
+        stop_reason: message.tool_calls ? 'tool_use' : result.choices?.[0]?.finish_reason,
+        stop_sequence: null,
+        usage: result.usage ? {
+          input_tokens: result.usage.prompt_tokens,
+          output_tokens: result.usage.completion_tokens,
+        } : undefined,
+      };
+    },
+
+    stream: async function* (params: {
+      model: string;
+      max_tokens: number;
+      messages: BetaMessageParam[];
+      tools?: BetaToolUnion[];
+      system?: string;
+      signal?: AbortSignal;
+    }): AsyncGenerator<BetaRawMessageStreamEvent> {
+      yield* createOpenRouterStream(
+        params.model,
+        params.system,
+        params.messages,
+        params.tools,
+        params.max_tokens,
+        (this as any).apiKey,
+        params.signal
+      );
+    }.bind(this),
+  };
+}