@chroxify/eunoe 1.0.0 → 1.2.0

package/src/proxy/rewrite.ts

@@ -1,146 +1,168 @@
-import { searchOnlyInstructions, trimInstructions, TRANSCRIPT_FALLBACK } from "../context/prompts"
-import { recallChunks, recallFor, recallForWith, livePrompt, withRecall } from "../context/recall"
-import { jevReranker, rerankKey } from "../context/rerank"
-import { appendSystem, tailMessages, trimMessages } from "../context/strategies"
-import { blocks, resultText, withoutCacheControl } from "../context/content"
-import { splitTurns, turnFingerprint } from "../context/turns"
-import type { Body, Message, Reranker } from "../context/types"
-import { sessionMessages } from "../transcript/messages"
-import { searchGuide } from "../transcript/search"
-import { RERANK_OFF } from "../config/constants"
-import type { Config } from "../config/types"
+import type { Config } from "../config"
+import type { Body, Message } from "../context/content"
+import { appendSystem, tailMessages, trimMessages } from "../context/fold/strategies"
+import { splitTurns, turnFingerprint } from "../context/fold/turns"
+import { SYSTEM_PROMPT, searchGuide, searchOnlyInstructions, trimInstructions } from "../context/prompts"
+import { identityReranker, type Reranker, withRecall } from "../context/recall"
+import { jevReranker, rerankKey } from "../context/recall/rerank"
+import type { TranscriptRef } from "../transcript/search"
 import { compact } from "./compaction"
-import { DEFAULT_RATIO } from "./constants"
-import { estimator, targetSize } from "./estimate"
-import { loadState, saveState } from "./state"
-import type { Rewrite, RewriteInput } from "./types"
+import { DEFAULT_RATIO, estimator, sizeOf, targetSize } from "./estimate"
+import { messageFingerprint } from "./fingerprint"
+import { activeHandoffs, attachHandoffs, withHandoffs } from "./handoff"
+import { activeRecalls, applyRecall, prefetchFor, wantsRecall } from "./recall"
+import { readState, saveState } from "./state"
+
+export interface RewriteInput {
+  body: Body
+  sessionId: string | null
+  config: Config
+  transcript: TranscriptRef | null
+  window: number | null
+  mayCompact: boolean
+  omittedBefore?: number
+}
+
+export interface Rewrite {
+  body: Body
+  threadKey: string | null
+  note: Record<string, unknown>
+}
+
+interface Prefetched {
+  reranked: boolean
+  rerankError: string | null
+  recalled: number
+}
 
 const pass = (body: Body): Rewrite => ({ body, threadKey: null, note: { action: "pass" } })
 
 const isAgentThread = (body: Body) => Array.isArray(body.tools) && body.tools.length > 0
 
-function messageFingerprint(message: Message) {
-  const hasher = new Bun.CryptoHasher("sha256")
-  hasher.update(JSON.stringify(blocks(message).filter((b) => !(b.type === "text" && String(b.text ?? "").startsWith("<recalled-context>"))).map(withoutCacheControl)))
-  return hasher.digest("hex").slice(0, 24)
-}
+const withSystemPrompt = (system: Body["system"], extra?: string | null) => appendSystem(extra ? appendSystem(system, extra) : system, SYSTEM_PROMPT)
 
-const wantsRecall = (input: RewriteInput) => (input.config.eval?.recall ?? true) && input.config.mode !== "off"
+const ratioOf = (threadKey: string) => readState(threadKey).ratio ?? DEFAULT_RATIO
 
 function rerankModel(config: Config): string | null {
   const model = config.eval?.rerank?.model ?? config.rerank
-  return model && model !== RERANK_OFF ? model : null
+  return model && model !== "off" ? model : null
 }
 
