@xortex/xcode 3.0.0

package/utils/shell/resolveDefaultShell.ts

@@ -0,0 +1,14 @@
+import { getInitialSettings } from '../settings/settings.js'
+
+/**
+ * Resolve the default shell for input-box `!` commands.
+ *
+ * Resolution order (docs/design/ps-shell-selection.md §4.2):
+ *   settings.defaultShell → 'bash'
+ *
+ * Platform default is 'bash' everywhere — we do NOT auto-flip Windows to
+ * PowerShell (would break existing Windows users with bash hooks).
+ */
+export function resolveDefaultShell(): 'bash' | 'powershell' {
+  return getInitialSettings().defaultShell ?? 'bash'
+}

package/utils/shell/shellProvider.ts

@@ -0,0 +1,33 @@
+export const SHELL_TYPES = ['bash', 'powershell'] as const
+export type ShellType = (typeof SHELL_TYPES)[number]
+export const DEFAULT_HOOK_SHELL: ShellType = 'bash'
+
+export type ShellProvider = {
+  type: ShellType
+  shellPath: string
+  detached: boolean
+
+  /**
+   * Build the full command string including all shell-specific setup.
+   * For bash: source snapshot, session env, disable extglob, eval-wrap, pwd tracking.
+   */
+  buildExecCommand(
+    command: string,
+    opts: {
+      id: number | string
+      sandboxTmpDir?: string
+      useSandbox: boolean
+    },
+  ): Promise<{ commandString: string; cwdFilePath: string }>
+
+  /**
+   * Shell args for spawn (e.g., ['-c', '-l', cmd] for bash).
+   */
+  getSpawnArgs(commandString: string): string[]
+
+  /**
+   * Extra env vars for this shell type.
+   * May perform async initialization (e.g., tmux socket setup for bash).
+   */
+  getEnvironmentOverrides(command: string): Promise<Record<string, string>>
+}

package/utils/shell/shellToolUtils.ts

@@ -0,0 +1,22 @@
+import { BASH_TOOL_NAME } from '../../tools/BashTool/toolName.js'
+import { POWERSHELL_TOOL_NAME } from '../../tools/PowerShellTool/toolName.js'
+import { isEnvDefinedFalsy, isEnvTruthy } from '../envUtils.js'
+import { getPlatform } from '../platform.js'
+
+export const SHELL_TOOL_NAMES: string[] = [BASH_TOOL_NAME, POWERSHELL_TOOL_NAME]
+
+/**
+ * Runtime gate for PowerShellTool. Windows-only (the permission engine uses
+ * Win32-specific path normalizations). Ant defaults on (opt-out via env=0);
+ * external defaults off (opt-in via env=1).
+ *
+ * Used by tools.ts (tool-list visibility), processBashCommand (! routing),
+ * and promptShellExecution (skill frontmatter routing) so the gate is
+ * consistent across all paths that invoke PowerShellTool.call().
+ */
+export function isPowerShellToolEnabled(): boolean {
+  if (getPlatform() !== 'windows') return false
+  return process.env.USER_TYPE === 'ant'
+    ? !isEnvDefinedFalsy(process.env.CLAUDE_CODE_USE_POWERSHELL_TOOL)
+    : isEnvTruthy(process.env.CLAUDE_CODE_USE_POWERSHELL_TOOL)
+}

package/utils/shell/specPrefix.ts

