@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/util/anvil-privacy.ts

@@ -0,0 +1,82 @@
+import type { AnvilIpPrivacySignal } from '../types/anvil-session'
+
+export const ANVIL_HARD_BLOCKED_PRIVACY_SIGNALS = [
+  'vpn',
+  'proxy',
+  'tor',
+  'res_proxy',
+] as const satisfies readonly AnvilIpPrivacySignal[]
+
+type AnvilHardBlockedPrivacySignal =
+  (typeof ANVIL_HARD_BLOCKED_PRIVACY_SIGNALS)[number]
+
+const ANVIL_HARD_BLOCKED_PRIVACY_SIGNAL_SET =
+  new Set<AnvilIpPrivacySignal>(ANVIL_HARD_BLOCKED_PRIVACY_SIGNALS)
+
+const ANVIL_HARD_BLOCKED_PRIVACY_SIGNAL_LABELS: Record<
+  AnvilHardBlockedPrivacySignal,
+  string
+> = {
+  vpn: 'VPN',
+  proxy: 'proxy',
+  res_proxy: 'proxy',
+  tor: 'Tor',
+}
+
+export function isAnvilHardBlockedPrivacySignal(
+  signal: AnvilIpPrivacySignal,
+): signal is AnvilHardBlockedPrivacySignal {
+  return ANVIL_HARD_BLOCKED_PRIVACY_SIGNAL_SET.has(signal)
+}
+
+/**
+ * ipinfo's `as.type` classifies the owning ASN as one of: ISP, Hosting,
+ * Education, Government or Business (see ipinfo's "IPinfo Plus" sample DB).
+ * Only `hosting` is a meaningful abuse signal — that's where VPN/proxy exits
+ * and bot infrastructure live. The other classes are ordinary networks real
+ * users sit behind, so we treat them as benign even when other heuristics
+ * (e.g. ipinfo's `is_hosting` flag) would otherwise fire.
+ */
+const ANVIL_BENIGN_AS_TYPES = new Set([
+  'isp',
+  'business',
+  'education',
+  'government',
+])
+
+export function isAnvilBenignAsType(
+  asType: string | null | undefined,
+): boolean {
+  return asType != null && ANVIL_BENIGN_AS_TYPES.has(asType.toLowerCase())
+}
+
+export function isAnvilHostingAsType(
+  asType: string | null | undefined,
+): boolean {
+  return typeof asType === 'string' && asType.toLowerCase() === 'hosting'
+}
+
+export function formatAnvilHardBlockedPrivacySignals(
+  signals: readonly AnvilIpPrivacySignal[] | null | undefined,
+): string {
+  const labels = Array.from(
+    new Set(
+      (signals ?? []).flatMap((signal): string[] => {
+        if (!isAnvilHardBlockedPrivacySignal(signal)) return []
+        return [ANVIL_HARD_BLOCKED_PRIVACY_SIGNAL_LABELS[signal]]
+      }),
+    ),
+  )
+
+  if (labels.length === 0) return 'VPN, proxy, or Tor'
+  if (labels.length === 1) return labels[0]
+  return `${labels.slice(0, -1).join(', ')} or ${labels[labels.length - 1]}`
+}
+
+export function formatAnvilHardBlockedMessage(
+  signals: readonly AnvilIpPrivacySignal[] | null | undefined,
+): string {
+  return `Anvil cannot be used from ${formatAnvilHardBlockedPrivacySignals(
+    signals,
+  )} traffic. Please disable it and try again.`
+}

package/vendor/@anvil/common/src/util/anvil-streak-line.ts

