@xortex/xcode 3.0.0

package/utils/configConstants.ts

@@ -0,0 +1,21 @@
+// These constants are in a separate file to avoid circular dependency issues.
+// Do NOT add imports to this file - it must remain dependency-free.
+
+export const NOTIFICATION_CHANNELS = [
+  'auto',
+  'iterm2',
+  'iterm2_with_bell',
+  'terminal_bell',
+  'kitty',
+  'ghostty',
+  'notifications_disabled',
+] as const
+
+// Valid editor modes (excludes deprecated 'emacs' which is auto-migrated to 'normal')
+export const EDITOR_MODES = ['normal', 'vim'] as const
+
+// Valid teammate modes for spawning
+// 'tmux' = traditional tmux-based teammates
+// 'in-process' = in-process teammates running in same process
+// 'auto' = automatically choose based on context (default)
+export const TEAMMATE_MODES = ['auto', 'tmux', 'in-process'] as const

package/utils/contentArray.ts

@@ -0,0 +1,51 @@
+/**
+ * Utility for inserting a block into a content array relative to tool_result
+ * blocks. Used by the API layer to position supplementary content (e.g.,
+ * cache editing directives) correctly within user messages.
+ *
+ * Placement rules:
+ * - If tool_result blocks exist: insert after the last one
+ * - Otherwise: insert before the last block
+ * - If the inserted block would be the final element, a text continuation
+ *   block is appended (some APIs require the prompt not to end with
+ *   non-text content)
+ */
+
+/**
+ * Inserts a block into the content array after the last tool_result block.
+ * Mutates the array in place.
+ *
+ * @param content - The content array to modify
+ * @param block - The block to insert
+ */
+export function insertBlockAfterToolResults(
+  content: unknown[],
+  block: unknown,
+): void {
+  // Find position after the last tool_result block
+  let lastToolResultIndex = -1
+  for (let i = 0; i < content.length; i++) {
+    const item = content[i]
+    if (
+      item &&
+      typeof item === 'object' &&
+      'type' in item &&
+      (item as { type: string }).type === 'tool_result'
+    ) {
+      lastToolResultIndex = i
+    }
+  }
+
+  if (lastToolResultIndex >= 0) {
+    const insertPos = lastToolResultIndex + 1
+    content.splice(insertPos, 0, block)
+    // Append a text continuation if the inserted block is now last
+    if (insertPos === content.length - 1) {
+      content.push({ type: 'text', text: '.' })
+    }
+  } else {
+    // No tool_result blocks — insert before the last block
+    const insertIndex = Math.max(0, content.length - 1)
+    content.splice(insertIndex, 0, block)
+  }
+}

package/utils/context.ts

