@threadcrumbs/common 0.0.0-stage → 0.1.1

package/launch/terminal.mjs

@@ -0,0 +1,213 @@
+/**
+ * Put a command in a new terminal window.
+ *
+ * Only `present()` in `index.mjs` uses this, and Windows is handed to `win-terminal.mjs` first.
+ * It is a separate file because it is terminal-emulator detail with nothing to do with HTTP, and
+ * nothing in here knows about a particular harness. An adapter never imports it: an adapter hands
+ * the app an argv, and the app decides whether a terminal is the right place for it.
+ */
+import { spawn } from 'node:child_process'
+import fsp from 'node:fs/promises'
+import path from 'node:path'
+import { findExecutable } from '../lib/fsutil.mjs'
+import { openInTerminalWindows } from './win-terminal.mjs'
+
+/**
+ * How each terminal takes "run this command in this directory". The command comes after the
+ * terminal's own end-of-options marker where it has one, so nothing in it is read as a flag. The
+ * working directory is also set on the spawn itself, which is all the xterm family needs and what
+ * the D-Bus terminals forward to their server anyway.
+ *
+ * Only terminals whose flags are documented are listed. `tilix` is left out on purpose: its `-e`
+ * takes one string that it splits again itself, which would mean building a shell string.
+ */
+const TERMINALS = {
+  'gnome-terminal': (dir, cmd) => [`--working-directory=${dir}`, '--', ...cmd],
+  kgx: (dir, cmd) => [`--working-directory=${dir}`, '--', ...cmd],
+  ptyxis: (dir, cmd) => [`--working-directory=${dir}`, '--', ...cmd],
+  konsole: (dir, cmd) => ['--workdir', dir, '-e', ...cmd],
+  'xfce4-terminal': (dir, cmd) => [`--working-directory=${dir}`, '-x', ...cmd],
+  'mate-terminal': (dir, cmd) => [`--working-directory=${dir}`, '-x', ...cmd],
+  kitty: (dir, cmd) => [`--directory=${dir}`, ...cmd],
+  alacritty: (dir, cmd) => ['--working-directory', dir, '-e', ...cmd],
+  ghostty: (dir, cmd) => [`--working-directory=${dir}`, '-e', ...cmd],
+  wezterm: (dir, cmd) => ['start', '--cwd', dir, '--', ...cmd],
+  foot: (dir, cmd) => [`--working-directory=${dir}`, ...cmd],
+  terminator: (dir, cmd) => [`--working-directory=${dir}`, '-x', ...cmd],
+  xterm: (_dir, cmd) => ['-e', ...cmd],
+  uxterm: (_dir, cmd) => ['-e', ...cmd],
+  urxvt: (_dir, cmd) => ['-e', ...cmd],
+  rxvt: (_dir, cmd) => ['-e', ...cmd],
+  st: (_dir, cmd) => ['-e', ...cmd],
+}
+
+const GENERAL_ORDER = [
+  'gnome-terminal', 'konsole', 'xfce4-terminal', 'mate-terminal', 'kitty', 'alacritty', 'ghostty',
+  'wezterm', 'foot', 'terminator', 'ptyxis', 'kgx', 'xterm', 'uxterm', 'urxvt', 'rxvt', 'st',
+]
+
+/**
+ * The terminal that ships with the desktop comes first. `XDG_CURRENT_DESKTOP` is a colon list,
+ * such as `ubuntu:GNOME`, and GNOME gets the three terminals it has shipped over the years, in the
+ * order they are most likely to be the one configured.
+ */
+function desktopOrder() {
+  const parts = (process.env.XDG_CURRENT_DESKTOP || '').toLowerCase().split(':')
+  if (parts.includes('kde')) return ['konsole']
+  if (parts.includes('xfce')) return ['xfce4-terminal']
+  if (parts.includes('mate')) return ['mate-terminal']
+  if (parts.some((p) => ['gnome', 'ubuntu', 'unity', 'cinnamon', 'x-cinnamon'].includes(p))) {
+    return ['gnome-terminal', 'kgx', 'ptyxis']
+  }
+  return []
+}
+
+/**
+ * Is there a display for a window to appear on? Only the plainly headless case is refused here,
+ * so that it gets a message saying so. Anything less clear is left to the launch itself, whose
+ * exit code is the real answer. Wayland clients find their socket without the variable being set,
+ * so the runtime directory is checked too.
+ */
+async function hasDisplay() {
+  if (process.env.DISPLAY || process.env.WAYLAND_DISPLAY) return true
+  const run = process.env.XDG_RUNTIME_DIR
+  if (!run) return false
+  try {
+    return (await fsp.readdir(run)).some((name) => name.startsWith('wayland-'))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * A terminal that refuses does so at once, well under 50 ms on a GNOME desktop, while a window
+ * takes longer than this to come up. A refusal slower than this is reported as a success on
+ * purpose: treating every late non-zero exit as a failure would open a second terminal whenever
+ * the command inside the first one ended quickly.
+ */
+const REFUSAL_MS = 300
+/** After this long, a foreground terminal (xterm, Debian's `--wait` wrapper) is up. */
+const GRACE_MS = 1500
+/**
+ * A limit on the whole search. Each candidate can take `GRACE_MS`, and on a machine with several
+ * terminals installed and a broken display, each one can fail only after that long. Without a
+ * limit the request would wait for the sum of them while the page shows a spinner, so the search
+ * stops at this limit and reports the failure.
+ */
+const WALK_BUDGET_MS = 4000
+
+/**
+ * Spawn a terminal and report whether it came up. The D-Bus terminals hand the window to a
+ * service and exit 0 at once. When they cannot (no display, a flag they reject) they exit non-zero
+ * just as fast, and that failure is reported instead of a message that says "opened". A non-zero
+ * exit that arrives later is different: the window came up and the command inside it has ended,
+ * which is for the user to see and no reason to open a second terminal.
+ */
+function trySpawn(cmd, args, cwd) {
+  return new Promise((resolve) => {
+    let child
+    try {
+      child = spawn(cmd, args, { cwd, stdio: 'ignore', detached: true })
+    } catch (err) {
+      resolve({ ok: false, error: err?.message || String(err) })
+      return
+    }
+    const startedAt = Date.now()
+    let timer = null
+    let settled = false
+    const done = (result) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(result)
+    }
+    child.on('error', (err) => done({ ok: false, error: err?.message || String(err) }))
+    child.on('exit', (code, signal) => {
+      if (code === 0 || Date.now() - startedAt >= REFUSAL_MS) return done({ ok: true })
+      const how = signal ? `signal ${signal}` : `code ${code}`
+      done({ ok: false, error: `${path.basename(cmd)} exited with ${how}` })
+    })
+    timer = setTimeout(() => {
+      child.unref()
+      done({ ok: true })
+    }, GRACE_MS)
+  })
+}
+
+/**
+ * Run `argv` in a new terminal window with `cwd` as its working directory.
+ *
+ * The caller has already resolved both: `argv[0]` is an absolute executable and `cwd` an
+ * existing directory. The terminal is chosen in this order: `THREADCRUMBS_TERMINAL` (or the older
+ * `THREADNAUTS_TERMINAL`) if set, then `$TERMINAL`, then the desktop's own, then whatever is
+ * installed, then Debian's `x-terminal-emulator` alternative. That last one is tried by name and
+ * given `-e`, the one form Debian policy guarantees, because on Ubuntu it is a wrapper script that
+ * knows no other flags: given `--working-directory`, it opens an empty window. That is also why a
+ * real `gnome-terminal` is looked for first.
+ *
+ * A named terminal the table does not know is skipped rather than guessed at. `-e` means "the
+ * rest of the line" to xterm and "one string, which I will split" to tilix, and guessing wrong
+ * opens a window on the wrong command, which is worse than trying a terminal the table knows.
+ *
+ * On macOS the desktop order finds nothing, so only a named terminal works there. kitty,
+ * alacritty, ghostty, and wezterm take the same flags on both. Terminal.app and iTerm are not
+ * supported, because `open -a` cannot pass them an argv without a shell string in between.
+ */
+export async function openInTerminal(argv, cwd) {
+  // Windows shares none of the logic below (no PATH search over sixteen emulators, no display to
+  // check), so it is a separate file, called from here. The caller asks for a terminal and does
+  // not need to know the platform.
+  if (process.platform === 'win32') return openInTerminalWindows(argv, cwd)
+
+  const wellFormed = Array.isArray(argv) && argv.length > 0 && argv.every((a) => typeof a === 'string' && a)
+  if (!wellFormed || !path.isAbsolute(argv[0]) || typeof cwd !== 'string' || !path.isAbsolute(cwd)) {
+    return { ok: false, error: 'Invalid launch command' }
+  }
+  // A macOS session always has a window server; only Linux can be headless in a way worth naming.
+  if (process.platform === 'linux' && !(await hasDisplay())) {
+    return { ok: false, error: 'No graphical display to open a terminal on' }
+  }
+
+  const preferred = [
+    process.env.THREADCRUMBS_TERMINAL || process.env.THREADNAUTS_TERMINAL || '',
+    process.env.TERMINAL || '',
+    ...desktopOrder(),
+    ...GENERAL_ORDER,
+    'x-terminal-emulator',
+  ]
+  const names = [...new Set(preferred.filter(Boolean))]
+  const deadline = Date.now() + WALK_BUDGET_MS
+  const tried = new Set()
+  let lastError = ''
+  let ranOut = false
+
+  for (const name of names) {
+    if (Date.now() >= deadline) {
+      ranOut = true
+      break
+    }
+    const resolved = await findExecutable(name)
+    if (!resolved || tried.has(resolved)) continue
+    tried.add(resolved)
+
+    const base = path.basename(name)
+    let args
+    if (base === 'x-terminal-emulator') args = ['-e', ...argv]
+    else if (TERMINALS[base]) args = TERMINALS[base](cwd, argv)
+    else continue
+
+    const result = await trySpawn(resolved, args, cwd)
+    if (result.ok) return { ok: true }
+    lastError = result.error
+  }
+
+  if (ranOut) {
+    return { ok: false, error: 'Gave up waiting for a terminal to open. Is the display responding?' }
+  }
+  return {
+    ok: false,
+    error: lastError
+      ? `Could not open a terminal (${lastError})`
+      : 'No terminal emulator found. Set THREADCRUMBS_TERMINAL or $TERMINAL, or install one (gnome-terminal, kitty, xterm)',
+  }
+}

package/launch/win-terminal.mjs

@@ -0,0 +1,87 @@
+/**
+ * Windows: how to put a command in a terminal window.
+ *
+ * The counterpart of `openInTerminal` in `terminal.mjs`, and a separate file for the same reason:
+ * platform detail with nothing to do with HTTP, and nothing in it knows about a particular
+ * harness. An adapter hands the app an argv, and the app decides whether a terminal is the right
+ * place for it.
+ *
+ * Two terminals, tried in order. Windows Terminal is the better one: it takes the working
+ * directory as a flag and the command as trailing arguments, so nothing in the argv is read as a
+ * flag of its own. Plain `cmd.exe` is the fallback that every machine has.
+ */
+import { spawn } from 'node:child_process'
+import fsp from 'node:fs/promises'
+import path from 'node:path'
+import { findExecutable } from '../lib/fsutil.mjs'
+
+/**
+ * `start` is a cmd builtin rather than a program, so it cannot be spawned directly and has to be
+ * reached through `cmd /c`. `start` takes its first quoted argument as the new window's title,
+ * which is why the empty string is there: without it the first real argument disappears and the
+ * window opens on whatever the second one was.
+ *
+ * `/k` keeps the window open after the command exits. That is the point: you are meant to keep
+ * typing in it, and it also keeps a failure on screen instead of a window that closes before you
+ * can read the error.
+ */
+const TERMINALS = {
+  'wt.exe': (cwd, argv) => ['-d', cwd, ...argv],
+  'cmd.exe': (_cwd, argv) => ['/c', 'start', '', 'cmd.exe', '/k', ...argv],
+}
+
+const ORDER = ['wt.exe', 'cmd.exe']
+
+function trySpawn(bin, args, cwd) {
+  return new Promise((resolve) => {
+    let child
+    try {
+      // Detached and unref'd: the terminal has to outlive this request, and it must not keep the
+      // server running when you stop it.
+      child = spawn(bin, args, { cwd, detached: true, stdio: 'ignore', windowsHide: false })
+    } catch (err) {
+      return resolve({ ok: false, error: String(err && err.message ? err.message : err) })
+    }
+    // A spawn that is going to fail does so at once; one that lasts past this delay is running.
+    const settled = setTimeout(() => {
+      child.unref()
+      resolve({ ok: true })
+    }, 120)
+    child.once('error', (err) => {
+      clearTimeout(settled)
+      resolve({ ok: false, error: String(err && err.message ? err.message : err) })
+    })
+  })
+}
+
+/**
+ * Open `argv` in a terminal whose working directory is `cwd`.
+ *
+ * Both arguments are checked the same way `openInTerminal` checks them, and for the same reason:
+ * this function hands what it is given to the OS, so a relative path or an empty string is
+ * refused here rather than resolved against the directory the server is running in.
+ */
+export async function openInTerminalWindows(argv, cwd) {
+  const wellFormed = Array.isArray(argv) && argv.length > 0 && argv.every((a) => typeof a === 'string' && a)
+  if (!wellFormed || !path.isAbsolute(argv[0]) || typeof cwd !== 'string' || !path.isAbsolute(cwd)) {
+    return { ok: false, error: 'Invalid launch command' }
+  }
+  const usable = await fsp.stat(cwd).then((st) => st.isDirectory(), () => false)
+  if (!usable) return { ok: false, error: 'That folder is not a directory any more' }
+
+  let lastError = ''
+  for (const name of ORDER) {
+    const resolved = await findExecutable(name)
+    if (!resolved) continue
+    const result = await trySpawn(resolved, TERMINALS[name](cwd, argv), cwd)
+    if (result.ok) return { ok: true }
+    lastError = result.error
+  }
+
+  return {
+    ok: false,
+    error: lastError
+      ? `Could not open a terminal (${lastError})`
+      : 'No terminal found. Install Windows Terminal, or check that cmd.exe is on your PATH',
+  }
+}

package/launch/windows.mjs

@@ -0,0 +1,96 @@
+/**
+ * Windows desktop helper: bring the window that hosts a given process to the front.
+ *
+ * The counterpart of `xdg.mjs`, for the same reason: OS detail with nothing to do with HTTP, and
+ * nothing in here knows about a particular harness. An adapter hands the app a pid, and the app
+ * decides whether fronting its window is the right way to answer "open this".
+ *
+ * The pid itself has no window, because it is a CLI process. The window belongs to whatever
+ * terminal is hosting it, which is an ancestor: the shell's parent is Windows Terminal, VS Code,
+ * or an IDE. So the search goes up the parent chain until a process with a main window appears,
+ * and fronts that. The Claude desktop app is skipped on purpose: a process hosted by the app is
+ * the app's to present, and the deep link does that better than fronting a raw window.
+ */
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+
+/**
+ * Listing every process (`Get-CimInstance Win32_Process`) is the slow part, a second or two on
+ * a busy machine; the rest is instant. The limit covers that with room, because past it the
+ * caller falls back to the deep link, which is a worse answer than a fronted window but never
+ * hangs.
+ */
+const FOCUS_TIMEOUT_MS = 8000
+
+/** How many parents to visit before concluding nothing on the chain owns a window. */
+const MAX_HOPS = 16
+
+/**
+ * `SetForegroundWindow` alone is refused when the caller is a background process, because
+ * Windows only lets the process the user is interacting with take focus. A brief Alt keypress
+ * (0xA4, down then up) is the widely used exemption: a process that just sent input counts as
+ * interacting. Restoring first matters too: fronting a minimized window leaves it minimized and
+ * only marks it active in the taskbar.
+ */
+const script = (pid) => `
+$ErrorActionPreference = 'SilentlyContinue'
+$parent = @{}
+foreach ($p in Get-CimInstance Win32_Process) { $parent[[int]$p.ProcessId] = [int]$p.ParentProcessId }
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class WindowFocus {
+  [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr h);
+  [DllImport("user32.dll")] public static extern bool ShowWindowAsync(IntPtr h, int cmd);
+  [DllImport("user32.dll")] public static extern bool IsIconic(IntPtr h);
+  [DllImport("user32.dll")] public static extern void keybd_event(byte key, byte scan, uint flags, UIntPtr extra);
+}
+'@
+$cur = ${pid}
+for ($i = 0; $i -lt ${MAX_HOPS} -and $cur -gt 0; $i++) {
+  $proc = Get-Process -Id $cur
+  if ($proc -and $proc.MainWindowHandle -ne [IntPtr]::Zero) {
+    # The first ancestor with a window decides. The Claude app means the thread is the app's own,
+    # and its deep link presents it better; explorer is the root of the chain, and fronting a
+    # stray File Explorer window would be wrong. Either way, stop and let the caller fall back.
+    if ($proc.ProcessName -eq 'claude' -or $proc.ProcessName -eq 'explorer') { exit 1 }
+    $h = $proc.MainWindowHandle
+    if ([WindowFocus]::IsIconic($h)) { [WindowFocus]::ShowWindowAsync($h, 9) | Out-Null }
+    [WindowFocus]::keybd_event(0xA4, 0, 0, [UIntPtr]::Zero)
+    [WindowFocus]::keybd_event(0xA4, 0, 2, [UIntPtr]::Zero)
+    [WindowFocus]::SetForegroundWindow($h) | Out-Null
+    'focused'
+    exit 0
+  }
+  if (-not $parent.ContainsKey($cur)) { break }
+  $next = $parent[$cur]
+  if ($next -eq $cur) { break }
+  $cur = $next
+}
+exit 1
+`
+
+/**
+ * Front the window hosting `pid`. True only when a window was found and told to come forward.
+ * False covers everything else: another platform, a chain with no window on it (a detached
+ * process, or one hosted by the Claude desktop app), or PowerShell being unavailable. The caller
+ * treats false as "use the URL instead", so this function returns false rather than throwing.
+ */
+export async function focusWindowOfPid(pid) {
+  if (process.platform !== 'win32') return false
+  if (!Number.isInteger(pid) || pid <= 0) return false
+  try {
+    // -EncodedCommand avoids every quoting rule cmd and PowerShell disagree on.
+    const encoded = Buffer.from(script(pid), 'utf16le').toString('base64')
+    const { stdout } = await execFileAsync(
+      'powershell.exe',
+      ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded],
+      { timeout: FOCUS_TIMEOUT_MS, windowsHide: true },
+    )
+    return stdout.includes('focused')
+  } catch {
+    return false
+  }
+}

