@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/session/prune.ts

@@ -1,481 +0,0 @@
-import * as Session from "./session"
-import { SessionID } from "./schema"
-import { Provider } from "../provider"
-import { MessageV2 } from "./message-v2"
-import { Token } from "../util"
-import { Log } from "../util"
-import { Config } from "@/config"
-import { NotFoundError } from "@/storage"
-import { Effect, Layer, Context } from "effect"
-import { pressureLevel, usable } from "./overflow"
-import { SessionCheckpoint } from "./checkpoint"
-import { ActorRegistry } from "@/actor/registry"
-import type { ActorPromptOps } from "@/tool/actor"
-
-const log = Log.create({ service: "session.prune" })
-
-const PRUNE_MINIMUM = 20_000
-const PRUNE_PROTECT = 40_000
-const PRUNE_PROTECTED_TOOLS = ["skill"]
-const SOFT_TRIM_THRESHOLD = 4096
-const SOFT_TRIM_KEEP_HEAD = 1536
-const SOFT_TRIM_KEEP_TAIL = 1536
-const DEFAULT_CACHE_TTL = 300_000
-// Default safety buffer subtracted from windowSize to derive maxAllowed for
-// checkpoint thresholds. Users can override via cfg.checkpoint.reserved.
-const CHECKPOINT_RESERVED = 13_000
-const MAX_WRITER_FAILURES = 3
-
-/**
- * Default checkpoint thresholds by context window size.
- *
- * Schedule (Part 2 density):
- *   < 25K          → []                    (subsystem disabled)
- *   25K ≤ w ≤ 200K → 4 triggers @ 20%      (mid-tier models)
- *   200K < w ≤ 500K → 9 triggers @ 10%     (extended-context models)
- *   w > 500K        → 18 triggers @ 5%     (1M+ window models)
- *
- * Density mirrors cc's intent that writers fire often enough that overflow
- * almost always finds a fresh `checkpoint.md` to rebuild from (avoiding
- * fallback to lossy compaction). cc uses growth+toolcall triggers; we use
- * % of window for a simpler implementation that doesn't require new state.
- * See docs/superpowers/specs/2026-06-03-checkpoint-threshold-density-design.md.
- */
-export function defaultThresholdsFor(window: number): readonly string[] {
-  if (window < 25_000) return []
-  if (window <= 200_000) return ["20%", "40%", "60%", "80%"]
-  if (window <= 500_000) {
-    return ["10%", "20%", "30%", "40%", "50%", "60%", "70%", "80%", "90%"]
-  }
-  return Array.from({ length: 18 }, (_, i) => `${(i + 1) * 5}%`)
-}
-
-function isCacheCold(model?: Provider.Model, lastAssistantTime?: number): boolean {
-  if (!model) return true
-  const ttl = model.cacheTTL ?? DEFAULT_CACHE_TTL
-  if (!lastAssistantTime) return true
-  return Date.now() - lastAssistantTime > ttl
-}
-
-/**
- * Parse a checkpoint threshold string into a token count.
- * Supports: "40%" (percent of windowSize), "100K"/"100k" (kilotokens),
- * "1.5M"/"1.5m" (megatokens), or plain number.
- */
-export function parseThreshold(s: string, windowSize: number): number {
-  const trimmed = s.trim()
-  if (trimmed.endsWith("%")) {
-    const pct = parseFloat(trimmed.slice(0, -1))
-    if (!Number.isFinite(pct) || pct <= 0 || pct > 100) {
-      throw new Error(`Invalid checkpoint threshold percentage: "${s}" (must be 0 < n <= 100)`)
-    }
-    return Math.floor((windowSize * pct) / 100)
-  }
-  const match = trimmed.match(/^(\d+(?:\.\d+)?)([KkMm]?)$/)
-  if (!match) throw new Error(`Invalid checkpoint threshold format: "${s}"`)
-  let n = parseFloat(match[1])
-  if (match[2] === "K" || match[2] === "k") n *= 1_000
-  else if (match[2] === "M" || match[2] === "m") n *= 1_000_000
-  return Math.floor(n)
-}
-
-/**
- * Parse, validate, sort, and deduplicate checkpoint thresholds.
- *
- * - Values ≤ maxAllowed pass through.
- * - The FIRST over-cap value (in user-provided order) is clamped to maxAllowed
- *   and logged INFO.
- * - Later over-cap values are dropped and logged INFO.
- * - Throws only when maxAllowed itself is <= 0 (model context too small to
- *   accommodate the safety buffer — no recovery available).
- */
-export function resolveThresholds(raw: readonly string[], windowSize: number, reserved?: number): number[] {
-  const effectiveReserved = reserved ?? CHECKPOINT_RESERVED
-  const maxAllowed = windowSize - effectiveReserved
-  if (maxAllowed <= 0) {
-    throw new Error(
-      `Model window size (${windowSize}) is too small for checkpoints ` +
-        `(need > ${effectiveReserved} reserved tokens)`,
-    )
-  }
-
-  const parsed = raw.map((s) => ({ raw: s, value: parseThreshold(s, windowSize) }))
-
-  const result: number[] = []
-  let cappedAlready = false
-  for (const p of parsed) {
-    if (p.value <= maxAllowed) {
-      result.push(p.value)
-      continue
-    }
-    if (!cappedAlready) {
-      log.info(
-        `checkpoint threshold "${p.raw}" (${p.value}) exceeds maxAllowed (${maxAllowed}) — clamped to maxAllowed`,
-      )
-      result.push(maxAllowed)
-      cappedAlready = true
-      continue
-    }
-    log.info(
-      `checkpoint threshold "${p.raw}" (${p.value}) exceeds maxAllowed (${maxAllowed}) — dropped (already clamped earlier)`,
-    )
-  }
-
-  // Sort and dedupe. If a sub-cap entry happened to equal maxAllowed, it
-  // collapses with the clamped value.
-  const values = result.sort((a, b) => a - b)
-  const deduped: number[] = []
-  for (const v of values) {
-    if (deduped.length === 0 || deduped[deduped.length - 1] !== v) deduped.push(v)
-  }
-  return deduped
-}
-
-export interface Interface {
-  readonly prune: (input: {
-    sessionID: SessionID
-    model: Provider.Model
-    tokens: MessageV2.Assistant["tokens"]
-    lastAssistantTime?: number
-    promptOps?: ActorPromptOps
-  }) => Effect.Effect<void>
-  /**
-   * Fire background checkpoint writers for every newly-crossed threshold.
-   * Call this at the START of each runLoop iteration so thresholds fire
-   * mid-turn as tokens grow (not only at turn end).
-   */
-  readonly fireCheckpoints: (input: {
-    sessionID: SessionID
-    model: Provider.Model
-    tokens: MessageV2.Assistant["tokens"]
-    promptOps: ActorPromptOps
-    agentID?: string
-  }) => Effect.Effect<void>
-  /** True when the current tokens have just crossed the max checkpoint threshold. */
-  readonly maxThresholdCrossed: (sessionID: SessionID) => Effect.Effect<boolean>
-  /** Clear the crossed-threshold state for a session (e.g. after discard+rebuild). */
-  readonly resetThresholds: (sessionID: SessionID) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionPrune") {}
-
-export const layer: Layer.Layer<
-  Service,
-  never,
-  Config.Service | Session.Service | SessionCheckpoint.Service | ActorRegistry.Service
-> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const session = yield* Session.Service
-    const checkpoint = yield* SessionCheckpoint.Service
-    const actorReg = yield* ActorRegistry.Service
-
-    // Per-session state: which checkpoint thresholds have already been crossed
-    // (and had a checkpoint writer enqueued). Prevents re-firing on the same
-    // threshold every turn.
-    const crossed = new Map<SessionID, Set<number>>()
-    // Per-session signal: the max threshold was just crossed; prompt.ts should
-    // trigger discard+rebuild on the next loop iteration.
-    const maxCrossed = new Set<SessionID>()
-    // Per-session consecutive writer-failure count. Resets on success.
-    // After the configured `max_writer_failures` (default MAX_WRITER_FAILURES)
-    // consecutive failures, the session stops retrying checkpoint writes
-    // until the process restarts.
-    const writerFailures = new Map<SessionID, number>()
-
-    const stripNonEssential = Effect.fn("SessionPrune.stripNonEssential")(function* (input: {
-      sessionID: SessionID
-      model: Provider.Model
-      lastAssistantTime?: number
-    }) {
-      if (!isCacheCold(input.model, input.lastAssistantTime)) return
-
-      const msgs = yield* session
-        .messages({ sessionID: input.sessionID, agentID: "main" })
-        .pipe(Effect.catchIf(NotFoundError.isInstance, () => Effect.succeed(undefined)))
-      if (!msgs) return
-
-      // Protect last 3 turns.
-      let turnCount = 0
-      let boundary = msgs.length
-      for (let i = msgs.length - 1; i >= 0; i--) {
-        if (msgs[i].info.role === "user") turnCount++
-        if (turnCount > 3) {
-          boundary = i
-          break
-        }
-      }
-
-      let stripped = 0
-      for (let i = 0; i < boundary; i++) {
-        const msg = msgs[i]
-        for (const part of msg.parts) {
-          if (part.type === "file" && MessageV2.isMedia(part.mime)) {
-            yield* session.updatePart({
-              ...part,
-              url: "",
-              filename: `[stripped: ${part.filename ?? part.mime}]`,
-            })
-            stripped++
-          }
-          if (part.type === "reasoning" && msg.info.role === "assistant") {
-            yield* session.updatePart({
-              ...part,
-              text: "",
-            })
-            stripped++
-          }
-        }
-      }
-
-      if (stripped > 0) {
-        log.info("stripped non-essential content", { count: stripped })
-      }
-    })
-
-    // Fires a checkpoint write for every threshold newly crossed by the
-    // current token count. Exposed publicly so runLoop can call it at each
-    // iteration to catch mid-turn threshold crossings (not just turn end).
-    const fireCheckpoints = Effect.fn("SessionPrune.fireCheckpoints")(function* (input: {
-      sessionID: SessionID
-      model: Provider.Model
-      tokens: MessageV2.Assistant["tokens"]
-      promptOps: ActorPromptOps
-      agentID?: string
-    }) {
-      // Skip if this is a system-spawned actor — it's an internal subagent
-      // (e.g. checkpoint-writer) and should not itself trigger checkpoints.
-      if (input.agentID && (yield* actorReg.isSystemSpawned(input.sessionID, input.agentID))) {
-        return
-      }
-
-      // Kept separate from the isSystemSpawned skip above on purpose: that
-      // guard keys on AGENT TYPE (checkpoint-writer/dream/distill), this one
-      // keys on MODE. They are orthogonal invariants that merely overlap today
-      // (those agents happen to spawn as mode:"subagent"). Folding them into one
-      // boolean would silently re-enable self-triggering for any future
-      // system agent spawned as mode:"peer". The extra registry read is a local
-      // SQLite hit; correctness of the layering is worth more than saving it.
-      //
-      // Checkpoint serves main/peer only; subagents use per-actor compaction
-      // (independent layers — see 2026-05-22-checkpoint-v8-design.md:71). A
-      // subagent shares the parent sessionID, so if it triggered a checkpoint
-      // the writer's unfiltered-stream watermark could land on the subagent's
-      // messages and the fork would capture the wrong parent system prompt.
-      // Gate on registry mode, NOT agentID: a peer's agentID is its child.id,
-      // not "main", so an agentID==="main" check would wrongly exclude peers.
-      // Unresolved actor (no agentID / unregistered / race) → fail open and
-      // fire: main and peer must never silently lose checkpoints.
-      const actor = input.agentID ? yield* actorReg.get(input.sessionID, input.agentID) : undefined
-      if (actor?.mode === "subagent") return
-
-      // Lock: skip if a writer is already running for this session.
-      // crossed Set is NOT incremented here — when the in-flight writer
-      // finishes, the next fireCheckpoints invocation can re-fire previously-
-      // skipped thresholds.
-      if (yield* checkpoint.isWriterRunning(input.sessionID)) {
-        log.info("checkpoint writer running, skipping new threshold trigger", {
-          sessionID: input.sessionID,
-        })
-        return
-      }
-
-      const cfg = yield* config.get()
-      const windowSize = usable({ cfg, model: input.model })
-      if (windowSize === 0) return
-      const raw = cfg.checkpoint?.thresholds ?? defaultThresholdsFor(windowSize)
-
-      // resolveThresholds throws on invalid config; we let that propagate so
-      // the user sees the error fast at the first overflow check.
-      const thresholds = resolveThresholds(raw, windowSize, cfg.checkpoint?.reserved)
-      if (thresholds.length === 0) return
-
-      const maxFailures = cfg.checkpoint?.max_writer_failures ?? MAX_WRITER_FAILURES
-
-      const currentTokens =
-        input.tokens.total ||
-        input.tokens.input + input.tokens.output + input.tokens.cache.read + input.tokens.cache.write
-
-      const already = crossed.get(input.sessionID) ?? new Set<number>()
-      const maxThreshold = thresholds[thresholds.length - 1]
-
-      for (const t of thresholds) {
-        if (currentTokens < t) break // sorted ascending; nothing more to trigger
-        if (already.has(t)) continue
-
-        const outcome = yield* checkpoint
-          .tryStartCheckpointWriter({
-            sessionID: input.sessionID,
-            model: { providerID: input.model.providerID, modelID: input.model.id },
-            promptOps: input.promptOps,
-          })
-          .pipe(Effect.catch(() => Effect.succeed<"started" | "queued" | "skipped">("skipped")))
-
-        if (outcome === "started") {
-          // Fork a watcher that settles after the detached writer fiber
-          // finishes. On success, clear the failure counter. On failure,
-          // increment the counter; if below MAX_WRITER_FAILURES, clear the
-          // session's crossed thresholds so the next iteration retries.
-          //
-          // Known narrow race: between tryStartCheckpointWriter returning "started" and
-          // the watcher's forkDetach scheduling, a very-fast writer fiber can
-          // complete and delete itself from the writers map. waitForWriter
-          // then returns "no-writer" and the watcher exits without touching
-          // the counter. Impact is low — real writers run an LLM round-trip
-          // (seconds) vs. microseconds to schedule the fork, so observable
-          // failures tick the counter in practice. Proper fix: have
-          // tryStartCheckpointWriter return the Deferred handle so the watcher doesn't
-          // re-read the writers map.
-          yield* Effect.gen(function* () {
-            const result = yield* checkpoint.waitForWriter(input.sessionID)
-            if (result === "success") {
-              writerFailures.delete(input.sessionID)
-              return
-            }
-            if (result !== "failure") return
-            const next = (writerFailures.get(input.sessionID) ?? 0) + 1
-            writerFailures.set(input.sessionID, next)
-            if (next < maxFailures) {
-              crossed.delete(input.sessionID)
-              maxCrossed.delete(input.sessionID)
-              log.info("checkpoint writer failed — cleared thresholds for retry", {
-                sessionID: input.sessionID,
-                attempt: next,
-                maxAttempts: maxFailures,
-              })
-            } else {
-              log.warn("checkpoint writer gave up after max consecutive failures", {
-                sessionID: input.sessionID,
-                maxAttempts: maxFailures,
-              })
-            }
-          }).pipe(Effect.forkDetach)
-        }
-
-        already.add(t)
-        log.info("checkpoint triggered", { threshold: t, currentTokens })
-
-        if (t === maxThreshold) maxCrossed.add(input.sessionID)
-      }
-
-      crossed.set(input.sessionID, already)
-    })
-
-    // Each turn end, decide (based on cache-TTL + pressure) whether to soft-trim
-    // old tool outputs, hard-clear them with a compacted timestamp, and/or
-    // strip non-essential content. Checkpoint firing is NOT done here — the
-    // runLoop calls fireCheckpoints() directly each iteration so thresholds
-    // fire mid-turn as tokens grow.
-    const prune = Effect.fn("SessionPrune.prune")(function* (input: {
-      sessionID: SessionID
-      model: Provider.Model
-      tokens: MessageV2.Assistant["tokens"]
-      lastAssistantTime?: number
-      promptOps?: ActorPromptOps
-    }) {
-      const cfg = yield* config.get()
-      if (!cfg.compaction?.prune) return
-
-      if (!isCacheCold(input.model, input.lastAssistantTime)) return
-
-      const pressure = pressureLevel({ cfg, tokens: input.tokens, model: input.model })
-      if (pressure === 0) return
-      const level = pressure >= 2 ? 2 : 1
-      log.info("pruning", { level })
-
-      const msgs = yield* session
-        .messages({ sessionID: input.sessionID, agentID: "main" })
-        .pipe(Effect.catchIf(NotFoundError.isInstance, () => Effect.succeed(undefined)))
-      if (!msgs) return
-
-      let total = 0
-      let pruned = 0
-      const toPrune: MessageV2.ToolPart[] = []
-      let turns = 0
-
-      loop: for (let msgIndex = msgs.length - 1; msgIndex >= 0; msgIndex--) {
-        const msg = msgs[msgIndex]
-        if (msg.info.role === "user") turns++
-        if (turns < 2) continue
-        if (msg.info.role === "assistant" && msg.info.summary) break loop
-        for (let partIndex = msg.parts.length - 1; partIndex >= 0; partIndex--) {
-          const part = msg.parts[partIndex]
-          if (part.type === "tool")
-            if (part.state.status === "completed") {
-              if (PRUNE_PROTECTED_TOOLS.includes(part.tool)) continue
-              if (part.state.time.compacted) break loop
-              const estimate = Token.estimate(part.state.output)
-              total += estimate
-              if (total > PRUNE_PROTECT) {
-                pruned += estimate
-                toPrune.push(part)
-              }
-            }
-        }
-      }
-
-      log.info("found", { pruned, total, level })
-
-      if (level === 1) {
-        for (const part of toPrune) {
-          if (part.state.status === "completed") {
-            const output = part.state.output
-            if (output.length > SOFT_TRIM_THRESHOLD) {
-              part.state.output =
-                output.slice(0, SOFT_TRIM_KEEP_HEAD) +
-                "\n\n[... trimmed — kept first and last 1.5K of " +
-                output.length +
-                " chars ...]\n\n" +
-                output.slice(-SOFT_TRIM_KEEP_TAIL)
-              yield* session.updatePart(part)
-            }
-          }
-        }
-        log.info("soft-trimmed", { count: toPrune.length })
-      } else {
-        if (pruned > PRUNE_MINIMUM) {
-          for (const part of toPrune) {
-            if (part.state.status === "completed") {
-              part.state.time.compacted = Date.now()
-              yield* session.updatePart(part)
-            }
-          }
-          log.info("pruned", { count: toPrune.length })
-        }
-      }
-
-      if (level >= 2) {
-        yield* stripNonEssential({
-          sessionID: input.sessionID,
-          model: input.model,
-          lastAssistantTime: input.lastAssistantTime,
-        })
-      }
-    })
-
-    const maxThresholdCrossed = Effect.fn("SessionPrune.maxThresholdCrossed")(function* (
-      sessionID: SessionID,
-    ) {
-      return maxCrossed.has(sessionID)
-    })
-
-    const resetThresholds = Effect.fn("SessionPrune.resetThresholds")(function* (sessionID: SessionID) {
-      crossed.delete(sessionID)
-      maxCrossed.delete(sessionID)
-    })
-
-    return Service.of({ prune, fireCheckpoints, maxThresholdCrossed, resetThresholds })
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() =>
-  layer.pipe(
-    Layer.provide(Session.defaultLayer),
-    Layer.provide(Config.defaultLayer),
-    Layer.provide(SessionCheckpoint.defaultLayer),
-    Layer.provide(ActorRegistry.defaultLayer),
-  ),
-)
-
-export * as SessionPrune from "./prune"