@@ -0,0 +1,221 @@
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import { CONTEXT_1M_BETA_HEADER } from '../constants/betas.js'
+import { getGlobalConfig } from './config.js'
+import { isEnvTruthy } from './envUtils.js'
+import { getCanonicalName } from './model/model.js'
+import { getModelCapability } from './model/modelCapabilities.js'
+
+// Model context window size (200k tokens for all models right now)
+export const MODEL_CONTEXT_WINDOW_DEFAULT = 200_000
+
+// Maximum output tokens for compact operations
+export const COMPACT_MAX_OUTPUT_TOKENS = 20_000
+
+// Default max output tokens
+const MAX_OUTPUT_TOKENS_DEFAULT = 32_000
+const MAX_OUTPUT_TOKENS_UPPER_LIMIT = 64_000
+
+// Capped default for slot-reservation optimization. BQ p99 output = 4,911
+// tokens, so 32k/64k defaults over-reserve 8-16× slot capacity. With the cap
+// enabled, <1% of requests hit the limit; those get one clean retry at 64k
+// (see query.ts max_output_tokens_escalate). Cap is applied in
+// claude.ts:getMaxOutputTokensForModel to avoid the growthbook→betas→context
+// import cycle.
+export const CAPPED_DEFAULT_MAX_TOKENS = 8_000
+export const ESCALATED_MAX_TOKENS = 64_000
+
+/**
+ * Check if 1M context is disabled via environment variable.
+ * Used by C4E admins to disable 1M context for HIPAA compliance.
+ */
+export function is1mContextDisabled(): boolean {
+  return isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT)
+}
+
+export function has1mContext(model: string): boolean {
+  if (is1mContextDisabled()) {
+    return false
+  }
+  return /\[1m\]/i.test(model)
+}
+
+// @[MODEL LAUNCH]: Update this pattern if the new model supports 1M context
+export function modelSupports1M(model: string): boolean {
+  if (is1mContextDisabled()) {
+    return false
+  }
+  const canonical = getCanonicalName(model)
+  return canonical.includes('claude-sonnet-4') || canonical.includes('opus-4-6')
+}
+
+export function getContextWindowForModel(
+  model: string,
+  betas?: string[],
+): number {
+  // Allow override via environment variable (ant-only)
+  // This takes precedence over all other context window resolution, including 1M detection,
+  // so users can cap the effective context window for local decisions (auto-compact, etc.)
+  // while still using a 1M-capable endpoint.
+  if (
+    process.env.USER_TYPE === 'ant' &&
+    process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS
+  ) {
+    const override = parseInt(process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, 10)
+    if (!isNaN(override) && override > 0) {
+      return override
+    }
+  }
+
+  // [1m] suffix — explicit client-side opt-in, respected over all detection
+  if (has1mContext(model)) {
+    return 1_000_000
+  }
+
+  const cap = getModelCapability(model)
+  if (cap?.max_input_tokens && cap.max_input_tokens >= 100_000) {
+    if (
+      cap.max_input_tokens > MODEL_CONTEXT_WINDOW_DEFAULT &&
+      is1mContextDisabled()
+    ) {
+      return MODEL_CONTEXT_WINDOW_DEFAULT
+    }
+    return cap.max_input_tokens
+  }
+
+  if (betas?.includes(CONTEXT_1M_BETA_HEADER) && modelSupports1M(model)) {
+    return 1_000_000
+  }
+  if (getSonnet1mExpTreatmentEnabled(model)) {
+    return 1_000_000
+  }
+  if (process.env.USER_TYPE === 'ant') {
+    const antModel = resolveAntModel(model)
+    if (antModel?.contextWindow) {
+      return antModel.contextWindow
+    }
+  }
+  return MODEL_CONTEXT_WINDOW_DEFAULT
+}
+
+export function getSonnet1mExpTreatmentEnabled(model: string): boolean {
+  if (is1mContextDisabled()) {
+    return false
+  }
+  // Only applies to sonnet 4.6 without an explicit [1m] suffix
+  if (has1mContext(model)) {
+    return false
+  }
+  if (!getCanonicalName(model).includes('sonnet-4-6')) {
+    return false
+  }
+  return getGlobalConfig().clientDataCache?.['coral_reef_sonnet'] === 'true'
+}
+
+/**
+ * Calculate context window usage percentage from token usage data.
+ * Returns used and remaining percentages, or null values if no usage data.
+ */
+export function calculateContextPercentages(
+  currentUsage: {
+    input_tokens: number
+    cache_creation_input_tokens: number
+    cache_read_input_tokens: number
+  } | null,
+  contextWindowSize: number,
+): { used: number | null; remaining: number | null } {
+  if (!currentUsage) {
+    return { used: null, remaining: null }
+  }
+
+  const totalInputTokens =
+    currentUsage.input_tokens +
+    currentUsage.cache_creation_input_tokens +
+    currentUsage.cache_read_input_tokens
+
+  const usedPercentage = Math.round(
+    (totalInputTokens / contextWindowSize) * 100,
+  )
+  const clampedUsed = Math.min(100, Math.max(0, usedPercentage))
+
+  return {
+    used: clampedUsed,
+    remaining: 100 - clampedUsed,
+  }
+}
+
+/**
+ * Returns the model's default and upper limit for max output tokens.
+ */
+export function getModelMaxOutputTokens(model: string): {
+  default: number
+  upperLimit: number
+} {
+  let defaultTokens: number
+  let upperLimit: number
+
+  if (process.env.USER_TYPE === 'ant') {
+    const antModel = resolveAntModel(model.toLowerCase())
+    if (antModel) {
+      defaultTokens = antModel.defaultMaxTokens ?? MAX_OUTPUT_TOKENS_DEFAULT
+      upperLimit = antModel.upperMaxTokensLimit ?? MAX_OUTPUT_TOKENS_UPPER_LIMIT
+      return { default: defaultTokens, upperLimit }
+    }
+  }
+
+  const m = getCanonicalName(model)
+
+  if (m.includes('opus-4-6')) {
+    defaultTokens = 64_000
+    upperLimit = 128_000
+  } else if (m.includes('sonnet-4-6')) {
+    defaultTokens = 32_000
+    upperLimit = 128_000
+  } else if (
+    m.includes('opus-4-5') ||
+    m.includes('sonnet-4') ||
+    m.includes('haiku-4')
+  ) {
+    defaultTokens = 32_000
+    upperLimit = 64_000
+  } else if (m.includes('opus-4-1') || m.includes('opus-4')) {
+    defaultTokens = 32_000
+    upperLimit = 32_000
+  } else if (m.includes('claude-3-opus')) {
+    defaultTokens = 4_096
+    upperLimit = 4_096
+  } else if (m.includes('claude-3-sonnet')) {
+    defaultTokens = 8_192
+    upperLimit = 8_192
+  } else if (m.includes('claude-3-haiku')) {
+    defaultTokens = 4_096
+    upperLimit = 4_096
+  } else if (m.includes('3-5-sonnet') || m.includes('3-5-haiku')) {
+    defaultTokens = 8_192
+    upperLimit = 8_192
+  } else if (m.includes('3-7-sonnet')) {
+    defaultTokens = 32_000
+    upperLimit = 64_000
+  } else {
+    defaultTokens = MAX_OUTPUT_TOKENS_DEFAULT
+    upperLimit = MAX_OUTPUT_TOKENS_UPPER_LIMIT
+  }
+
+  const cap = getModelCapability(model)
+  if (cap?.max_tokens && cap.max_tokens >= 4_096) {
+    upperLimit = cap.max_tokens
+    defaultTokens = Math.min(defaultTokens, upperLimit)
+  }
+
+  return { default: defaultTokens, upperLimit }
+}
+
+/**
+ * Returns the max thinking budget tokens for a given model. The max
+ * thinking tokens should be strictly less than the max output tokens.
+ *
+ * Deprecated since newer models use adaptive thinking rather than a
+ * strict thinking token budget.
+ */
+export function getMaxThinkingTokensForModel(model: string): number {
+  return getModelMaxOutputTokens(model).upperLimit - 1
+}