package/launch/xdg.mjs

@@ -0,0 +1,44 @@
+/**
+ * Linux desktop helper: does anything on this machine answer a URL scheme?
+ *
+ * Only `present()` in `index.mjs` uses this, and only on Linux. It is a separate file because it
+ * is desktop-environment detail with nothing to do with HTTP, and nothing in here knows about a
+ * particular harness. An adapter never imports it.
+ */
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+
+/** The scheme of a URL, or '' if it does not parse. */
+export function schemeOf(url) {
+  try {
+    return new URL(url).protocol.replace(/:$/, '')
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * Is a desktop app registered for this URL's scheme?
+ *
+ * `xdg-mime query default x-scheme-handler/<scheme>` is what `xdg-open` itself consults. It
+ * checks that a `mimeapps.list` entry still points at an installed .desktop file, which is the
+ * common stale case (an uninstalled app leaves its line behind), though its `mimeinfo.cache`
+ * fallback accepts an entry without checking, exactly as xdg-open would.
+ *
+ * Anything that stops the query counts as "no handler". The alternative is handing xdg-open a
+ * URL nothing answers, which fails silently and reaches the page as "Opened".
+ */
+export async function schemeHasHandler(url) {
+  const scheme = schemeOf(url)
+  if (!/^[a-z][a-z0-9+.-]*$/.test(scheme)) return false
+  try {
+    // Bounded: on KDE the query goes through the trader, which can wait on a D-Bus timeout.
+    const args = ['query', 'default', `x-scheme-handler/${scheme}`]
+    const { stdout } = await execFileAsync('xdg-mime', args, { timeout: 5000 })
+    return stdout.trim().length > 0
+  } catch {
+    return false
+  }
+}

package/lib/anthropic-prices.mjs

@@ -0,0 +1,70 @@
+export const PRICES_SOURCE = 'https://platform.claude.com/docs/en/about-claude/pricing'
+export const PRICES_AS_OF = '2026-10-30'
+
+const PER_TOKEN = 1e6
+const WEB_SEARCH_USD = 0.01
+const US_ONLY = 1.1
+
+const rates = (input, write5m, write1h, read, output, fast = null) => ({ input, write5m, write1h, read, output, fast })
+const OPUS_45 = rates(5, 6.25, 10, 0.5, 25)
+const OPUS_4 = rates(15, 18.75, 30, 1.5, 75)
+const SONNET_4 = rates(3, 3.75, 6, 0.3, 15)
+
+const PRICES = {
+  'fable-5.1': rates(10, 12.5, 20, 0.25, 50),
+  'mythos-5.1': rates(10, 12.5, 20, 0.25, 50),
+  'fable-5': rates(10, 12.5, 20, 1, 50),
+  'mythos-5': rates(10, 12.5, 20, 1, 50),
+  'opus-5.5': rates(4, 5, 8, 0.2, 20, { input: 8, output: 40 }),
+  'opus-5': rates(5, 6.25, 10, 0.5, 25, { input: 10, output: 50 }),
+  'opus-4.8': rates(5, 6.25, 10, 0.5, 25, { input: 10, output: 50 }),
+  'opus-4.7': OPUS_45,
+  'opus-4.6': OPUS_45,
+  'opus-4.5': OPUS_45,
+  'opus-4.1': OPUS_4,
+  'opus-4': OPUS_4,
+  'sonnet-5.5': rates(2, 2.5, 4, 0.1, 10),
+  'sonnet-5': rates(2, 2.5, 4, 0.2, 10),
+  'sonnet-4.6': SONNET_4,
+  'sonnet-4.5': SONNET_4,
+  'sonnet-4': SONNET_4,
+  'haiku-5.5': rates(0.1, 0.125, 0.2, 0.01, 0.5),
+  'haiku-4.5': rates(1, 1.25, 2, 0.1, 5),
+  'haiku-3.5': rates(0.8, 1, 1.6, 0.08, 4),
+}
+
+const LONG_PROMPT = { 'haiku-5.5': { over: 100_000, rates: rates(0.5, 0.625, 1, 0.05, 2.5) } }
+
+const count = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0)
+
+export function modelKey(model) {
+  const id = String(model || '').toLowerCase()
+  const at = id.indexOf('claude-')
+  if (at < 0) return ''
+  const name = id.slice(at)
+  const current = /^claude-(fable|mythos|opus|sonnet|haiku)-(\d+)(?:-(\d{1,2}))?(?=-|\[|$)/.exec(name)
+  if (current) return `${current[1]}-${current[2]}${current[3] ? `.${current[3]}` : ''}`
+  const older = /^claude-(\d+)-(\d+)-(opus|sonnet|haiku)/.exec(name)
+  return older ? `${older[3]}-${older[1]}.${older[2]}` : ''
+}
+
+export function requestCost(model, usage) {
+  const key = modelKey(model)
+  let price = PRICES[key]
+  if (!price || !usage) return null
+  const input = count(usage.input_tokens)
+  const output = count(usage.output_tokens)
+  const read = count(usage.cache_read_input_tokens)
+  let write5m = count(usage.cache_creation?.ephemeral_5m_input_tokens)
+  let write1h = count(usage.cache_creation?.ephemeral_1h_input_tokens)
+  if (!write5m && !write1h) write1h = count(usage.cache_creation_input_tokens)
+  const long = LONG_PROMPT[key]
+  if (long && input + read + write5m + write1h > long.over) price = long.rates
+  if (usage.speed === 'fast' && price.fast) {
+    const scale = price.fast.input / price.input
+    price = { input: price.fast.input, output: price.fast.output, read: price.read * scale, write5m: price.write5m * scale, write1h: price.write1h * scale }
+  }
+  let usd = (input * price.input + output * price.output + read * price.read + write5m * price.write5m + write1h * price.write1h) / PER_TOKEN
+  if (usage.inference_geo === 'us') usd *= US_ONLY
+  return usd + count(usage.server_tool_use?.web_search_requests) * WEB_SEARCH_USD
+}