package/src/session/retry.ts

@@ -1,178 +0,0 @@
-import type { NamedError } from "@sleepy-ai/shared/util/error"
-import { Cause, Clock, Duration, Effect, Schedule } from "effect"
-import { MessageV2 } from "./message-v2"
-import { iife } from "@/util/iife"
-
-export type Err = ReturnType<NamedError["toObject"]>
-
-// This exported message is shared with the TUI upsell detector. Matching on a
-// literal error string kind of sucks, but it is the simplest for now.
-export const GO_UPSELL_MESSAGE = "Free usage exceeded, subscribe to Go https://opencode.ai/go"
-
-// Shared with the TUI: does this retry status message indicate a rate-limit /
-// queue ("too many requests" / HTTP 429) condition? retryable() normalizes
-// every 429 variant into a message containing one of these substrings.
-export function isRateLimitMessage(message: string): boolean {
-  const lower = message.toLowerCase()
-  return (
-    lower.includes("too many requests") ||
-    lower.includes("rate limit") ||
-    lower.includes("rate increased too quickly")
-  )
-}
-
-export const RETRY_INITIAL_DELAY = 2000
-export const RETRY_BACKOFF_FACTOR = 2
-export const RETRY_MAX_DELAY_NO_HEADERS = 30_000 // 30 seconds
-export const RETRY_MAX_DELAY = 2_147_483_647 // max 32-bit signed integer for setTimeout
-
-const NETWORK_ERROR_CODES = new Set(["ECONNRESET", "EPIPE", "ETIMEDOUT"])
-const SSE_TIMEOUT_MESSAGE = "SSE read timed out"
-const RETRYABLE_HTTP_STATUS = new Set([429, 500, 502, 503, 504, 529])
-
-/**
- * Single source of truth for "is this transient and retryable?".
- *
- * Used by:
- * - `retryable()` below (processor-level Effect.retry policy via SessionRetry.policy)
- * - `isTransientCapacityError()` in llm.ts (LLM-internal retry around streamText)
- *
- * Both call sites previously had divergent logic — this hung sessions on
- * SSE timeouts that one path retried but the other dropped. See Spec ③.
- */
-export function isRetryableTransientError(error: unknown): boolean {
-  if (!(error instanceof Error)) return false
-
-  const status =
-    (error as { status?: number }).status ??
-    (error as { statusCode?: number }).statusCode ??
-    (error as { response?: { status?: number } }).response?.status
-  if (typeof status === "number" && RETRYABLE_HTTP_STATUS.has(status)) return true
-
-  const code = (error as { code?: string }).code
-  if (typeof code === "string" && NETWORK_ERROR_CODES.has(code)) return true
-
-  if (error.message === SSE_TIMEOUT_MESSAGE) return true
-
-  return false
-}
-
-function cap(ms: number) {
-  return Math.min(ms, RETRY_MAX_DELAY)
-}
-
-export function delay(attempt: number, error?: MessageV2.APIError) {
-  if (error) {
-    const headers = error.data.responseHeaders
-    if (headers) {
-      const retryAfterMs = headers["retry-after-ms"]
-      if (retryAfterMs) {
-        const parsedMs = Number.parseFloat(retryAfterMs)
-        if (!Number.isNaN(parsedMs)) {
-          return cap(parsedMs)
-        }
-      }
-
-      const retryAfter = headers["retry-after"]
-      if (retryAfter) {
-        const parsedSeconds = Number.parseFloat(retryAfter)
-        if (!Number.isNaN(parsedSeconds)) {
-          // convert seconds to milliseconds
-          return cap(Math.ceil(parsedSeconds * 1000))
-        }
-        // Try parsing as HTTP date format
-        const parsed = Date.parse(retryAfter) - Date.now()
-        if (!Number.isNaN(parsed) && parsed > 0) {
-          return cap(Math.ceil(parsed))
-        }
-      }
-
-      return cap(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1))
-    }
-  }
-
-  return cap(Math.min(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1), RETRY_MAX_DELAY_NO_HEADERS))
-}
-
-export function retryable(error: Err) {
-  // context overflow errors should not be retried
-  if (MessageV2.ContextOverflowError.isInstance(error)) return undefined
-
-  // Catch raw Error / network / SSE-timeout BEFORE APIError narrowing.
-  // SessionRetry.policy unwraps Cause<unknown> via opts.parse, but raw
-  // Error instances slip past the APIError check below. Adding this
-  // branch closes that gap. See Spec ③ P2.
-  if (isRetryableTransientError(error as unknown)) {
-    const msg = (error as unknown as Error).message
-    return msg || "Transient network error"
-  }
-
-  if (MessageV2.APIError.isInstance(error)) {
-    const status = error.data.statusCode
-    // 5xx errors are transient server failures and should always be retried,
-    // even when the provider SDK doesn't explicitly mark them as retryable.
-    if (!error.data.isRetryable && !(status !== undefined && status >= 500)) return undefined
-    if (error.data.responseBody?.includes("FreeUsageLimitError")) return GO_UPSELL_MESSAGE
-    return error.data.message.includes("Overloaded") ? "Provider is overloaded" : error.data.message
-  }
-
-  // Check for rate limit patterns in plain text error messages
-  const msg = error.data?.message
-  if (typeof msg === "string") {
-    const lower = msg.toLowerCase()
-    if (
-      lower.includes("rate increased too quickly") ||
-      lower.includes("rate limit") ||
-      lower.includes("too many requests")
-    ) {
-      return msg
-    }
-  }
-
-  const json = iife(() => {
-    try {
-      if (typeof error.data?.message === "string") {
-        const parsed = JSON.parse(error.data.message)
-        return parsed
-      }
-
-      return JSON.parse(error.data.message)
-    } catch {
-      return undefined
-    }
-  })
-  if (!json || typeof json !== "object") return undefined
-  const code = typeof json.code === "string" ? json.code : ""
-
-  if (json.type === "error" && json.error?.type === "too_many_requests") {
-    return "Too Many Requests"
-  }
-  if (code.includes("exhausted") || code.includes("unavailable")) {
-    return "Provider is overloaded"
-  }
-  if (json.type === "error" && typeof json.error?.code === "string" && json.error.code.includes("rate_limit")) {
-    return "Rate Limited"
-  }
-  return undefined
-}
-
-export function policy(opts: {
-  parse: (error: unknown) => Err
-  set: (input: { attempt: number; message: string; next: number }) => Effect.Effect<void>
-}) {
-  return Schedule.fromStepWithMetadata(
-    Effect.succeed((meta: Schedule.InputMetadata<unknown>) => {
-      const error = opts.parse(meta.input)
-      const message = retryable(error)
-      if (!message) return Cause.done(meta.attempt)
-      return Effect.gen(function* () {
-        const wait = delay(meta.attempt, MessageV2.APIError.isInstance(error) ? error : undefined)
-        const now = yield* Clock.currentTimeMillis
-        yield* opts.set({ attempt: meta.attempt, message, next: now + wait })
-        return [meta.attempt, Duration.millis(wait)] as [number, Duration.Duration]
-      })
-    }),
-  )
-}
-
-export * as SessionRetry from "./retry"