package/utils/contextAnalysis.ts

@@ -0,0 +1,272 @@
+import type { BetaContentBlock } from '@anthropic-ai/sdk/resources/beta/messages/messages.mjs'
+import type {
+  ContentBlock,
+  ContentBlockParam,
+} from '@anthropic-ai/sdk/resources/index.mjs'
+import { roughTokenCountEstimation as countTokens } from '../services/tokenEstimation.js'
+import type {
+  AssistantMessage,
+  Message,
+  UserMessage,
+} from '../types/message.js'
+import { normalizeMessagesForAPI } from './messages.js'
+import { jsonStringify } from './slowOperations.js'
+
+type TokenStats = {
+  toolRequests: Map<string, number>
+  toolResults: Map<string, number>
+  humanMessages: number
+  assistantMessages: number
+  localCommandOutputs: number
+  other: number
+  attachments: Map<string, number>
+  duplicateFileReads: Map<string, { count: number; tokens: number }>
+  total: number
+}
+
+export function analyzeContext(messages: Message[]): TokenStats {
+  const stats: TokenStats = {
+    toolRequests: new Map(),
+    toolResults: new Map(),
+    humanMessages: 0,
+    assistantMessages: 0,
+    localCommandOutputs: 0,
+    other: 0,
+    attachments: new Map(),
+    duplicateFileReads: new Map(),
+    total: 0,
+  }
+
+  const toolIdsToToolNames = new Map<string, string>()
+  const readToolIdToFilePath = new Map<string, string>()
+  const fileReadStats = new Map<
+    string,
+    { count: number; totalTokens: number }
+  >()
+
+  messages.forEach(msg => {
+    if (msg.type === 'attachment') {
+      const type = msg.attachment.type || 'unknown'
+      stats.attachments.set(type, (stats.attachments.get(type) || 0) + 1)
+    }
+  })
+
+  const normalizedMessages = normalizeMessagesForAPI(messages)
+  normalizedMessages.forEach(msg => {
+    const { content } = msg.message
+
+    // Not sure if this path is still used, but adding as a fallback
+    if (typeof content === 'string') {
+      const tokens = countTokens(content)
+      stats.total += tokens
+      // Check if this is a local command output
+      if (msg.type === 'user' && content.includes('local-command-stdout')) {
+        stats.localCommandOutputs += tokens
+      } else {
+        stats[msg.type === 'user' ? 'humanMessages' : 'assistantMessages'] +=
+          tokens
+      }
+    } else {
+      content.forEach(block =>
+        processBlock(
+          block,
+          msg,
+          stats,
+          toolIdsToToolNames,
+          readToolIdToFilePath,
+          fileReadStats,
+        ),
+      )
+    }
+  })
+
+  // Calculate duplicate file reads
+  fileReadStats.forEach((data, path) => {
+    if (data.count > 1) {
+      const averageTokensPerRead = Math.floor(data.totalTokens / data.count)
+      const duplicateTokens = averageTokensPerRead * (data.count - 1)
+
+      stats.duplicateFileReads.set(path, {
+        count: data.count,
+        tokens: duplicateTokens,
+      })
+    }
+  })
+
+  return stats
+}
+
+function processBlock(
+  block: ContentBlockParam | ContentBlock | BetaContentBlock,
+  message: UserMessage | AssistantMessage,
+  stats: TokenStats,
+  toolIds: Map<string, string>,
+  readToolPaths: Map<string, string>,
+  fileReads: Map<string, { count: number; totalTokens: number }>,
+): void {
+  const tokens = countTokens(jsonStringify(block))
+  stats.total += tokens
+
+  switch (block.type) {
+    case 'text':
+      // Check if this is a local command output
+      if (
+        message.type === 'user' &&
+        'text' in block &&
+        block.text.includes('local-command-stdout')
+      ) {
+        stats.localCommandOutputs += tokens
+      } else {
+        stats[
+          message.type === 'user' ? 'humanMessages' : 'assistantMessages'
+        ] += tokens
+      }
+      break
+
+    case 'tool_use': {
+      if ('name' in block && 'id' in block) {
+        const toolName = block.name || 'unknown'
+        increment(stats.toolRequests, toolName, tokens)
+        toolIds.set(block.id, toolName)
+
+        // Track Read tool file paths
+        if (
+          toolName === 'Read' &&
+          'input' in block &&
+          block.input &&
+          typeof block.input === 'object' &&
+          'file_path' in block.input
+        ) {
+          const path = String(
+            (block.input as Record<string, unknown>).file_path,
+          )
+          readToolPaths.set(block.id, path)
+        }
+      }
+      break
+    }
+
+    case 'tool_result': {
+      if ('tool_use_id' in block) {
+        const toolName = toolIds.get(block.tool_use_id) || 'unknown'
+        increment(stats.toolResults, toolName, tokens)
+
+        // Track file read tokens
+        if (toolName === 'Read') {
+          const path = readToolPaths.get(block.tool_use_id)
+          if (path) {
+            const current = fileReads.get(path) || { count: 0, totalTokens: 0 }
+            fileReads.set(path, {
+              count: current.count + 1,
+              totalTokens: current.totalTokens + tokens,
+            })
+          }
+        }
+      }
+      break
+    }
+
+    case 'image':
+    case 'server_tool_use':
+    case 'web_search_tool_result':
+    case 'search_result':
+    case 'document':
+    case 'thinking':
+    case 'redacted_thinking':
+    case 'code_execution_tool_result':
+    case 'mcp_tool_use':
+    case 'mcp_tool_result':
+    case 'container_upload':
+    case 'web_fetch_tool_result':
+    case 'bash_code_execution_tool_result':
+    case 'text_editor_code_execution_tool_result':
+    case 'tool_search_tool_result':
+    case 'compaction':
+      // Don't care about these for now..
+      stats['other'] += tokens
+      break
+  }
+}
+
+function increment(map: Map<string, number>, key: string, value: number): void {
+  map.set(key, (map.get(key) || 0) + value)
+}
+
+export function tokenStatsToStatsigMetrics(
+  stats: TokenStats,
+): Record<string, number> {
+  const metrics: Record<string, number> = {
+    total_tokens: stats.total,
+    human_message_tokens: stats.humanMessages,
+    assistant_message_tokens: stats.assistantMessages,
+    local_command_output_tokens: stats.localCommandOutputs,
+    other_tokens: stats.other,
+  }
+
+  stats.attachments.forEach((count, type) => {
+    metrics[`attachment_${type}_count`] = count
+  })
+
+  stats.toolRequests.forEach((tokens, tool) => {
+    metrics[`tool_request_${tool}_tokens`] = tokens
+  })
+
+  stats.toolResults.forEach((tokens, tool) => {
+    metrics[`tool_result_${tool}_tokens`] = tokens
+  })
+
+  const duplicateTotal = [...stats.duplicateFileReads.values()].reduce(
+    (sum, d) => sum + d.tokens,
+    0,
+  )
+
+  metrics.duplicate_read_tokens = duplicateTotal
+  metrics.duplicate_read_file_count = stats.duplicateFileReads.size
+
+  if (stats.total > 0) {
+    metrics.human_message_percent = Math.round(
+      (stats.humanMessages / stats.total) * 100,
+    )
+    metrics.assistant_message_percent = Math.round(
+      (stats.assistantMessages / stats.total) * 100,
+    )
+    metrics.local_command_output_percent = Math.round(
+      (stats.localCommandOutputs / stats.total) * 100,
+    )
+    metrics.duplicate_read_percent = Math.round(
+      (duplicateTotal / stats.total) * 100,
+    )
+
+    const toolRequestTotal = [...stats.toolRequests.values()].reduce(
+      (sum, v) => sum + v,
+      0,
+    )
+    const toolResultTotal = [...stats.toolResults.values()].reduce(
+      (sum, v) => sum + v,
+      0,
+    )
+
+    metrics.tool_request_percent = Math.round(
+      (toolRequestTotal / stats.total) * 100,
+    )
+    metrics.tool_result_percent = Math.round(
+      (toolResultTotal / stats.total) * 100,
+    )
+
+    // Add individual tool request percentages
+    stats.toolRequests.forEach((tokens, tool) => {
+      metrics[`tool_request_${tool}_percent`] = Math.round(
+        (tokens / stats.total) * 100,
+      )
+    })
+
+    // Add individual tool result percentages
+    stats.toolResults.forEach((tokens, tool) => {
+      metrics[`tool_result_${tool}_percent`] = Math.round(
+        (tokens / stats.total) * 100,
+      )
+    })
+  }
+
+  return metrics
+}