@@ -0,0 +1,103 @@
+import { ANVIL_STREAK_REWARDS_ENABLED } from '../constants/anvil-models'
+import {
+  getAnvilStreakGlmWeeklyUnits,
+  isAnvilStreakGlmBonusActive,
+} from './anvil-streak'
+
+/** Days in a streak "week" — the milestone the progress dots fill toward. */
+export const ANVIL_STREAK_WEEK = 7
+
+export interface AnvilStreakLine {
+  /** Count label, e.g. "2 day streak". */
+  label: string
+  /** A week's worth of progress dots toward the 7-day milestone, e.g.
+   *  "●●○○○○○". Fills to "●●●●●●●" at 7, then gains a trailing "+"
+   *  ("●●●●●●●+") for any streak beyond the week so long runs read as
+   *  "earned and still going" rather than just maxed out. */
+  dots: string
+  /** The same progress as counts, for a surface that draws its own dots rather
+   *  than glyphs (the desktop app draws CSS circles). `total` is always
+   *  ANVIL_STREAK_WEEK, carried so a renderer that can't import this module
+   *  knows how many slots to draw; `beyond` is the trailing "+". */
+  progress: { filled: number; total: number; beyond: boolean }
+}
+
+/** Glyph pair used to draw the progress dots. */
+export interface AnvilStreakDotChars {
+  filled: string
+  empty: string
+}
+
+/**
+ * Pure presentation logic for the streak line shown on the CLI landing screen
+ * and the desktop account popover: a plain count plus a week of filled/empty
+ * progress dots. Returns null for streak <= 0 so the caller hides the row
+ * entirely — new / lapsed users should be nudged to start using the product,
+ * not shown an empty streak.
+ *
+ * The glyphs default to ●/○, which is what a real UI font renders best; a
+ * surface whose font can't be trusted with those passes its own pair.
+ */
+export function getAnvilStreakLine(
+  streak: number,
+  chars: AnvilStreakDotChars = { filled: '●', empty: '○' },
+): AnvilStreakLine | null {
+  if (streak <= 0) return null
+
+  // Fill toward the 7-day milestone, then stay full — a 19-day streak should
+  // read as fully earned, not roll back over into a partial second week. Past
+  // the week, a trailing "+" marks that the streak has run beyond the row.
+  const filled = Math.min(streak, ANVIL_STREAK_WEEK)
+  const beyond = streak > ANVIL_STREAK_WEEK
+  const dots =
+    chars.filled.repeat(filled) +
+    chars.empty.repeat(ANVIL_STREAK_WEEK - filled) +
+    (beyond ? '+' : '')
+
+  // "day" stays singular — it's a compound modifier ("7 day streak"), not a
+  // count of days on its own.
+  return {
+    label: `${streak} day streak`,
+    dots,
+    progress: { filled, total: ANVIL_STREAK_WEEK, beyond },
+  }
+}
+
+/**
+ * A short perk note for an active streak. Below the 7-day milestone it teases
+ * the countdown ("N more days to unlock …") so the reward motivates the users
+ * who haven't earned it yet; at 7+ it flips to describing the perk they're now
+ * receiving. Returns null with no streak at all (the streak row is hidden then
+ * too — a lapsed user needs a first day, not a countdown from seven).
+ *
+ * The daily-pool bonus (+1 session) recurs **every day** the streak stays at 7+,
+ * so it's framed as "every day". The GLM 5.2 bonus refills with the GLM pool —
+ * daily since 2026-07-29 (weekly before) — while the streak remains active and
+ * grows with the streak (one session per completed 7 days, max 4), so the
+ * earned line shows the current tier's count. The exact remaining GLM count
+ * lives in the referral banner; this line is the motivational why. GLM is
+ * full-access only, so limited users get the daily session bonus alone.
+ */
+export function getAnvilStreakBonusNote(params: {
+  streak: number
+  accessTier: 'full' | 'limited'
+}): string | null {
+  if (!ANVIL_STREAK_REWARDS_ENABLED) return null
+  if (params.streak <= 0) return null
+  // Only advertise GLM when the recurring full-access streak entitlement is
+  // active, so the copy never promises a perk the gate won't honor.
+  const includesGlm =
+    params.accessTier === 'full' && isAnvilStreakGlmBonusActive()
+  // Below the milestone this is the first tier being unlocked (1/day); at 7+
+  // it's whatever tier the current streak has earned (up to 4/day).
+  const glmDaily = Math.max(1, getAnvilStreakGlmWeeklyUnits(params.streak))
+  const perk = includesGlm
+    ? `+1 bonus session every day + ${glmDaily} GLM 5.2 ${glmDaily === 1 ? 'session' : 'sessions'} each day`
+    : '+1 bonus session every day'
+
+  if (params.streak < ANVIL_STREAK_WEEK) {
+    const remaining = ANVIL_STREAK_WEEK - params.streak
+    return `🎁 ${remaining} more ${remaining === 1 ? 'day' : 'days'} to unlock ${perk}`
+  }
+  return `🎁 Streak perk: ${perk}`
+}

package/vendor/@anvil/common/src/util/anvil-streak.ts

