@chroxify/eunoe 0.0.0-stage → 1.0.0

package/src/proxy/compaction.ts

@@ -0,0 +1,110 @@
+import { CLEARED_OUTPUT } from "../context/prompts"
+import { clearToolResults, compactMessages, countToolResults } from "../context/strategies"
+import { splitTurns, turnFingerprint } from "../context/turns"
+import { DEFAULT_RATIO, PROTECTED_OUTPUTS } from "./constants"
+import { estimator, targetSize } from "./estimate"
+import { resetCut } from "./state"
+import type { Message } from "../context/types"
+import type { CompactInput, CompactResult } from "./types"
+
+function settledCut(turns: Message[][], index: number) {
+  let cut = index
+  while (cut > 1 && JSON.stringify(turns[cut][0].content).includes("[Request interrupted")) cut -= 1
+  return cut
+}
+
+export function compact({ body, config, state, window, guide, mayCompact, omittedBefore = 0 }: CompactInput): CompactResult {
+  const { turns } = splitTurns(body.messages)
+  let stateChanged = false
+
+  let cutIndex = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1
+  if (state.cut && cutIndex === -1) {
+    resetCut(state)
+    stateChanged = true
+  }
+  const rolling = config.eval?.rolling ?? (config.mode === "default" ? { keep: config.keep, budget: config.budget } : undefined)
+  if (cutIndex <= 0 && config.eval?.forceCut && turns.length >= 3) {
+    const forced = settledCut(turns, Math.max(1, turns.length - 1 - (rolling?.keep ?? 1)))
+    cutIndex = forced
+    state.cut = turnFingerprint(turns[forced])
+    stateChanged = true
+  }
+
+  const configuredKeep = config.keepTurns === "all" ? Number.MAX_SAFE_INTEGER : config.keepTurns
+  const liveLength = () => turns.slice(Math.max(cutIndex, 0)).flat().length
+  const compacted = () => cutIndex > 0
+    ? compactMessages(body.messages, cutIndex, { keepTurns: state.keep ?? configuredKeep, guide, omittedBefore, evidence: config.eval?.evidence ?? true })
+    : body.messages
+  const build = () => {
+    const messages = compacted()
+    return state.cleared ? clearToolResults(messages, messages.length - liveLength(), state.cleared, CLEARED_OUTPUT) : messages
+  }
+
+  const size = estimator(body, state.ratio ?? DEFAULT_RATIO)
+  const limit = window ? config.compactAt * window : Number.POSITIVE_INFINITY
+  const target = window ? targetSize(size, window) : Number.POSITIVE_INFINITY
+
+  let messages = build()
+  let estimate = size.of(messages)
+  const actions: string[] = []
+  const current = turns.length - 1
+  const moveCut = (index: number, action: string) => {
+    cutIndex = index
+    resetCut(state)
+    state.cut = turnFingerprint(turns[index])
+    actions.push(action)
+    messages = build()
+    estimate = size.of(messages)
+  }
+
+  if (mayCompact && rolling) {
+    const next = settledCut(turns, current - rolling.keep)
+    const backlog = size.of(turns.slice(Math.max(cutIndex, 0), Math.max(next, 0)).flat()) - size.fixed
+    if (next >= 1 && next > cutIndex && backlog > rolling.budget) {
+      moveCut(next, "roll")
+      stateChanged = true
+    }
+  }
+
+  if (mayCompact && estimate > limit) {
+    if (current > 0 && current > cutIndex) moveCut(current, "cut")
+    while (estimate > target) {
+      const keep = Math.min(state.keep ?? configuredKeep, cutIndex - 1)
+      if (cutIndex > 0 && keep > 0) {
+        state.keep = keep - 1
+        actions.push(`keep=${state.keep}`)
+      } else {
+        const unclearedLive = compacted()
+        const total = countToolResults(unclearedLive, unclearedLive.length - liveLength())
+        const remaining = total - (state.cleared ?? 0) - PROTECTED_OUTPUTS
+        if (remaining <= 0) {
+          actions.push("stuck")
+          break
+        }
+        state.cleared = (state.cleared ?? 0) + Math.ceil(remaining / 2)
+        actions.push(`cleared=${state.cleared}`)
+      }
+      messages = build()
+      estimate = size.of(messages)
+    }
+    stateChanged = true
+  }
+
+  return {
+    messages,
+    stateChanged,
+    note: {
+      action: cutIndex > 0 ? "compact" : "full",
+      compacted: actions.includes("cut") || actions.includes("roll"),
+      actions: actions.length ? actions : undefined,
+      cutTurn: cutIndex > 0 ? cutIndex : null,
+      keep: state.keep,
+      cleared: state.cleared,
+      turns: turns.length,
+      messagesIn: body.messages.length,
+      messagesOut: messages.length,
+      estimate,
+      window,
+    },
+  }
+}