-function droppedChunks(original: Body, result: Rewrite, transcript: string | null) {
-  const kept = new Map<string, string>()
-  for (const message of result.body.messages) for (const b of blocks(message)) if (b.type === "tool_result") kept.set(b.tool_use_id, resultText(b))
-  const chunks = recallChunks(original.messages, kept)
-  return chunks.length || !transcript ? chunks : recallChunks([...sessionMessages(transcript), { role: "user", content: "" }], kept)
+function evalStrategy(input: RewriteInput, turns: Message[][], threadKey: string, guide: string | null): Rewrite | null {
+  const { body, config } = input
+  const strategy = config.eval?.strategy
+  if (strategy !== "guide" && strategy !== "trim" && strategy !== "tail") return null
+  if (!isAgentThread(body)) return pass(body)
+  const counts = { turns: turns.length, messagesIn: body.messages.length }
+  if (strategy === "guide") {
+    return { body: { ...body, system: withSystemPrompt(body.system, guide ? searchOnlyInstructions(guide) : null) }, threadKey, note: { action: "guide", ...counts } }
+  }
+  if (strategy === "trim") {
+    const messages = trimMessages(body.messages, { evidence: config.eval?.evidence ?? true })
+    return { body: { ...body, system: withSystemPrompt(body.system, trimInstructions(guide)), messages }, threadKey, note: { action: "trim", ...counts, messagesOut: messages.length } }
+  }
+  const based = { ...body, system: withSystemPrompt(body.system) }
+  const size = estimator(based, ratioOf(threadKey))
+  let from = 1
+  if (input.window) {
+    const target = targetSize(size, input.window)
+    from = turns.length - 1
+    while (from > 1 && size.of(tailMessages(body.messages, from - 1, guide)) <= target) from -= 1
+  }
+  const messages = tailMessages(body.messages, from, guide)
+  return { body: { ...based, messages }, threadKey, note: { action: "tail", keptTurns: turns.length - from, ...counts, messagesOut: messages.length, estimate: size.of(messages) } }
 }
 
-function recallTarget(original: Body, result: Rewrite): { key: string; text: string } | null {
-  if (!result.threadKey || result.body === original && result.note.action === "pass") return null
-  const live = livePrompt(original.messages)
-  return live ? { key: messageFingerprint(original.messages[live.index]), text: live.text } : null
+function strategize(input: RewriteInput): Rewrite {
+  const { body, sessionId, config, transcript } = input
+  if (config.mode === "off" || !sessionId || !Array.isArray(body.messages) || body.messages.length === 0) return pass(body)
+  const { turns } = splitTurns(body.messages)
+  if (turns.length === 0) return pass(body)
+  const threadKey = `${sessionId}-${turnFingerprint(turns[0])}`
+  const guide = transcript ? searchGuide(transcript) : null
+  const state = readState(threadKey)
+  if (attachHandoffs(body.messages, config, sessionId, state)) saveState(threadKey, state)
+
+  const forced = evalStrategy(input, turns, threadKey, guide)
+  if (forced) return forced
+
+  const based = isAgentThread(body) ? { ...body, system: withSystemPrompt(body.system) } : body
+  if (body.messages.length < 2) return { body: based, threadKey, note: { action: "full", turns: turns.length } }
+  const handoffs = activeHandoffs(state.handoffs)
+  const recalls = wantsRecall(input) ? activeRecalls(state.recalls) : {}
+  const result = compact({
+    body: based,
+    config,
+    state,
+    window: input.window,
+    guide,
+    transcriptDir: transcript && transcript.mode !== "jsonl" ? transcript.dir : null,
+    mayCompact: input.mayCompact,
+    omittedBefore: input.omittedBefore,
+    decorate: (messages) => withRecall(withHandoffs(messages, handoffs), messageFingerprint, recalls),
+  })
+  if (result.stateChanged) saveState(threadKey, state)
+  return { body: result.messages === body.messages ? based : { ...based, messages: result.messages }, threadKey, note: result.note }
 }
 
-function recalled(original: Body, result: Rewrite, transcript: string | null): Rewrite {
-  if (!result.threadKey || result.body === original && result.note.action === "pass") return result
-  const state = loadState(result.threadKey)
-  state.recalls ??= {}
-  const target = recallTarget(original, result)
-  let note = result.note
-  if (target && !(target.key in state.recalls)) {
-    state.recalls[target.key] = recallFor(target.text, droppedChunks(original, result, transcript)) ?? ""
-    saveState(result.threadKey, state)
-    note = { ...note, recalled: state.recalls[target.key].length }
-  }
-  const recalls = Object.fromEntries(Object.entries(state.recalls).filter(([, text]) => text))
-  const messages = withRecall(result.body.messages, messageFingerprint, recalls)
-  return messages === result.body.messages ? { ...result, note } : { ...result, body: { ...result.body, messages }, note }
+function withAttachedHandoffs(result: Rewrite): Rewrite {
+  if (!result.threadKey) return result
+  const handoffs = activeHandoffs(readState(result.threadKey).handoffs)
+  const messages = withHandoffs(result.body.messages, handoffs)
+  if (messages === result.body.messages) return result
+  const attached = Object.values(handoffs)
+  const note = { ...result.note, handoff: attached.reduce((sum, h) => sum + h.text.length, 0), handoffFrom: attached.map((h) => h.label).join(", ") }
+  return { ...result, body: { ...result.body, messages }, note }
 }
 
-export async function prefetchRecall(input: RewriteInput, rerank: Reranker): Promise<boolean> {
-  if (!wantsRecall(input)) return false
-  const result = strategize(input)
-  const target = recallTarget(input.body, result)
-  if (!target) return false
-  const state = loadState(result.threadKey!)
-  state.recalls ??= {}
-  if (target.key in state.recalls) return false
-  const chunks = droppedChunks(input.body, result, input.transcript?.jsonl ?? null)
-  state.recalls[target.key] = (await recallForWith(target.text, chunks, rerank, { candidates: input.config.eval?.rerank?.candidates })) ?? ""
-  saveState(result.threadKey!, state)
-  return true
+function once(input: RewriteInput): Rewrite {
+  const result = withAttachedHandoffs(strategize(input))
+  return wantsRecall(input) ? applyRecall(input, result) : result
 }
 
-export function rewrite(input: RewriteInput): Rewrite {
-  const result = strategize(input)
-  return wantsRecall(input) ? recalled(input.body, result, input.transcript?.jsonl ?? null) : result
+function sentEstimate(result: Rewrite): number {
+  return Math.round(sizeOf(result.body) * (result.threadKey ? ratioOf(result.threadKey) : DEFAULT_RATIO))
 }
 
-export async function rewriteAsync(input: RewriteInput): Promise<Rewrite> {
-  const model = rerankModel(input.config)
-  const key = model ? rerankKey() : null
-  const reranked = model && key ? await prefetchRecall(input, jevReranker(model, key)) : false
-  const result = rewrite(input)
-  return reranked ? { ...result, note: { ...result.note, reranked: model } } : result
+function overLimit(input: RewriteInput, result: Rewrite): boolean {
+  if (!input.window || !result.threadKey || input.mayCompact === false || result.note.action === "pass") return false
+  return sentEstimate(result) > input.config.compactAt * input.window
 }
 
-function strategize(input: RewriteInput): Rewrite {
-  const { body, sessionId, config, transcript } = input
-  if (config.mode === "off" || !sessionId || !Array.isArray(body.messages) || body.messages.length === 0) return pass(body)
-  const { turns } = splitTurns(body.messages)
-  if (turns.length === 0) return pass(body)
-  const threadKey = `${sessionId}-${turnFingerprint(turns[0])}`
-  const guide = transcript ? searchGuide(transcript) : null
+function carried(from: Rewrite, to: Rewrite): Rewrite {
+  const actionsOf = ({ note }: Rewrite) => (note.actions as string[] | undefined) ?? []
+  const actions = [...actionsOf(from), ...actionsOf(to)]
+  if (!from.note.compacted && actions.length === 0) return to
+  return { ...to, note: { ...to.note, compacted: Boolean(to.note.compacted || from.note.compacted), actions } }
+}
 
-  switch (config.eval?.strategy) {
-    case "guide": {
-      if (!isAgentThread(body)) return pass(body)
-      return {
-        body: guide ? { ...body, system: appendSystem(body.system, searchOnlyInstructions(guide)) } : body,
-        threadKey,
-        note: { action: "guide", turns: turns.length, messagesIn: body.messages.length },
-      }
-    }
-    case "tail": {
-      if (!isAgentThread(body)) return pass(body)
-      const size = estimator(body, loadState(threadKey).ratio ?? DEFAULT_RATIO)
-      let from = 1
-      if (config.eval.tailTurns) {
-        from = Math.max(1, turns.length - config.eval.tailTurns)
-      } else if (input.window) {
-        const target = targetSize(size, input.window)
-        from = turns.length - 1
-        while (from > 1 && size.of(tailMessages(body.messages, from - 1, guide)) <= target) from -= 1
-      }
-      const messages = tailMessages(body.messages, from, guide)
-      return {
-        body: { ...body, messages },
-        threadKey,
-        note: { action: "tail", keptTurns: turns.length - from, turns: turns.length, messagesIn: body.messages.length, messagesOut: messages.length, estimate: size.of(messages) },
-      }
-    }
-    case "trim": {
-      if (!isAgentThread(body)) return pass(body)
-      const messages = trimMessages(body.messages, { evidence: config.eval?.evidence ?? true })
-      return {
-        body: { ...body, system: appendSystem(body.system, trimInstructions(guide ?? TRANSCRIPT_FALLBACK)), messages },
-        threadKey,
-        note: { action: "trim", turns: turns.length, messagesIn: body.messages.length, messagesOut: messages.length },
-      }
-    }
-  }
+export function rewrite(input: RewriteInput, before?: Rewrite): Rewrite {
+  const result = before ? carried(before, once(input)) : once(input)
+  if (!overLimit(input, result)) return result
+  const recut = carried(result, once(input))
+  if (!overLimit(input, recut)) return { ...recut, note: { ...recut.note, fit: "recut" } }
+  const bare = carried(recut, once({ ...input, config: { ...input.config, eval: { ...input.config.eval, recall: false } } }))
+  return { ...bare, note: { ...bare.note, fit: overLimit(input, bare) ? "over" : "bare", fitEstimate: sentEstimate(bare) } }
+}
 
-  if (body.messages.length < 2) return { body, threadKey, note: { action: "full", turns: turns.length } }
-  const state = loadState(threadKey)
-  const result = compact({ body, config, state, window: input.window, guide, mayCompact: input.mayCompact, omittedBefore: input.omittedBefore })
-  if (result.stateChanged) saveState(threadKey, state)
-  return {
-    body: result.messages === body.messages ? body : { ...body, messages: result.messages },
-    threadKey,
-    note: result.note,
-  }
+export async function prefetchRecall(input: RewriteInput, rerank: Reranker): Promise<Prefetched | null> {
+  if (!wantsRecall(input)) return null
+  const recalled = await prefetchFor(input, strategize(input), rerank)
+  return recalled === null ? null : { reranked: rerank !== identityReranker, rerankError: null, recalled }
+}
+
+export async function rewriteAsync(input: RewriteInput): Promise<Rewrite> {
+  const model = wantsRecall(input) ? rerankModel(input.config) : null
+  const key = model ? rerankKey() : null
+  if (!model || !key) return rewrite(input)
+  const failure = { reason: null as string | null }
+  const reranker = jevReranker(model, key, input.config.eval?.rerank?.endpoint, (reason) => {
+    failure.reason = reason
+  })
+  const first = strategize(input)
+  const recalled = await prefetchFor(input, first, reranker)
+  const final = rewrite(input, first)
+  if (recalled === null) return final
+  const outcome = failure.reason ? { rerankError: `${model}: ${failure.reason}` } : { reranked: model }
+  return { ...final, note: { ...final.note, recalled, ...outcome } }
 }

package/src/proxy/server.ts

@@ -1,25 +1,47 @@
 import path from "node:path"
-import { claudeConfigDirs, loadConfig, settingsFor } from "../config"
-import type { Config } from "../config/types"
-import { wellFormed } from "../context/content"
-import type { Body } from "../context/types"
+import { type Config, claudeConfigDirs, readConfig, settingsFor } from "../config"
+import { type Body, wellFormed } from "../context/content"
 import { findSessionFile } from "../transcript/locate"
 import { prepareTranscript } from "../transcript/search"
 import { VERSION } from "../version"
-import { CANONICAL_HEADER, HEALTH_PATH, IDLE_TIMEOUT_SECONDS, LOGGED_ERROR_CHARS, OMITTED_BEFORE_HEADER, SESSION_HEADER, TRANSCRIPT_HEADER, WINDOW_HEADER } from "./constants"
 import { applyCanonical } from "./canonical"
 import { sizeOf } from "./estimate"
-import { contextFingerprint } from "./fingerprint"
+import { type ContextFingerprint, contextFingerprint } from "./fingerprint"
 import { logRequest } from "./log"
 import { rewriteAsync } from "./rewrite"
 import { recordSession } from "./sessions"
-import { loadState, saveState } from "./state"
-import type { ContextFingerprint, Health, Note } from "./types"
+import { readState, saveState } from "./state"
 import { inputTokens, watchUsage } from "./usage"
 import { resolveWindow } from "./window"
 
-export function sessionIdOf(headers: Headers, body: Body): string | null {
-  const header = headers.get(SESSION_HEADER)
+export interface Health {
+  ok: boolean
+  version: string
+  mode: Config["mode"]
+  pid: number
+  startedAt?: number
+}
+
+interface Outgoing {
+  note: Record<string, unknown>
+  threadKey: string | null
+  bodyText: string | undefined
+  sentSize: number
+  givenSize: number
+  fixedSize: number
+  sent: (ContextFingerprint & { session: string | null }) | null
+}
+
+export const HEALTH_PATH = "/_eunoe/health"
+
+const startedAt = Date.now()
+
+const trustedHeader = (request: Request, config: Config, name: string) => (config.eval?.trustHeaders === true ? request.headers.get(`x-eunoe-${name}`) : null)
+
+const clipped = (error: string) => error.slice(0, 500)
+
+function sessionIdOf(headers: Headers, body: Body): string | null {
+  const header = headers.get("x-claude-code-session-id")
   if (header) return header
   try {
     return JSON.parse(body.metadata?.user_id ?? "{}").session_id ?? null
@@ -35,75 +57,113 @@ function forwardableHeaders(headers: Headers) {
   return out
 }
 
+function overflowTokens(errorText: string): number | null {
+  const tokens = Number(errorText.match(/prompt is too long[^0-9]*(\d+)\s*tokens?\s*>\s*(\d+)/i)?.[1])
+  return Number.isFinite(tokens) && tokens > 0 ? tokens : null
+}
+
 async function prepare(request: Request, body: Body, base: Config, isCountTokens: boolean) {
   const sessionId = sessionIdOf(request.headers, body)
   const config = settingsFor(base, sessionId)
   const trusted = config.eval?.trustHeaders === true
-  const transcriptOverride = trusted ? request.headers.get(TRANSCRIPT_HEADER) : null
+  const transcriptOverride = trustedHeader(request, config, "transcript")
   const sessionFile = transcriptOverride ?? (sessionId ? findSessionFile(sessionId, claudeConfigDirs(config)) : null)
   if (sessionId && !trusted) recordSession(sessionId, config.mode, sessionFile)
   if (config.mode === "off") return rewriteAsync({ body, sessionId, config, transcript: null, window: null, mayCompact: false })
-  const transcript = sessionFile && sessionId
-    ? prepareTranscript(config.search, sessionFile, transcriptOverride ? path.basename(transcriptOverride, ".jsonl") : sessionId)
-    : null
+  const transcriptKey = transcriptOverride ? path.basename(transcriptOverride, ".jsonl") : sessionId
+  const transcript = sessionFile && sessionId && transcriptKey ? prepareTranscript(config.search, sessionFile, transcriptKey) : null
   const needsWindow = !config.eval?.strategy || config.eval.strategy === "tail"
-  const windowOverride = trusted ? Number(request.headers.get(WINDOW_HEADER)) || null : null
-  const window = windowOverride ?? config.window ?? (needsWindow ? await resolveWindow(body.model, request.headers, config.upstream) : null)
+  const windowOverride = Number(trustedHeader(request, config, "window")) || null
+  let resolved: number | null = null
+  if (needsWindow) resolved = await resolveWindow(body.model, request.headers, config.upstream)
   return rewriteAsync({
     body,
     sessionId,
     config,
     transcript,
-    window,
+    window: windowOverride ?? config.window ?? resolved,
     mayCompact: !isCountTokens,
-    omittedBefore: trusted ? Number(request.headers.get(OMITTED_BEFORE_HEADER) ?? 0) : 0,
+    omittedBefore: Number(trustedHeader(request, config, "omitted-before") ?? 0),
   })
 }
 
+function saveRatio(threadKey: string, ratio: (previous: number | undefined) => number) {
+  const state = readState(threadKey)
+  state.ratio = ratio(state.ratio)
+  saveState(threadKey, state)
+}
+
 export async function handle(request: Request): Promise<Response> {
-  const config = loadConfig()
+  try {
+    return await route(request)
+  } catch (error) {
+    logRequest({ path: new URL(request.url).pathname, status: 502, action: "upstream-unreachable", error: clipped(String(error)) })
+    return Response.json({ type: "error", error: { type: "api_error", message: `eunoe could not reach the API: ${String(error)}` } }, { status: 502 })
+  }
+}
+
+async function route(request: Request): Promise<Response> {
+  const config = readConfig()
   const url = new URL(request.url)
-  if (url.pathname === HEALTH_PATH) return Response.json({ ok: true, version: VERSION, mode: config.mode, pid: process.pid } satisfies Health)
+  if (url.pathname === HEALTH_PATH) return Response.json({ ok: true, version: VERSION, mode: config.mode, pid: process.pid, startedAt } satisfies Health)
   const headers = new Headers(request.headers)
-  headers.delete("host")
-  headers.delete("content-length")
-  headers.delete("accept-encoding")
+  for (const name of ["host", "content-length", "accept-encoding"]) headers.delete(name)
 
-  let bodyText = request.method === "GET" || request.method === "HEAD" ? undefined : await request.text()
+  let givenText: string | undefined
+  if (request.method !== "GET" && request.method !== "HEAD") givenText = await request.text()
   const isMessages = request.method === "POST" && url.pathname.startsWith("/v1/messages")
   const isCountTokens = url.pathname.includes("count_tokens")
-  let note: Note = { action: "pass" }
-  let threadKey: string | null = null
-  let sentSize = 0
-  let givenSize = 0
-  let sent: (ContextFingerprint & { session: string | null }) | null = null
 
-  if (bodyText && isMessages) {
+  const build = async (): Promise<Outgoing> => {
+    const passthrough: Outgoing = { note: { action: "pass" }, threadKey: null, bodyText: givenText, sentSize: 0, givenSize: 0, fixedSize: 0, sent: null }
+    if (!givenText || !isMessages) return passthrough
     try {
-      const given = JSON.parse(bodyText) as Body
-      const canonicalFile = config.eval?.trustHeaders ? request.headers.get(CANONICAL_HEADER) : null
+      const given = JSON.parse(givenText) as Body
+      const canonicalFile = trustedHeader(request, config, "canonical")
       const canonical = canonicalFile ? applyCanonical(given, canonicalFile) : null
-      const body = canonical?.body ?? given
-      const result = await prepare(request, body, config, isCountTokens)
-      note = canonical ? { ...result.note, canonical: canonical.status } : result.note
-      threadKey = result.threadKey
-      if (result.body !== given) bodyText = JSON.stringify(result.body, wellFormed)
-      sentSize = sizeOf(result.body)
-      givenSize = result.body === given ? sentSize : sizeOf(given)
-      if (config.eval) sent = { session: sessionIdOf(request.headers, given), ...contextFingerprint(result.body), given: contextFingerprint(given) }
+      const result = await prepare(request, canonical?.body ?? given, config, isCountTokens)
+      const sentSize = sizeOf(result.body)
+      return {
+        note: canonical ? { ...result.note, canonical: canonical.status } : result.note,
+        threadKey: result.threadKey,
+        bodyText: result.body !== given ? JSON.stringify(result.body, wellFormed) : givenText,
+        sentSize,
+        givenSize: result.body === given ? sentSize : sizeOf(given),
+        fixedSize: sizeOf({ ...result.body, messages: [] }),
+        sent: config.eval ? { session: sessionIdOf(request.headers, given), ...contextFingerprint(result.body), given: contextFingerprint(given) } : null,
+      }
     } catch (error) {
-      note = { action: "error-passthrough", error: String(error) }
+      return { ...passthrough, note: { action: "error-passthrough", error: String(error) } }
     }
   }
+  const send = (body: string | undefined) => fetch(config.upstream + url.pathname + url.search, { method: request.method, headers, body })
 
-  const upstream = await fetch(config.upstream + url.pathname + url.search, { method: request.method, headers, body: bodyText })
+  let out = await build()
+  let upstream = await send(out.bodyText)
+  const errorResponse = (text: string) => new Response(text, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
 
-  if (upstream.status >= 400 && note.action !== "pass") {
+  if (upstream.status >= 400 && out.note.action !== "pass") {
     const errorText = await upstream.text()
-    logRequest({ path: url.pathname, status: upstream.status, thread: threadKey, ...note, error: errorText.slice(0, LOGGED_ERROR_CHARS) })
-    return new Response(errorText, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
+    const overflow = overflowTokens(errorText)
+    const logged = { path: url.pathname, status: upstream.status, thread: out.threadKey, ...out.note }
+    if (!overflow || !out.threadKey || out.sentSize === 0 || isCountTokens) {
+      logRequest({ ...logged, error: clipped(errorText) })
+      return errorResponse(errorText)
+    }
+    const sentSize = out.sentSize
+    saveRatio(out.threadKey, (previous) => Math.max(previous ?? 0, overflow / sentSize) * 1.1)
+    logRequest({ ...logged, overflow, error: clipped(errorText) })
+    out = await build()
+    out = { ...out, note: { ...out.note, healed: overflow } }
+    upstream = await send(out.bodyText)
+    if (upstream.status >= 400) {
+      const retryError = await upstream.text()
+      logRequest({ path: url.pathname, status: upstream.status, thread: out.threadKey, ...out.note, error: clipped(retryError) })
+      return errorResponse(retryError)
+    }
   }
 
+  const { note, threadKey, sentSize, givenSize, fixedSize, sent } = out
   const response = new Response(upstream.body, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
   if (note.action === "pass" || !isMessages || isCountTokens) {
     if (note.action !== "pass" || sent) logRequest({ path: url.pathname, status: upstream.status, ...note, ...(sent && { context: sent }) })
@@ -123,16 +183,13 @@ export async function handle(request: Request): Promise<Response> {
       uncached: usage.input_tokens ?? 0,
       charsIn: givenSize,
       charsOut: sentSize,
+      charsFixed: fixedSize,
       ...(sent && { context: sent }),
     })
-    if (threadKey && input > 0 && sentSize > 0) {
-      const state = loadState(threadKey)
-      state.ratio = input / sentSize
-      saveState(threadKey, state)
-    }
+    if (threadKey && input > 0 && sentSize > 0) saveRatio(threadKey, () => input / sentSize)
   })
 }
 
 export function serve(port: number) {
-  return Bun.serve({ port, hostname: "127.0.0.1", idleTimeout: IDLE_TIMEOUT_SECONDS, fetch: handle })
+  return Bun.serve({ port, hostname: "127.0.0.1", idleTimeout: 255, fetch: handle })
 }

package/src/proxy/sessions.ts

@@ -1,12 +1,18 @@
 import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from "node:fs"
-import { EUNOE_DIR, paths } from "../config/constants"
-import type { Mode } from "../config/types"
-import { SESSION_HEAD_BYTES, SESSION_SEEN_INTERVAL_MS, SESSIONS_KEPT } from "./constants"
-import type { SeenSession } from "./types"
+import type { Mode } from "../config"
+import { EUNOE_DIR, paths } from "../config/paths"
+
+interface SeenSession {
+  lastSeen: string
+  mode: Mode
+  cwd?: string
+}
+
+const HEAD_BYTES = 65_536
 
 let seen: Record<string, SeenSession> | null = null
 
-function load(): Record<string, SeenSession> {
+function readSeen(): Record<string, SeenSession> {
   try {
     return JSON.parse(readFileSync(paths.sessions, "utf8"))
   } catch {
@@ -14,27 +20,39 @@ function load(): Record<string, SeenSession> {
   }
 }
 
-function cwdOf(sessionFile: string): string | undefined {
+const newestFirst = (entries: Array<[string, SeenSession]>) => entries.sort(([, a], [, b]) => b.lastSeen.localeCompare(a.lastSeen))
+
+export function cwdOf(sessionFile: string): string | undefined {
   try {
     const fd = openSync(sessionFile, "r")
-    const buffer = Buffer.alloc(SESSION_HEAD_BYTES)
-    const read = readSync(fd, buffer, 0, SESSION_HEAD_BYTES, 0)
+    const buffer = Buffer.alloc(HEAD_BYTES)
+    const read = readSync(fd, buffer, 0, HEAD_BYTES, 0)
     closeSync(fd)
-    return buffer.subarray(0, read).toString("utf8").match(/"cwd":"((?:[^"\\]|\\.)*)"/)?.[1]
+    return buffer
+      .subarray(0, read)
+      .toString("utf8")
+      .match(/"cwd":"((?:[^"\\]|\\.)*)"/)?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+export function titleOf(sessionFile: string): string | undefined {
+  try {
+    return readFileSync(sessionFile, "utf8").match(/"aiTitle":"((?:[^"\\]|\\.)*)"/)?.[1]
   } catch {
     return undefined
   }
 }
 
 export function recordSession(sessionId: string, mode: Mode, sessionFile: string | null) {
-  seen ??= load()
+  seen ??= readSeen()
   const previous = seen[sessionId]
   const now = Date.now()
   const needsCwd = !previous?.cwd && sessionFile !== null
-  if (previous && previous.mode === mode && !needsCwd && now - Date.parse(previous.lastSeen) < SESSION_SEEN_INTERVAL_MS) return
+  if (previous && previous.mode === mode && !needsCwd && now - Date.parse(previous.lastSeen) < 30_000) return
   seen[sessionId] = { lastSeen: new Date(now).toISOString(), mode, cwd: previous?.cwd ?? (sessionFile ? cwdOf(sessionFile) : undefined) }
-  const kept = Object.entries(seen).sort(([, a], [, b]) => b.lastSeen.localeCompare(a.lastSeen)).slice(0, SESSIONS_KEPT)
-  seen = Object.fromEntries(kept)
+  seen = Object.fromEntries(newestFirst(Object.entries(seen)).slice(0, 200))
   try {
     mkdirSync(EUNOE_DIR, { recursive: true })
     writeFileSync(paths.sessions, JSON.stringify(seen, null, 2))
@@ -42,5 +60,5 @@ export function recordSession(sessionId: string, mode: Mode, sessionFile: string
 }
 
 export function seenSessions(): Array<[string, SeenSession]> {
-  return Object.entries(load()).sort(([, a], [, b]) => b.lastSeen.localeCompare(a.lastSeen))
+  return newestFirst(Object.entries(readSeen()))
 }

package/src/proxy/state.ts

@@ -1,13 +1,27 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import path from "node:path"
-import { paths } from "../config/constants"
-import type { ThreadState } from "./types"
+import { paths } from "../config/paths"
+
+export interface Handoff {
+  label: string
+  source: string
+  text: string
+}
+
+export interface ThreadState {
+  handoffs?: Record<string, Handoff | null>
+  cut?: string
+  keep?: number
+  cleared?: number
+  ratio?: number
+  recalls?: Record<string, string>
+}
 
 function stateFile(key: string) {
   return path.join(paths.threads, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`)
 }
 
-export function loadState(key: string): ThreadState {
+export function readState(key: string): ThreadState {
   try {
     return JSON.parse(readFileSync(stateFile(key), "utf8"))
   } catch {