@@ -0,0 +1,241 @@
+/**
+ * Fig-spec-driven command prefix extraction.
+ *
+ * Given a command name + args array + its @withfig/autocomplete spec, walks
+ * the spec to find how deep into the args a meaningful prefix extends.
+ * `git -C /repo status --short` → `git status` (spec says -C takes a value,
+ * skip it, find `status` as a known subcommand).
+ *
+ * Pure over (string, string[], CommandSpec) — no parser dependency. Extracted
+ * from src/utils/bash/prefix.ts so PowerShell's extractor can reuse it;
+ * external CLIs (git, npm, kubectl) are shell-agnostic.
+ */
+
+import type { CommandSpec } from '../bash/registry.js'
+
+const URL_PROTOCOLS = ['http://', 'https://', 'ftp://']
+
+// Overrides for commands whose fig specs aren't available at runtime
+// (dynamic imports don't work in native/node builds). Without these,
+// calculateDepth falls back to 2, producing overly broad prefixes.
+export const DEPTH_RULES: Record<string, number> = {
+  rg: 2, // pattern argument is required despite variadic paths
+  'pre-commit': 2,
+  // CLI tools with deep subcommand trees (e.g. gcloud scheduler jobs list)
+  gcloud: 4,
+  'gcloud compute': 6,
+  'gcloud beta': 6,
+  aws: 4,
+  az: 4,
+  kubectl: 3,
+  docker: 3,
+  dotnet: 3,
+  'git push': 2,
+}
+
+const toArray = <T>(val: T | T[]): T[] => (Array.isArray(val) ? val : [val])
+
+// Check if an argument matches a known subcommand (case-insensitive: PS
+// callers pass original-cased args; fig spec names are lowercase)
+function isKnownSubcommand(arg: string, spec: CommandSpec | null): boolean {
+  if (!spec?.subcommands?.length) return false
+  const argLower = arg.toLowerCase()
+  return spec.subcommands.some(sub =>
+    Array.isArray(sub.name)
+      ? sub.name.some(n => n.toLowerCase() === argLower)
+      : sub.name.toLowerCase() === argLower,
+  )
+}
+
+// Check if a flag takes an argument based on spec, or use heuristic
+function flagTakesArg(
+  flag: string,
+  nextArg: string | undefined,
+  spec: CommandSpec | null,
+): boolean {
+  // Check if flag is in spec.options
+  if (spec?.options) {
+    const option = spec.options.find(opt =>
+      Array.isArray(opt.name) ? opt.name.includes(flag) : opt.name === flag,
+    )
+    if (option) return !!option.args
+  }
+  // Heuristic: if next arg isn't a flag and isn't a known subcommand, assume it's a flag value
+  if (spec?.subcommands?.length && nextArg && !nextArg.startsWith('-')) {
+    return !isKnownSubcommand(nextArg, spec)
+  }
+  return false
+}
+
+// Find the first subcommand by skipping flags and their values
+function findFirstSubcommand(
+  args: string[],
+  spec: CommandSpec | null,
+): string | undefined {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (!arg) continue
+    if (arg.startsWith('-')) {
+      if (flagTakesArg(arg, args[i + 1], spec)) i++
+      continue
+    }
+    if (!spec?.subcommands?.length) return arg
+    if (isKnownSubcommand(arg, spec)) return arg
+  }
+  return undefined
+}
+
+export async function buildPrefix(
+  command: string,
+  args: string[],
+  spec: CommandSpec | null,
+): Promise<string> {
+  const maxDepth = await calculateDepth(command, args, spec)
+  const parts = [command]
+  const hasSubcommands = !!spec?.subcommands?.length
+  let foundSubcommand = false
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (!arg || parts.length >= maxDepth) break
+
+    if (arg.startsWith('-')) {
+      // Special case: python -c should stop after -c
+      if (arg === '-c' && ['python', 'python3'].includes(command.toLowerCase()))
+        break
+
+      // Check for isCommand/isModule flags that should be included in prefix
+      if (spec?.options) {
+        const option = spec.options.find(opt =>
+          Array.isArray(opt.name) ? opt.name.includes(arg) : opt.name === arg,
+        )
+        if (
+          option?.args &&
+          toArray(option.args).some(a => a?.isCommand || a?.isModule)
+        ) {
+          parts.push(arg)
+          continue
+        }
+      }
+
+      // For commands with subcommands, skip global flags to find the subcommand
+      if (hasSubcommands && !foundSubcommand) {
+        if (flagTakesArg(arg, args[i + 1], spec)) i++
+        continue
+      }
+      break // Stop at flags (original behavior)
+    }
+
+    if (await shouldStopAtArg(arg, args.slice(0, i), spec)) break
+    if (hasSubcommands && !foundSubcommand) {
+      foundSubcommand = isKnownSubcommand(arg, spec)
+    }
+    parts.push(arg)
+  }
+
+  return parts.join(' ')
+}
+
+async function calculateDepth(
+  command: string,
+  args: string[],
+  spec: CommandSpec | null,
+): Promise<number> {
+  // Find first subcommand by skipping flags and their values
+  const firstSubcommand = findFirstSubcommand(args, spec)
+  const commandLower = command.toLowerCase()
+  const key = firstSubcommand
+    ? `${commandLower} ${firstSubcommand.toLowerCase()}`
+    : commandLower
+  if (DEPTH_RULES[key]) return DEPTH_RULES[key]
+  if (DEPTH_RULES[commandLower]) return DEPTH_RULES[commandLower]
+  if (!spec) return 2
+
+  if (spec.options && args.some(arg => arg?.startsWith('-'))) {
+    for (const arg of args) {
+      if (!arg?.startsWith('-')) continue
+      const option = spec.options.find(opt =>
+        Array.isArray(opt.name) ? opt.name.includes(arg) : opt.name === arg,
+      )
+      if (
+        option?.args &&
+        toArray(option.args).some(arg => arg?.isCommand || arg?.isModule)
+      )
+        return 3
+    }
+  }
+
+  // Find subcommand spec using the already-found firstSubcommand
+  if (firstSubcommand && spec.subcommands?.length) {
+    const firstSubLower = firstSubcommand.toLowerCase()
+    const subcommand = spec.subcommands.find(sub =>
+      Array.isArray(sub.name)
+        ? sub.name.some(n => n.toLowerCase() === firstSubLower)
+        : sub.name.toLowerCase() === firstSubLower,
+    )
+    if (subcommand) {
+      if (subcommand.args) {
+        const subArgs = toArray(subcommand.args)
+        if (subArgs.some(arg => arg?.isCommand)) return 3
+        if (subArgs.some(arg => arg?.isVariadic)) return 2
+      }
+      if (subcommand.subcommands?.length) return 4
+      // Leaf subcommand with NO args declared (git show, git log, git tag):
+      // the 3rd word is transient (SHA, ref, tag name) → dead over-specific
+      // rule like PowerShell(git show 81210f8:*). NOT the isOptional case —
+      // `git fetch` declares optional remote/branch and `git fetch origin`
+      // is tested (bash/prefix.test.ts:912) as intentional remote scoping.
+      if (!subcommand.args) return 2
+      return 3
+    }
+  }
+
+  if (spec.args) {
+    const argsArray = toArray(spec.args)
+
+    if (argsArray.some(arg => arg?.isCommand)) {
+      return !Array.isArray(spec.args) && spec.args.isCommand
+        ? 2
+        : Math.min(2 + argsArray.findIndex(arg => arg?.isCommand), 3)
+    }
+
+    if (!spec.subcommands?.length) {
+      if (argsArray.some(arg => arg?.isVariadic)) return 1
+      if (argsArray[0] && !argsArray[0].isOptional) return 2
+    }
+  }
+
+  return spec.args && toArray(spec.args).some(arg => arg?.isDangerous) ? 3 : 2
+}
+
+async function shouldStopAtArg(
+  arg: string,
+  args: string[],
+  spec: CommandSpec | null,
+): Promise<boolean> {
+  if (arg.startsWith('-')) return true
+
+  const dotIndex = arg.lastIndexOf('.')
+  const hasExtension =
+    dotIndex > 0 &&
+    dotIndex < arg.length - 1 &&
+    !arg.substring(dotIndex + 1).includes(':')
+
+  const hasFile = arg.includes('/') || hasExtension
+  const hasUrl = URL_PROTOCOLS.some(proto => arg.startsWith(proto))
+
+  if (!hasFile && !hasUrl) return false
+
+  // Check if we're after a -m flag for python modules
+  if (spec?.options && args.length > 0 && args[args.length - 1] === '-m') {
+    const option = spec.options.find(opt =>
+      Array.isArray(opt.name) ? opt.name.includes('-m') : opt.name === '-m',
+    )
+    if (option?.args && toArray(option.args).some(arg => arg?.isModule)) {
+      return false // Don't stop at module names
+    }
+  }
+
+  // For actual files/URLs, always stop regardless of context
+  return true
+}