package/src/proxy/constants.ts

@@ -0,0 +1,29 @@
+export const HEALTH_PATH = "/_eunoe/health"
+export const SESSION_HEADER = "x-claude-code-session-id"
+export const TRANSCRIPT_HEADER = "x-eunoe-transcript"
+export const OMITTED_BEFORE_HEADER = "x-eunoe-omitted-before"
+export const CANONICAL_HEADER = "x-eunoe-canonical"
+export const WINDOW_HEADER = "x-eunoe-window"
+export const BILLING_LINE = /^x-anthropic-billing-header:[^\n]*/
+
+export const TARGET_SHARE = 0.3
+export const PROTECTED_OUTPUTS = 5
+
+export const DEFAULT_RATIO = 1 / 3.6
+export const MEDIA_CHARS = 5_800
+export const MEDIA_MIN_LENGTH = 2_000
+
+export const MODEL_HEADERS = ["authorization", "x-api-key", "anthropic-version", "anthropic-beta"]
+export const ANTHROPIC_VERSION = "2023-06-01"
+export const MODEL_LOOKUP_TIMEOUT_MS = 5_000
+
+export const MAX_EVENT_BUFFER = 4_000_000
+export const LOGGED_ERROR_CHARS = 500
+export const IDLE_TIMEOUT_SECONDS = 255
+
+export const SESSION_SEEN_INTERVAL_MS = 30_000
+export const SESSION_HEAD_BYTES = 65_536
+export const SESSIONS_KEPT = 200
+
+export const FINGERPRINT_LENGTH = 12
+export const SKILL_MARKER = /Base directory for this skill: ([^\s"\\]+)/g

package/src/proxy/estimate.ts

@@ -0,0 +1,26 @@
+import type { Body, Message } from "../context/types"
+import { MEDIA_CHARS, MEDIA_MIN_LENGTH, TARGET_SHARE } from "./constants"
+import type { Estimator } from "./types"
+
+export function sizeOf(body: Pick<Body, "system" | "tools" | "messages">): number {
+  let media = 0
+  const json = JSON.stringify({ system: body.system, tools: body.tools, messages: body.messages }, (key, value) => {
+    if (key === "data" && typeof value === "string" && value.length > MEDIA_MIN_LENGTH) {
+      media += 1
+      return ""
+    }
+    return value
+  })
+  return json.length + media * MEDIA_CHARS
+}
+
+export function estimator(body: Body, ratio: number): Estimator {
+  return {
+    of: (messages: Message[]) => Math.round(sizeOf({ ...body, messages }) * ratio),
+    fixed: Math.round(sizeOf({ ...body, messages: [] }) * ratio),
+  }
+}
+
+export function targetSize(size: Estimator, window: number): number {
+  return size.fixed + TARGET_SHARE * Math.max(0, window - size.fixed)
+}

package/src/proxy/fingerprint.ts

@@ -0,0 +1,15 @@
+import type { Body } from "../context/types"
+import { FINGERPRINT_LENGTH, SKILL_MARKER } from "./constants"
+import type { ContextFingerprint } from "./types"
+
+const hash = (value: unknown) => {
+  const hasher = new Bun.CryptoHasher("sha256")
+  hasher.update(JSON.stringify(value ?? null, (key, inner) => (key === "cache_control" ? undefined : inner)))
+  return hasher.digest("hex").slice(0, FINGERPRINT_LENGTH)
+}
+
+export function contextFingerprint(body: Body): ContextFingerprint {
+  const skills = new Set<string>()
+  for (const match of JSON.stringify(body.messages ?? []).matchAll(SKILL_MARKER)) skills.add(match[1].split("/").at(-1)!)
+  return { system: hash(body.system), tools: hash(body.tools), skills: [...skills].sort() }
+}

package/src/proxy/log.ts

@@ -0,0 +1,9 @@
+import { appendFileSync, mkdirSync } from "node:fs"
+import { EUNOE_DIR, paths } from "../config/constants"
+
+export function logRequest(record: Record<string, unknown>) {
+  try {
+    mkdirSync(EUNOE_DIR, { recursive: true })
+    appendFileSync(paths.requests, JSON.stringify({ ts: new Date().toISOString(), ...record }) + "\n")
+  } catch {}
+}

package/src/proxy/rewrite.ts

@@ -0,0 +1,146 @@
+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 { compact } from "./compaction"
+import { DEFAULT_RATIO } from "./constants"
+import { estimator, targetSize } from "./estimate"
+import { loadState, saveState } from "./state"
+import type { Rewrite, RewriteInput } from "./types"
+
+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 wantsRecall = (input: RewriteInput) => (input.config.eval?.recall ?? true) && input.config.mode !== "off"
+
+function rerankModel(config: Config): string | null {
+  const model = config.eval?.rerank?.model ?? config.rerank
+  return model && model !== RERANK_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 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 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 }
+}
+
+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
+}
+
+export function rewrite(input: RewriteInput): Rewrite {
+  const result = strategize(input)
+  return wantsRecall(input) ? recalled(input.body, result, input.transcript?.jsonl ?? null) : result
+}
+
+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 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
+
+  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 },
+      }
+    }
+  }
+
+  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,
+  }
+}