@@ -0,0 +1,156 @@
+import {
+  ANVIL_GLM_V52_REFERRAL_ENABLED,
+  ANVIL_PREMIUM_SESSION_RESET_TIMEZONE,
+  ANVIL_STREAK_GLM_BONUS_ENABLED,
+  ANVIL_STREAK_GLM_BONUS_MAX_MULTIPLIER,
+  ANVIL_STREAK_BONUS_SESSION_UNITS,
+  ANVIL_STREAK_REWARD_INTERVAL_DAYS,
+  ANVIL_STREAK_REWARDS_ENABLED,
+} from '../constants/anvil-models'
+
+import type {
+  AnvilAccessTier,
+  AnvilStreakRewardPool,
+} from '../constants/anvil-models'
+
+export const ANVIL_STREAK_TIME_ZONE = ANVIL_PREMIUM_SESSION_RESET_TIMEZONE
+
+const DAY_MS = 24 * 60 * 60 * 1000
+
+function dateKeyFromParts(parts: Intl.DateTimeFormatPart[]): string {
+  const get = (type: Intl.DateTimeFormatPartTypes) =>
+    parts.find((part) => part.type === type)?.value
+
+  const year = get('year')
+  const month = get('month')
+  const day = get('day')
+
+  if (!year || !month || !day) {
+    throw new Error('Failed to format Anvil usage date')
+  }
+
+  return `${year}-${month}-${day}`
+}
+
+export function getAnvilUsageDateKey(
+  now: Date = new Date(),
+  timeZone = ANVIL_STREAK_TIME_ZONE,
+): string {
+  return dateKeyFromParts(
+    new Intl.DateTimeFormat('en-US', {
+      timeZone,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+    }).formatToParts(now),
+  )
+}
+
+export function addDaysToDateKey(dateKey: string, days: number): string {
+  const date = new Date(`${dateKey}T00:00:00.000Z`)
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid date key: ${dateKey}`)
+  }
+
+  return new Date(date.getTime() + days * DAY_MS).toISOString().slice(0, 10)
+}
+
+export function calculateAnvilStreak(params: {
+  usageDates: readonly string[]
+  todayDateKey: string
+}): {
+  streak: number
+  todayUsed: boolean
+  lastUsageDate: string | null
+} {
+  const { usageDates, todayDateKey } = params
+  const usageDateSet = new Set(
+    usageDates.filter((date) => date <= todayDateKey),
+  )
+  const lastUsageDate = usageDates.reduce<string | null>((latest, date) => {
+    if (date > todayDateKey) return latest
+    return latest === null || date > latest ? date : latest
+  }, null)
+  const todayUsed = usageDateSet.has(todayDateKey)
+
+  let anchorDateKey = todayDateKey
+  if (!todayUsed) {
+    const yesterdayDateKey = addDaysToDateKey(todayDateKey, -1)
+    if (!usageDateSet.has(yesterdayDateKey)) {
+      return { streak: 0, todayUsed, lastUsageDate }
+    }
+    anchorDateKey = yesterdayDateKey
+  }
+
+  let streak = 0
+  for (
+    let cursor = anchorDateKey;
+    usageDateSet.has(cursor);
+    cursor = addDaysToDateKey(cursor, -1)
+  ) {
+    streak++
+  }
+
+  return { streak, todayUsed, lastUsageDate }
+}
+
+/**
+ * Whether the full-access GLM 5.2 streak bonus is currently active. Requires all
+ * three switches: streak rewards on, the GLM streak sub-switch on, AND the GLM
+ * program itself live — GLM is only launchable from the referral banner, which
+ * is hidden when the referral program is wound down, so a GLM bonus granted
+ * while it's off would be unusable. Keeping the grant and the advertised perk
+ * gated on the same predicate avoids that mismatch.
+ */
+export function isAnvilStreakGlmBonusActive(): boolean {
+  return (
+    ANVIL_STREAK_REWARDS_ENABLED &&
+    ANVIL_STREAK_GLM_BONUS_ENABLED &&
+    ANVIL_GLM_V52_REFERRAL_ENABLED
+  )
+}
+
+/** GLM sessions per pool window earned by a streak of `streak` days, ignoring
+ * the feature gates: one per completed 7-day interval, capped at
+ * `ANVIL_STREAK_GLM_BONUS_MAX_MULTIPLIER` (a 28-day streak earns the max).
+ * The GLM pool resets daily since 2026-07-29 (weekly before), so these units
+ * refill at that cadence. The name keeps its historical "Weekly". */
+export function getAnvilStreakGlmWeeklyUnits(streak: number): number {
+  const tiers = Math.min(
+    Math.floor(streak / ANVIL_STREAK_REWARD_INTERVAL_DAYS),
+    ANVIL_STREAK_GLM_BONUS_MAX_MULTIPLIER,
+  )
+  return tiers * ANVIL_STREAK_BONUS_SESSION_UNITS
+}
+
+/** Resolve the live GLM bonus directly from usage dates. The GLM pool gets +1
+ * per completed 7 days of the current streak (7 → 1, 14 → 2, capped at 4 for
+ * 28+) and refills at the pool reset (daily Pacific since 2026-07-29); once
+ * the streak breaks it gets 0. */
+export function getAnvilStreakGlmBonusUnits(params: {
+  usageDates: readonly string[]
+  todayDateKey: string
+}): number {
+  if (!isAnvilStreakGlmBonusActive()) return 0
+  const { streak } = calculateAnvilStreak(params)
+  return getAnvilStreakGlmWeeklyUnits(streak)
+}
+
+/**
+ * The daily streak-reward pool to persist after today's first usage, or `null`
+ * when nothing should be awarded. Full-access users receive a premium bonus;
+ * limited-access users receive a limited-pool bonus. GLM is intentionally not
+ * returned: its weekly +1 is derived live from usage dates, so it refills with
+ * the weekly quota and shuts off with the streak instead of becoming a one-time
+ * ledger grant.
+ */
+export function getAnvilDailyStreakRewardPool(params: {
+  streak: number
+  todayUsed: boolean
+  accessTier: AnvilAccessTier
+}): Exclude<AnvilStreakRewardPool, 'glm'> | null {
+  if (!ANVIL_STREAK_REWARDS_ENABLED) return null
+  if (!params.todayUsed) return null
+  if (params.streak < ANVIL_STREAK_REWARD_INTERVAL_DAYS) return null
+  return params.accessTier === 'limited' ? 'limited' : 'premium'
+}

package/vendor/@anvil/common/src/util/anvil-usage-summary.ts

@@ -0,0 +1,125 @@
+import { ANVIL_USAGE_MAP_DAYS } from '../constants/anvil-models'
+
+import {
+  addDaysToDateKey,
+  calculateAnvilStreak,
+  ANVIL_STREAK_TIME_ZONE,
+} from './anvil-streak'
+
+import type {
+  AnvilRecentUsage,
+  AnvilUsageSessionsByModel,
+  AnvilUsageSummary,
+} from '../types/anvil-usage'
+
+/**
+ * The longest run of consecutive active days in `dateKeys`.
+ *
+ * Unlike the current streak this has no grace day: a gap ends the run outright.
+ * The current streak treats "used yesterday, not yet today" as alive because
+ * the day is not over; a historical run has no such ambiguity.
+ */
+export function calculateLongestAnvilStreak(
+  dateKeys: readonly string[],
+): number {
+  const sorted = [...new Set(dateKeys)].sort()
+  let longest = 0
+  let run = 0
+  let previous: string | null = null
+
+  for (const dateKey of sorted) {
+    run =
+      previous !== null && addDaysToDateKey(previous, 1) === dateKey ? run + 1 : 1
+    previous = dateKey
+    if (run > longest) longest = run
+  }
+
+  return longest
+}
+
+/**
+ * Assemble the account hub's summary from the account's active dates.
+ *
+ * Pure, so the CLI, Desktop and web all describe usage identically and the
+ * arithmetic is testable without a database. `activeDates` may arrive in any
+ * order and may include days after `todayDateKey` (a client whose clock has run
+ * ahead of the Pacific date key); both are normalised here.
+ */
+export function buildAnvilUsageSummary(params: {
+  activeDates: readonly string[]
+  todayDateKey: string
+  recent?: AnvilRecentUsage | null
+  sessionsByModel?: readonly AnvilUsageSessionsByModel[]
+  windowDays?: number
+  timeZone?: string
+}): AnvilUsageSummary {
+  const windowDays = Math.max(1, params.windowDays ?? ANVIL_USAGE_MAP_DAYS)
+  const todayDateKey = params.todayDateKey
+
+  const allDates = [...new Set(params.activeDates)]
+    .filter((date) => date <= todayDateKey)
+    .sort()
+
+  const windowStart = addDaysToDateKey(todayDateKey, -(windowDays - 1))
+  const { streak, todayUsed, lastUsageDate } = calculateAnvilStreak({
+    usageDates: allDates,
+    todayDateKey,
+  })
+
+  return {
+    timeZone: params.timeZone ?? ANVIL_STREAK_TIME_ZONE,
+    todayDateKey,
+    streak: {
+      current: streak,
+      longest: calculateLongestAnvilStreak(allDates),
+      todayUsed,
+      lastUsageDate,
+    },
+    activeDates: allDates.filter((date) => date >= windowStart),
+    windowDays,
+    allTimeActiveDays: allDates.length,
+    recent: params.recent ?? null,
+    sessionsByModel: [...(params.sessionsByModel ?? [])],
+  }
+}
+
+/** One cell of the activity map: an active day, a quiet day, or padding. */
+export type AnvilUsageCell =
+  | { date: string; active: boolean }
+  | null
+
+/**
+ * Expand the active dates into the fixed grid the activity map draws: every day
+ * in the window, quiet days included, oldest first.
+ *
+ * The grid is laid out in columns of seven, so the first column is padded with
+ * `null` for the days before the window began and the last for the days after
+ * today. Callers render `null` as empty space, not as a quiet day — those days
+ * either predate the window or have not happened yet.
+ */
+export function buildAnvilUsageGrid(params: {
+  activeDates: readonly string[]
+  todayDateKey: string
+  windowDays: number
+  /** 0 = Sunday. The weekday `todayDateKey` falls on, resolved by the caller
+   *  in the streak time zone rather than from the viewer's clock. */
+  todayWeekday: number
+}): AnvilUsageCell[] {
+  const active = new Set(params.activeDates)
+  const cells: AnvilUsageCell[] = []
+
+  // Pad to whole weeks so the last column ends on today's weekday and every row
+  // is one weekday throughout the grid.
+  const trailingPad = 6 - params.todayWeekday
+  const start = addDaysToDateKey(params.todayDateKey, -(params.windowDays - 1))
+  const leadingPad = (7 - ((params.windowDays + trailingPad) % 7)) % 7
+
+  for (let index = 0; index < leadingPad; index++) cells.push(null)
+  for (let index = 0; index < params.windowDays; index++) {
+    const date = addDaysToDateKey(start, index)
+    cells.push({ date, active: active.has(date) })
+  }
+  for (let index = 0; index < trailingPad; index++) cells.push(null)
+
+  return cells
+}

package/vendor/@anvil/common/src/util/array.ts

@@ -0,0 +1,31 @@
+import { compact, flattenDeep, isEqual } from 'lodash'
+
+export function filterDefined<T>(array: (T | null | undefined)[]) {
+  return array.filter((item) => item !== null && item !== undefined) as T[]
+}
+
+type Falsey = false | undefined | null | 0 | ''
+type FalseyValueArray<T> = T | Falsey | FalseyValueArray<T>[]
+
+export function buildArray<T>(...params: FalseyValueArray<T>[]) {
+  return compact(flattenDeep(params)) as T[]
+}
+
+export function groupConsecutive<T, U>(xs: T[], key: (x: T) => U) {
+  if (!xs.length) {
+    return []
+  }
+  const result: any[] = []
+  let curr = { key: key(xs[0]), items: [xs[0]] }
+  for (const x of xs.slice(1)) {
+    const k = key(x)
+    if (!isEqual(k, curr.key)) {
+      result.push(curr)
+      curr = { key: k, items: [x] }
+    } else {
+      curr.items.push(x)
+    }
+  }
+  result.push(curr)
+  return result
+}

package/vendor/@anvil/common/src/util/axiom-only-log.ts

@@ -0,0 +1,124 @@
+/**
+ * Operational events that belong in Axiom but not in product analytics.
+ *
+ * CLI logs normally redact structured info payloads before shipping and also
+ * mirror a sampled `cli_log` event to PostHog. This allowlist lets a small set
+ * of content-free operational events retain useful numeric/string/boolean
+ * metadata in Axiom without becoming product events or providing a general
+ * redaction bypass — each event declares an explicit field allowlist, and
+ * unknown keys or unexpected value types are always discarded.
+ */
+
+export const CONTEXT_PRUNING_COMPLETED_EVENT =
+  'context_pruning.completed' as const
+
+/** Stream-cut / output-limit recovery (sdk/src/impl/stream-interruption.ts,
+ *  packages/agent-runtime/src/tools/stream-parser.ts). `metric` distinguishes
+ *  the log sites (stream_recovery_detected / _rescued) that share this one
+ *  allowlisted event — `_gave_up` logs at error level, which already ships
+ *  raw and doesn't need the allowlist. */
+export const STREAM_RECOVERY_EVENT = 'stream_recovery' as const
+
+type AxiomOnlyFieldType = 'string' | 'number' | 'boolean'
+type AxiomOnlyFieldSchema = Record<string, AxiomOnlyFieldType>
+
+const CONTEXT_PRUNING_FIELDS = {
+  agent_run_id: 'string',
+  parent_agent_run_id: 'string',
+  client_session_id: 'string',
+  client_request_id: 'string',
+  trigger_reason: 'string',
+  context_token_count: 'number',
+  max_context_length: 'number',
+  cache_gap_ms: 'number',
+  cache_expiry_ms: 'number',
+  previous_summary_entry_count: 'number',
+  user_budget: 'number',
+  user_entry_count: 'number',
+  dropped_user_entry_count: 'number',
+  assistant_tool_budget: 'number',
+  assistant_tool_entry_count: 'number',
+  dropped_assistant_tool_entry_count: 'number',
+  summary_estimated_tokens: 'number',
+  mid_turn: 'boolean',
+  live_user_prompt_found: 'boolean',
+  live_user_prompt_text_preserved: 'boolean',
+  newest_entry_forced: 'boolean',
+} as const satisfies AxiomOnlyFieldSchema
+
+const STREAM_RECOVERY_FIELDS = {
+  metric: 'string',
+  source: 'string',
+  model: 'string',
+  agentId: 'string',
+  runId: 'string',
+  userInputId: 'string',
+  finishReason: 'string',
+  hasYieldedContent: 'boolean',
+  consecutive: 'number',
+} as const satisfies AxiomOnlyFieldSchema
+
+export type AxiomOnlyLogEvent = {
+  event:
+    | typeof CONTEXT_PRUNING_COMPLETED_EVENT
+    | typeof STREAM_RECOVERY_EVENT
+  data: Record<string, string | number | boolean>
+}
+
+/** Keep only the allowlisted keys whose value matches the declared type
+ *  (strings truncated); everything else is dropped. */
+function sanitizeAllowlistedFields(
+  record: Record<string, unknown>,
+  fields: AxiomOnlyFieldSchema,
+): AxiomOnlyLogEvent['data'] {
+  const sanitized: AxiomOnlyLogEvent['data'] = {}
+  for (const [key, expectedType] of Object.entries(fields)) {
+    const value = record[key]
+    if (typeof value !== expectedType) continue
+    if (typeof value === 'string') {
+      sanitized[key] = value.slice(0, 200)
+    } else if (typeof value === 'number' && Number.isFinite(value)) {
+      sanitized[key] = value
+    } else if (typeof value === 'boolean') {
+      sanitized[key] = value
+    }
+  }
+  return sanitized
+}
+
+/**
+ * Return a sanitized Axiom-only event, or null for ordinary logger payloads.
+ * The event name comes from `data.axiomEvent` (the in-process marker set at
+ * the log call site) or the `event` param (the wire-format field a caller
+ * already extracted, e.g. the server-side sink re-checking a persisted
+ * `LogRow`). Unknown keys and unexpected value types are deliberately
+ * discarded.
+ *
+ * Matched by exact equality (not a lookup keyed on the caller-supplied name)
+ * so a value like 'constructor' can't resolve through an object's prototype.
+ */
+export function getAxiomOnlyLogEvent(
+  data: unknown,
+  event?: string | null,
+): AxiomOnlyLogEvent | null {
+  const record =
+    data != null && typeof data === 'object' && !Array.isArray(data)
+      ? (data as Record<string, unknown>)
+      : {}
+  const eventName =
+    typeof record.axiomEvent === 'string' ? record.axiomEvent : event
+
+  if (eventName === CONTEXT_PRUNING_COMPLETED_EVENT) {
+    return {
+      event: eventName,
+      data: sanitizeAllowlistedFields(record, CONTEXT_PRUNING_FIELDS),
+    }
+  }
+  if (eventName === STREAM_RECOVERY_EVENT) {
+    return {
+      event: eventName,
+      data: sanitizeAllowlistedFields(record, STREAM_RECOVERY_FIELDS),
+    }
+  }
+  return null
+}