package/utils/shellConfig.ts

@@ -0,0 +1,167 @@
+/**
+ * Utilities for managing shell configuration files (like .bashrc, .zshrc)
+ * Used for managing claude aliases and PATH entries
+ */
+
+import { open, readFile, stat } from 'fs/promises'
+import { homedir as osHomedir } from 'os'
+import { join } from 'path'
+import { isFsInaccessible } from './errors.js'
+import { getLocalClaudePath } from './localInstaller.js'
+
+export const CLAUDE_ALIAS_REGEX = /^\s*alias\s+claude\s*=/
+
+type EnvLike = Record<string, string | undefined>
+
+type ShellConfigOptions = {
+  env?: EnvLike
+  homedir?: string
+}
+
+/**
+ * Get the paths to shell configuration files
+ * Respects ZDOTDIR for zsh users
+ * @param options Optional overrides for testing (env, homedir)
+ */
+export function getShellConfigPaths(
+  options?: ShellConfigOptions,
+): Record<string, string> {
+  const home = options?.homedir ?? osHomedir()
+  const env = options?.env ?? process.env
+  const zshConfigDir = env.ZDOTDIR || home
+  return {
+    zsh: join(zshConfigDir, '.zshrc'),
+    bash: join(home, '.bashrc'),
+    fish: join(home, '.config/fish/config.fish'),
+  }
+}
+
+/**
+ * Filter out installer-created claude aliases from an array of lines
+ * Only removes aliases pointing to $HOME/.claude/local/claude
+ * Preserves custom user aliases that point to other locations
+ * Returns the filtered lines and whether our default installer alias was found
+ */
+export function filterClaudeAliases(lines: string[]): {
+  filtered: string[]
+  hadAlias: boolean
+} {
+  let hadAlias = false
+  const filtered = lines.filter(line => {
+    // Check if this is a claude alias
+    if (CLAUDE_ALIAS_REGEX.test(line)) {
+      // Extract the alias target - handle spaces, quotes, and various formats
+      // First try with quotes
+      let match = line.match(/alias\s+claude\s*=\s*["']([^"']+)["']/)
+      if (!match) {
+        // Try without quotes (capturing until end of line or comment)
+        match = line.match(/alias\s+claude\s*=\s*([^#\n]+)/)
+      }
+
+      if (match && match[1]) {
+        const target = match[1].trim()
+        // Only remove if it points to the installer location
+        // The installer always creates aliases with the full expanded path
+        if (target === getLocalClaudePath()) {
+          hadAlias = true
+          return false // Remove this line
+        }
+      }
+      // Keep custom aliases that don't point to the installer location
+    }
+    return true
+  })
+  return { filtered, hadAlias }
+}
+
+/**
+ * Read a file and split it into lines
+ * Returns null if file doesn't exist or can't be read
+ */
+export async function readFileLines(
+  filePath: string,
+): Promise<string[] | null> {
+  try {
+    const content = await readFile(filePath, { encoding: 'utf8' })
+    return content.split('\n')
+  } catch (e: unknown) {
+    if (isFsInaccessible(e)) return null
+    throw e
+  }
+}
+
+/**
+ * Write lines back to a file
+ */
+export async function writeFileLines(
+  filePath: string,
+  lines: string[],
+): Promise<void> {
+  const fh = await open(filePath, 'w')
+  try {
+    await fh.writeFile(lines.join('\n'), { encoding: 'utf8' })
+    await fh.datasync()
+  } finally {
+    await fh.close()
+  }
+}
+
+/**
+ * Check if a claude alias exists in any shell config file
+ * Returns the alias target if found, null otherwise
+ * @param options Optional overrides for testing (env, homedir)
+ */
+export async function findClaudeAlias(
+  options?: ShellConfigOptions,
+): Promise<string | null> {
+  const configs = getShellConfigPaths(options)
+
+  for (const configPath of Object.values(configs)) {
+    const lines = await readFileLines(configPath)
+    if (!lines) continue
+
+    for (const line of lines) {
+      if (CLAUDE_ALIAS_REGEX.test(line)) {
+        // Extract the alias target
+        const match = line.match(/alias\s+claude=["']?([^"'\s]+)/)
+        if (match && match[1]) {
+          return match[1]
+        }
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Check if a claude alias exists and points to a valid executable
+ * Returns the alias target if valid, null otherwise
+ * @param options Optional overrides for testing (env, homedir)
+ */
+export async function findValidClaudeAlias(
+  options?: ShellConfigOptions,
+): Promise<string | null> {
+  const aliasTarget = await findClaudeAlias(options)
+  if (!aliasTarget) return null
+
+  const home = options?.homedir ?? osHomedir()
+
+  // Expand ~ to home directory
+  const expandedPath = aliasTarget.startsWith('~')
+    ? aliasTarget.replace('~', home)
+    : aliasTarget
+
+  // Check if the target exists and is executable
+  try {
+    const stats = await stat(expandedPath)
+    // Check if it's a file (could be executable or symlink)
+    if (stats.isFile() || stats.isSymbolicLink()) {
+      return aliasTarget
+    }
+  } catch {
+    // Target doesn't exist or can't be accessed
+  }
+
+  return null
+}

package/utils/sideQuery.ts

@@ -0,0 +1,222 @@
+import type Anthropic from '@anthropic-ai/sdk'
+import type { BetaToolUnion } from '@anthropic-ai/sdk/resources/beta/messages.js'
+import {
+  getLastApiCompletionTimestamp,
+  setLastApiCompletionTimestamp,
+} from '../bootstrap/state.js'
+import { STRUCTURED_OUTPUTS_BETA_HEADER } from '../constants/betas.js'
+import type { QuerySource } from '../constants/querySource.js'
+import {
+  getAttributionHeader,
+  getCLISyspromptPrefix,
+} from '../constants/system.js'
+import { logEvent } from '../services/analytics/index.js'
+import type { AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS } from '../services/analytics/metadata.js'
+import { getAPIMetadata } from '../services/api/gemini.js'
+import { getAnthropicClient } from '../services/api/client.js'
+import { getModelBetas, modelSupportsStructuredOutputs } from './betas.js'
+import { computeFingerprint } from './fingerprint.js'
+import { normalizeModelStringForAPI } from './model/model.js'
+
+type MessageParam = Anthropic.MessageParam
+type TextBlockParam = Anthropic.TextBlockParam
+type Tool = Anthropic.Tool
+type ToolChoice = Anthropic.ToolChoice
+type BetaMessage = Anthropic.Beta.Messages.BetaMessage
+type BetaJSONOutputFormat = Anthropic.Beta.Messages.BetaJSONOutputFormat
+type BetaThinkingConfigParam = Anthropic.Beta.Messages.BetaThinkingConfigParam
+
+export type SideQueryOptions = {
+  /** Model to use for the query */
+  model: string
+  /**
+   * System prompt - string or array of text blocks (will be prefixed with CLI attribution).
+   *
+   * The attribution header is always placed in its own TextBlockParam block to ensure
+   * server-side parsing correctly extracts the cc_entrypoint value without including
+   * system prompt content.
+   */
+  system?: string | TextBlockParam[]
+  /** Messages to send (supports cache_control on content blocks) */
+  messages: MessageParam[]
+  /** Optional tools (supports both standard Tool[] and BetaToolUnion[] for custom tool types) */
+  tools?: Tool[] | BetaToolUnion[]
+  /** Optional tool choice (use { type: 'tool', name: 'x' } for forced output) */
+  tool_choice?: ToolChoice
+  /** Optional JSON output format for structured responses */
+  output_format?: BetaJSONOutputFormat
+  /** Max tokens (default: 1024) */
+  max_tokens?: number
+  /** Max retries (default: 2) */
+  maxRetries?: number
+  /** Abort signal */
+  signal?: AbortSignal
+  /** Skip CLI system prompt prefix (keeps attribution header for OAuth). For internal classifiers that provide their own prompt. */
+  skipSystemPromptPrefix?: boolean
+  /** Temperature override */
+  temperature?: number
+  /** Thinking budget (enables thinking), or `false` to send `{ type: 'disabled' }`. */
+  thinking?: number | false
+  /** Stop sequences — generation stops when any of these strings is emitted */
+  stop_sequences?: string[]
+  /** Attributes this call in tengu_api_success for COGS joining against reporting.sampling_calls. */
+  querySource: QuerySource
+}
+
+/**
+ * Extract text from first user message for fingerprint computation.
+ */
+function extractFirstUserMessageText(messages: MessageParam[]): string {
+  const firstUserMessage = messages.find(m => m.role === 'user')
+  if (!firstUserMessage) return ''
+
+  const content = firstUserMessage.content
+  if (typeof content === 'string') return content
+
+  // Array of content blocks - find first text block
+  const textBlock = content.find(block => block.type === 'text')
+  return textBlock?.type === 'text' ? textBlock.text : ''
+}
+
+/**
+ * Lightweight API wrapper for "side queries" outside the main conversation loop.
+ *
+ * Use this instead of direct client.beta.messages.create() calls to ensure
+ * proper OAuth token validation with fingerprint attribution headers.
+ *
+ * This handles:
+ * - Fingerprint computation for OAuth validation
+ * - Attribution header injection
+ * - CLI system prompt prefix
+ * - Proper betas for the model
+ * - API metadata
+ * - Model string normalization (strips [1m] suffix for API)
+ *
+ * @example
+ * // Permission explainer
+ * await sideQuery({ querySource: 'permission_explainer', model, system: SYSTEM_PROMPT, messages, tools, tool_choice })
+ *
+ * @example
+ * // Session search
+ * await sideQuery({ querySource: 'session_search', model, system: SEARCH_PROMPT, messages })
+ *
+ * @example
+ * // Model validation
+ * await sideQuery({ querySource: 'model_validation', model, max_tokens: 1, messages: [{ role: 'user', content: 'Hi' }] })
+ */
+export async function sideQuery(opts: SideQueryOptions): Promise<BetaMessage> {
+  const {
+    model,
+    system,
+    messages,
+    tools,
+    tool_choice,
+    output_format,
+    max_tokens = 1024,
+    maxRetries = 2,
+    signal,
+    skipSystemPromptPrefix,
+    temperature,
+    thinking,
+    stop_sequences,
+  } = opts
+
+  const client = await getAnthropicClient({
+    maxRetries,
+    model,
+    source: 'side_query',
+  })
+  const betas = [...getModelBetas(model)]
+  // Add structured-outputs beta if using output_format and provider supports it
+  if (
+    output_format &&
+    modelSupportsStructuredOutputs(model) &&
+    !betas.includes(STRUCTURED_OUTPUTS_BETA_HEADER)
+  ) {
+    betas.push(STRUCTURED_OUTPUTS_BETA_HEADER)
+  }
+
+  // Extract first user message text for fingerprint
+  const messageText = extractFirstUserMessageText(messages)
+
+  // Compute fingerprint for OAuth attribution
+  const fingerprint = computeFingerprint(messageText, MACRO.VERSION)
+  const attributionHeader = getAttributionHeader(fingerprint)
+
+  // Build system as array to keep attribution header in its own block
+  // (prevents server-side parsing from including system content in cc_entrypoint)
+  const systemBlocks: TextBlockParam[] = [
+    attributionHeader ? { type: 'text', text: attributionHeader } : null,
+    // Skip CLI system prompt prefix for internal classifiers that provide their own prompt
+    ...(skipSystemPromptPrefix
+      ? []
+      : [
+          {
+            type: 'text' as const,
+            text: getCLISyspromptPrefix({
+              isNonInteractive: false,
+              hasAppendSystemPrompt: false,
+            }),
+          },
+        ]),
+    ...(Array.isArray(system)
+      ? system
+      : system
+        ? [{ type: 'text' as const, text: system }]
+        : []),
+  ].filter((block): block is TextBlockParam => block !== null)
+
+  let thinkingConfig: BetaThinkingConfigParam | undefined
+  if (thinking === false) {
+    thinkingConfig = { type: 'disabled' }
+  } else if (thinking !== undefined) {
+    thinkingConfig = {
+      type: 'enabled',
+      budget_tokens: Math.min(thinking, max_tokens - 1),
+    }
+  }
+
+  const normalizedModel = normalizeModelStringForAPI(model)
+  const start = Date.now()
+  // biome-ignore lint/plugin: this IS the wrapper that handles OAuth attribution
+  const response = await client.beta.messages.create(
+    {
+      model: normalizedModel,
+      max_tokens,
+      system: systemBlocks,
+      messages,
+      ...(tools && { tools }),
+      ...(tool_choice && { tool_choice }),
+      ...(output_format && { output_config: { format: output_format } }),
+      ...(temperature !== undefined && { temperature }),
+      ...(stop_sequences && { stop_sequences }),
+      ...(thinkingConfig && { thinking: thinkingConfig }),
+      ...(betas.length > 0 && { betas }),
+      metadata: getAPIMetadata(),
+    },
+    { signal },
+  )
+
+  const requestId =
+    (response as { _request_id?: string | null })._request_id ?? undefined
+  const now = Date.now()
+  const lastCompletion = getLastApiCompletionTimestamp()
+  logEvent('tengu_api_success', {
+    requestId:
+      requestId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    querySource:
+      opts.querySource as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    model:
+      normalizedModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    inputTokens: response.usage.input_tokens,
+    outputTokens: response.usage.output_tokens,
+    cachedInputTokens: response.usage.cache_read_input_tokens ?? 0,
+    uncachedInputTokens: response.usage.cache_creation_input_tokens ?? 0,
+    durationMsIncludingRetries: now - start,
+    timeSinceLastApiCallMs:
+      lastCompletion !== null ? now - lastCompletion : undefined,
+  })
+  setLastApiCompletionTimestamp(now)
+
+  return response
+}