package/src/proxy/server.ts

@@ -0,0 +1,138 @@
+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 { 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 { logRequest } from "./log"
+import { rewriteAsync } from "./rewrite"
+import { recordSession } from "./sessions"
+import { loadState, saveState } from "./state"
+import type { ContextFingerprint, Health, Note } from "./types"
+import { inputTokens, watchUsage } from "./usage"
+import { resolveWindow } from "./window"
+
+export function sessionIdOf(headers: Headers, body: Body): string | null {
+  const header = headers.get(SESSION_HEADER)
+  if (header) return header
+  try {
+    return JSON.parse(body.metadata?.user_id ?? "{}").session_id ?? null
+  } catch {
+    return null
+  }
+}
+
+function forwardableHeaders(headers: Headers) {
+  const out = new Headers(headers)
+  out.delete("content-encoding")
+  out.delete("content-length")
+  return out
+}
+
+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 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 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)
+  return rewriteAsync({
+    body,
+    sessionId,
+    config,
+    transcript,
+    window,
+    mayCompact: !isCountTokens,
+    omittedBefore: trusted ? Number(request.headers.get(OMITTED_BEFORE_HEADER) ?? 0) : 0,
+  })
+}
+
+export async function handle(request: Request): Promise<Response> {
+  const config = loadConfig()
+  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)
+  const headers = new Headers(request.headers)
+  headers.delete("host")
+  headers.delete("content-length")
+  headers.delete("accept-encoding")
+
+  let bodyText = request.method === "GET" || request.method === "HEAD" ? undefined : 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) {
+    try {
+      const given = JSON.parse(bodyText) as Body
+      const canonicalFile = config.eval?.trustHeaders ? request.headers.get(CANONICAL_HEADER) : null
+      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) }
+    } catch (error) {
+      note = { action: "error-passthrough", error: String(error) }
+    }
+  }
+
+  const upstream = await fetch(config.upstream + url.pathname + url.search, { method: request.method, headers, body: bodyText })
+
+  if (upstream.status >= 400 && 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 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 }) })
+    return response
+  }
+
+  return watchUsage(response, (usage) => {
+    const input = inputTokens(usage)
+    logRequest({
+      path: url.pathname,
+      status: upstream.status,
+      thread: threadKey,
+      ...note,
+      input,
+      cacheRead: usage.cache_read_input_tokens ?? 0,
+      cacheWrite: usage.cache_creation_input_tokens ?? 0,
+      uncached: usage.input_tokens ?? 0,
+      charsIn: givenSize,
+      charsOut: sentSize,
+      ...(sent && { context: sent }),
+    })
+    if (threadKey && input > 0 && sentSize > 0) {
+      const state = loadState(threadKey)
+      state.ratio = input / sentSize
+      saveState(threadKey, state)
+    }
+  })
+}
+
+export function serve(port: number) {
+  return Bun.serve({ port, hostname: "127.0.0.1", idleTimeout: IDLE_TIMEOUT_SECONDS, fetch: handle })
+}

package/src/proxy/sessions.ts

@@ -0,0 +1,46 @@
+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"
+
+let seen: Record<string, SeenSession> | null = null
+
+function load(): Record<string, SeenSession> {
+  try {
+    return JSON.parse(readFileSync(paths.sessions, "utf8"))
+  } catch {
+    return {}
+  }
+}
+
+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)
+    closeSync(fd)
+    return buffer.subarray(0, read).toString("utf8").match(/"cwd":"((?:[^"\\]|\\.)*)"/)?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+export function recordSession(sessionId: string, mode: Mode, sessionFile: string | null) {
+  seen ??= load()
+  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
+  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)
+  try {
+    mkdirSync(EUNOE_DIR, { recursive: true })
+    writeFileSync(paths.sessions, JSON.stringify(seen, null, 2))
+  } catch {}
+}
+
+export function seenSessions(): Array<[string, SeenSession]> {
+  return Object.entries(load()).sort(([, a], [, b]) => b.lastSeen.localeCompare(a.lastSeen))
+}

package/src/proxy/state.ts

@@ -0,0 +1,27 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import { paths } from "../config/constants"
+import type { ThreadState } from "./types"
+
+function stateFile(key: string) {
+  return path.join(paths.threads, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`)
+}
+
+export function loadState(key: string): ThreadState {
+  try {
+    return JSON.parse(readFileSync(stateFile(key), "utf8"))
+  } catch {
+    return {}
+  }
+}
+
+export function saveState(key: string, state: ThreadState) {
+  mkdirSync(paths.threads, { recursive: true })
+  writeFileSync(stateFile(key), JSON.stringify(state))
+}
+
+export function resetCut(state: ThreadState) {
+  delete state.cut
+  delete state.keep
+  delete state.cleared
+}

package/src/proxy/types.ts

@@ -0,0 +1,82 @@
+import type { Config } from "../config/types"
+import type { Body, Message } from "../context/types"
+import type { TranscriptRef } from "../transcript/types"
+
+export interface ThreadState {
+  cut?: string
+  keep?: number
+  cleared?: number
+  ratio?: number
+  recalls?: Record<string, string>
+}
+
+export type Note = Record<string, unknown>
+
+export interface ContextFingerprint {
+  system: string
+  tools: string
+  skills: string[]
+  given?: ContextFingerprint
+}
+
+export interface Canonical {
+  system: Body["system"]
+  tools: Body["tools"]
+}
+
+export interface CanonicalResult {
+  body: Body
+  status: "applied" | "captured" | "skipped"
+}
+
+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: Note
+}
+
+export interface CompactInput {
+  body: Body
+  config: Config
+  state: ThreadState
+  window: number | null
+  guide: string | null
+  mayCompact: boolean
+  omittedBefore?: number
+}
+
+export interface CompactResult {
+  messages: Message[]
+  stateChanged: boolean
+  note: Note
+}
+
+export interface Estimator {
+  of: (messages: Message[]) => number
+  fixed: number
+}
+
+export type Usage = Record<string, number>
+
+export interface SeenSession {
+  lastSeen: string
+  mode: Config["mode"]
+  cwd?: string
+}
+
+export interface Health {
+  ok: boolean
+  version: string
+  mode: Config["mode"]
+  pid: number
+}

package/src/proxy/usage.ts

@@ -0,0 +1,44 @@
+import { MAX_EVENT_BUFFER } from "./constants"
+import type { Usage } from "./types"
+
+export function watchUsage(response: Response, onUsage: (usage: Usage) => void): Response {
+  if (!response.body) return response
+  const [toClient, toUs] = response.body.tee()
+  void (async () => {
+    const reader = toUs.pipeThrough(new TextDecoderStream()).getReader()
+    let buffer = ""
+    let found = false
+    while (true) {
+      const { value, done } = await reader.read()
+      if (done) break
+      if (found) continue
+      buffer += value
+      let newline: number
+      while (!found && (newline = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newline).trim()
+        buffer = buffer.slice(newline + 1)
+        if (!line.startsWith("data:") || !line.includes("message_start")) continue
+        try {
+          const event = JSON.parse(line.slice(5))
+          if (event.message?.usage) {
+            found = true
+            onUsage(event.message.usage)
+          }
+        } catch {}
+      }
+      if (!found && buffer.length > MAX_EVENT_BUFFER) buffer = ""
+    }
+    if (!found && buffer.trim().startsWith("{")) {
+      try {
+        const json = JSON.parse(buffer)
+        if (json.usage) onUsage(json.usage)
+        else if (typeof json.input_tokens === "number") onUsage({ input_tokens: json.input_tokens })
+      } catch {}
+    }
+  })().catch(() => undefined)
+  return new Response(toClient, { status: response.status, statusText: response.statusText, headers: response.headers })
+}
+
+export function inputTokens(usage: Usage) {
+  return (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0)
+}