@chroxify/eunoe 1.2.2 → 1.3.0

package/src/{proxy → core}/usage.ts

@@ -1,4 +1,8 @@
-type Usage = Record<string, number>
+import type { Body } from "../context/content"
+import { sizeOf } from "./estimate"
+import type { ThreadStore } from "./state"
+
+export type Usage = Record<string, number>
 
 function usageIn(line: string): Usage | null {
   if (!line.startsWith("data:") || !line.includes("message_start")) return null
@@ -58,3 +62,32 @@ export function watchUsage(response: Response, onUsage: (usage: Usage) => void):
 export function inputTokens(usage: Usage) {
   return (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0)
 }
+
+const OVERFLOW_MARGIN = 1.1
+
+const charsOf = (sent: Body | number) => (typeof sent === "number" ? sent : sizeOf(sent))
+
+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
+}
+
+export function recordUsage(store: ThreadStore, threadKey: string, sent: Body | number, usage: Usage): boolean {
+  const input = inputTokens(usage)
+  const chars = charsOf(sent)
+  if (input <= 0 || chars <= 0) return false
+  const state = store.read(threadKey)
+  state.ratio = input / chars
+  store.save(threadKey, state)
+  return true
+}
+
+export function recordOverflow(store: ThreadStore, threadKey: string, sent: Body | number, errorText: string): number | null {
+  const tokens = overflowTokens(errorText)
+  const chars = charsOf(sent)
+  if (!tokens || chars <= 0) return null
+  const state = store.read(threadKey)
+  state.ratio = Math.max(state.ratio ?? 0, tokens / chars) * OVERFLOW_MARGIN
+  store.save(threadKey, state)
+  return tokens
+}

package/src/core/window.ts

@@ -0,0 +1,39 @@
+export type WindowLookup = (model: unknown, requestHeaders: Headers, upstream?: string) => Promise<number | null>
+
+const LOOKUP_TIMEOUT_MS = 5_000
+
+function lookupHeaders(requestHeaders: Headers): Headers {
+  const headers = new Headers()
+  for (const name of ["authorization", "x-api-key", "anthropic-version", "anthropic-beta"]) {
+    const value = requestHeaders.get(name)
+    if (value) headers.set(name, value)
+  }
+  if (!headers.has("anthropic-version")) headers.set("anthropic-version", "2023-06-01")
+  return headers
+}
+
+export function createWindowLookup({ known = new Map<string, number>(), onLearn }: { known?: Map<string, number>; onLearn?: (windows: Map<string, number>) => void } = {}): WindowLookup {
+  const lookups = new Map<string, Promise<number | null>>()
+  const lookup = async (id: string, requestHeaders: Headers, upstream: string): Promise<number | null> => {
+    const response = await fetch(`${upstream}/v1/models/${encodeURIComponent(id)}`, { headers: lookupHeaders(requestHeaders), signal: AbortSignal.timeout(LOOKUP_TIMEOUT_MS) })
+    if (!response.ok) return null
+    const info = (await response.json()) as { max_input_tokens?: number }
+    if (typeof info.max_input_tokens !== "number" || info.max_input_tokens <= 0) return null
+    known.set(id, info.max_input_tokens)
+    onLearn?.(known)
+    return info.max_input_tokens
+  }
+  return (model, requestHeaders, upstream = "https://api.anthropic.com") => {
+    const id = String(model ?? "").replace(/\[[^\]]*\]$/, "")
+    if (!id) return Promise.resolve(null)
+    const window = known.get(id)
+    if (window) return Promise.resolve(window)
+    const inFlight = lookups.get(id)
+    if (inFlight) return inFlight
+    const pending = lookup(id, requestHeaders, upstream)
+      .catch(() => null)
+      .finally(() => lookups.delete(id))
+    lookups.set(id, pending)
+    return pending
+  }
+}

package/src/proxy/rewrite.ts

@@ -1,20 +1,15 @@
+import { existsSync, readFileSync } from "node:fs"
 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 { paths } from "../config/paths"
+import type { Reranker } from "../context/recall"
+import { jevReranker } from "../context/recall/rerank"
+import { type RewriteInput as CoreInput, prefetchRecall as prefetchCore, type Rewrite, rewrite as rewriteCore, rewriteAsync as rewriteCoreAsync } from "../core/rewrite"
 import type { TranscriptRef } from "../transcript/search"
-import { compact } from "./compaction"
-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"
+import { sessionSources } from "./sources"
+import { fileStore } from "./state"
 
 export interface RewriteInput {
-  body: Body
+  body: CoreInput["body"]
   sessionId: string | null
   config: Config
   transcript: TranscriptRef | null
@@ -23,146 +18,34 @@ export interface RewriteInput {
   omittedBefore?: number
 }
 
-export interface Rewrite {
-  body: Body
-  threadKey: string | null
-  note: Record<string, unknown>
+export function rerankKey(): string | null {
+  const env = process.env.TYPESAFE_API_KEY?.trim()
+  if (env) return env
+  return existsSync(paths.typesafeKey) ? readFileSync(paths.typesafeKey, "utf8").trim() : null
 }
 
-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
-
-const withSystemPrompt = (system: Body["system"], extra?: string | null) => appendSystem(extra ? appendSystem(system, extra) : system, SYSTEM_PROMPT)
-
-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 !== "off" ? model : null
 }
 
-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 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 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 }
-}
-
-function once(input: RewriteInput): Rewrite {
-  const result = withAttachedHandoffs(strategize(input))
-  return wantsRecall(input) ? applyRecall(input, result) : result
-}
-
-function sentEstimate(result: Rewrite): number {
-  return Math.round(sizeOf(result.body) * (result.threadKey ? ratioOf(result.threadKey) : DEFAULT_RATIO))
-}
-
-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 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 } }
-}
+const toCore = ({ sessionId, transcript, ...input }: RewriteInput): CoreInput => ({ ...input, threadId: sessionId, store: fileStore, sources: sessionSources(transcript, input.config, sessionId) })
 
-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) } }
-}
+export const rewrite = (input: RewriteInput): Rewrite => rewriteCore(toCore(input))
 
-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 const prefetchRecall = (input: RewriteInput, rerank: Reranker) => prefetchCore(toCore(input), rerank)
 
-export async function rewriteAsync(input: RewriteInput): Promise<Rewrite> {
-  const model = wantsRecall(input) ? rerankModel(input.config) : null
+export async function rewriteAsync(input: RewriteInput): Promise<Rewrite & { note: { reranked?: string; rerankError?: string } }> {
+  const core = toCore(input)
+  const model = core.config.mode !== "off" && (core.config.eval?.recall ?? true) ? rerankModel(input.config) : null
   const key = model ? rerankKey() : null
-  if (!model || !key) return rewrite(input)
+  if (!model || !key) return rewriteCore(core)
   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 result = await rewriteCoreAsync(core, reranker)
+  if (result.note.recalled === undefined) return result
   const outcome = failure.reason ? { rerankError: `${model}: ${failure.reason}` } : { reranked: model }
-  return { ...final, note: { ...final.note, recalled, ...outcome } }
+  return { ...result, note: { ...result.note, ...outcome } }
 }

package/src/proxy/server.ts

@@ -1,17 +1,16 @@
 import path from "node:path"
 import { type Config, claudeConfigDirs, readConfig, settingsFor } from "../config"
-import { type Body, wellFormed } from "../context/content"
+import type { Body } from "../context/content"
+import { contextFingerprint } from "../core/fingerprint"
+import { claudeCodeSessionId, createForwarder, type Prepared } from "../core/forward"
 import { findSessionFile } from "../transcript/locate"
 import { prepareTranscript } from "../transcript/search"
 import { VERSION } from "../version"
 import { applyCanonical } from "./canonical"
-import { sizeOf } from "./estimate"
-import { type ContextFingerprint, contextFingerprint } from "./fingerprint"
 import { logRequest } from "./log"
 import { rewriteAsync } from "./rewrite"
 import { recordSession } from "./sessions"
-import { readState, saveState } from "./state"
-import { inputTokens, watchUsage } from "./usage"
+import { fileStore } from "./state"
 import { resolveWindow } from "./window"
 
 export interface Health {
@@ -22,48 +21,14 @@ export interface Health {
   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
-  } catch {
-    return null
-  }
-}
-
-function forwardableHeaders(headers: Headers) {
-  const out = new Headers(headers)
-  out.delete("content-encoding")
-  out.delete("content-length")
-  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)
+async function prepareSession(request: Request, body: Body, base: Config, isCountTokens: boolean) {
+  const sessionId = claudeCodeSessionId(request.headers, body)
   const config = settingsFor(base, sessionId)
   const trusted = config.eval?.trustHeaders === true
   const transcriptOverride = trustedHeader(request, config, "transcript")
@@ -87,132 +52,29 @@ async function prepare(request: Request, body: Body, base: Config, isCountTokens
   })
 }
 
-function saveRatio(threadKey: string, ratio: (previous: number | undefined) => number) {
-  const state = readState(threadKey)
-  state.ratio = ratio(state.ratio)
-  saveState(threadKey, state)
+async function prepare(request: Request, given: Body, config: Config, mayCompact: boolean): Promise<Prepared> {
+  const canonicalFile = trustedHeader(request, config, "canonical")
+  const canonical = canonicalFile ? applyCanonical(given, canonicalFile) : null
+  const result = await prepareSession(request, canonical?.body ?? given, config, !mayCompact)
+  const context = config.eval ? { context: { session: claudeCodeSessionId(request.headers, given), ...contextFingerprint(result.body), given: contextFingerprint(given) } } : {}
+  return { ...result, note: { ...result.note, ...(canonical && { canonical: canonical.status }), ...context } }
 }
 
 interface Timing {
   countTokensTimeoutMs: number
 }
 
-const COUNT_TOKENS_ATTEMPTS = 3
-
-export async function handle(request: Request, timing: Timing = { countTokensTimeoutMs: 10_000 }): Promise<Response> {
-  const began = Date.now()
-  try {
-    return await route(request, began, timing)
-  } catch (error) {
-    logRequest({ path: new URL(request.url).pathname, status: 502, action: "upstream-unreachable", error: clipped(String(error)), ms: Date.now() - began })
-    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, began: number, timing: Timing): Promise<Response> {
-  let stalled = 0
-  let prep = 0
-  let upload = 0
-  const log = (record: Record<string, unknown>) => logRequest({ ...record, ms: Date.now() - began, prep, upload, ...(stalled > 0 && { stalled }) })
+export function handle(request: Request, timing: Timing = { countTokensTimeoutMs: 10_000 }): 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, startedAt } satisfies Health)
-  const headers = new Headers(request.headers)
-  for (const name of ["host", "content-length", "accept-encoding"]) headers.delete(name)
-
-  let givenText: string | undefined
-  if (request.method !== "GET" && request.method !== "HEAD") givenText = await request.text()
-  upload = Date.now() - began
-  const isMessages = request.method === "POST" && url.pathname.startsWith("/v1/messages")
-  const isCountTokens = url.pathname.includes("count_tokens")
-
-  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(givenText) as Body
-      const canonicalFile = trustedHeader(request, config, "canonical")
-      const canonical = canonicalFile ? applyCanonical(given, canonicalFile) : null
-      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) {
-      return { ...passthrough, note: { action: "error-passthrough", error: String(error) } }
-    }
-  }
-  const target = config.upstream + url.pathname + url.search
-  const send = async (body: string | undefined): Promise<Response> => {
-    if (!isCountTokens) return fetch(target, { method: request.method, headers, body })
-    for (;;) {
-      try {
-        return await fetch(target, { method: request.method, headers, body, signal: AbortSignal.timeout(timing.countTokensTimeoutMs) })
-      } catch (error) {
-        const timedOut = error instanceof Error && error.name === "TimeoutError"
-        if (!timedOut || stalled + 1 >= COUNT_TOKENS_ATTEMPTS) throw error
-        stalled += 1
-      }
-    }
-  }
-
-  let out = await build()
-  prep = Date.now() - began - upload
-  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 && out.note.action !== "pass") {
-    const errorText = await upstream.text()
-    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) {
-      log({ ...logged, error: clipped(errorText) })
-      return errorResponse(errorText)
-    }
-    const sentSize = out.sentSize
-    saveRatio(out.threadKey, (previous) => Math.max(previous ?? 0, overflow / sentSize) * 1.1)
-    log({ ...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()
-      log({ 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) log({ path: url.pathname, status: upstream.status, ...note, ...(sent && { context: sent }) })
-    return response
-  }
-
-  return watchUsage(response, (usage) => {
-    const input = inputTokens(usage)
-    log({
-      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,
-      charsFixed: fixedSize,
-      ...(sent && { context: sent }),
-    })
-    if (threadKey && input > 0 && sentSize > 0) saveRatio(threadKey, () => input / sentSize)
+  if (new URL(request.url).pathname === HEALTH_PATH) return Promise.resolve(Response.json({ ok: true, version: VERSION, mode: config.mode, pid: process.pid, startedAt } satisfies Health))
+  const forward = createForwarder({
+    store: fileStore,
+    upstream: config.upstream,
+    prepare: (incoming, body, mayCompact) => prepare(incoming, body, config, mayCompact),
+    record: logRequest,
+    countTokensTimeoutMs: timing.countTokensTimeoutMs,
   })
+  return forward(request)
 }
 
 export function serve(port: number) {

package/src/proxy/sessions.ts

@@ -1,6 +1,6 @@
 import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from "node:fs"
-import type { Mode } from "../config"
 import { EUNOE_DIR, paths } from "../config/paths"
+import type { Mode } from "../core/config"
 
 interface SeenSession {
   lastSeen: string

package/src/proxy/sources.ts

@@ -0,0 +1,35 @@
+import { type Config, claudeConfigDirs } from "../config"
+import type { Message } from "../context/content"
+import { searchGuide } from "../context/prompts"
+import type { ThreadSources } from "../core/rewrite"
+import { findSessionByPrefix } from "../transcript/locate"
+import { sessionMessages } from "../transcript/messages"
+import type { TranscriptRef } from "../transcript/search"
+import { subagentChunks } from "../transcript/subagents"
+import { titleOf } from "./sessions"
+
+function readSession(file: string): Message[] {
+  try {
+    return sessionMessages(file)
+  } catch {
+    return []
+  }
+}
+
+export function sessionSources(transcript: TranscriptRef | null, config: Config, sessionId: string | null): ThreadSources {
+  const handoffs = {
+    findHandoff: (id: string) => {
+      const file = findSessionByPrefix(id, claudeConfigDirs(config), sessionId ?? undefined)
+      return file ? { label: titleOf(file) ?? id, source: file } : null
+    },
+    readHandoff: readSession,
+  }
+  if (!transcript) return handoffs
+  return {
+    ...handoffs,
+    guide: searchGuide(transcript),
+    transcriptDir: transcript.mode !== "jsonl" ? transcript.dir : null,
+    readHistory: () => sessionMessages(transcript.jsonl),
+    listSubagentChunks: () => subagentChunks(transcript.jsonl),
+  }
+}

package/src/proxy/state.ts

@@ -1,21 +1,7 @@
 import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import path from "node:path"
 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>
-}
+import type { ThreadState, ThreadStore } from "../core/state"
 
 function stateFile(key: string) {
   return path.join(paths.threads, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`)
@@ -63,8 +49,4 @@ export function saveState(key: string, state: ThreadState) {
   if (version !== null) remember(file, version, structuredClone(state))
 }
 
-export function resetCut(state: ThreadState) {
-  delete state.cut
-  delete state.keep
-  delete state.cleared
-}
+export const fileStore: ThreadStore = { read: readState, save: saveState }

package/src/proxy/window.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { EUNOE_DIR, paths } from "../config/paths"
+import { createWindowLookup } from "../core/window"
 
 function readCache(): Map<string, number> {
   try {
@@ -9,40 +10,9 @@ function readCache(): Map<string, number> {
   }
 }
 
-const windows = readCache()
-const lookups = new Map<string, Promise<number | null>>()
-
-function lookupHeaders(requestHeaders: Headers): Headers {
-  const headers = new Headers()
-  for (const name of ["authorization", "x-api-key", "anthropic-version", "anthropic-beta"]) {
-    const value = requestHeaders.get(name)
-    if (value) headers.set(name, value)
-  }
-  if (!headers.has("anthropic-version")) headers.set("anthropic-version", "2023-06-01")
-  return headers
-}
-
-async function lookup(id: string, requestHeaders: Headers, upstream: string): Promise<number | null> {
-  const response = await fetch(`${upstream}/v1/models/${encodeURIComponent(id)}`, { headers: lookupHeaders(requestHeaders), signal: AbortSignal.timeout(5_000) })
-  if (!response.ok) return null
-  const info = (await response.json()) as { max_input_tokens?: number }
-  if (typeof info.max_input_tokens !== "number" || info.max_input_tokens <= 0) return null
-  windows.set(id, info.max_input_tokens)
+function saveCache(windows: Map<string, number>) {
   mkdirSync(EUNOE_DIR, { recursive: true })
   writeFileSync(paths.models, JSON.stringify(Object.fromEntries(windows), null, 2))
-  return info.max_input_tokens
 }
 
-export function resolveWindow(model: unknown, requestHeaders: Headers, upstream: string): Promise<number | null> {
-  const id = String(model ?? "").replace(/\[[^\]]*\]$/, "")
-  if (!id) return Promise.resolve(null)
-  const known = windows.get(id)
-  if (known) return Promise.resolve(known)
-  const inFlight = lookups.get(id)
-  if (inFlight) return inFlight
-  const pending = lookup(id, requestHeaders, upstream)
-    .catch(() => null)
-    .finally(() => lookups.delete(id))
-  lookups.set(id, pending)
-  return pending
-}
+export const resolveWindow = createWindowLookup({ known: readCache(), onLearn: saveCache })

package/src/transcript/format.ts

@@ -1,9 +1,8 @@
 import { clip } from "../context/content"
 import type { ToolPart, TranscriptFormat, Turn } from "./parse"
-import type { SubagentRun } from "./subagents"
 
 export interface SubagentRecord {
-  run: SubagentRun
+  run: { description: string }
   turns: Turn[]
   parentTurn: number
   file: string

package/src/transcript/subagents.ts

@@ -2,7 +2,8 @@ import { readFileSync, statSync } from "node:fs"
 import path from "node:path"
 import { blocks, clip, contentBlocks, type Message } from "../context/content"
 import { splitTurns } from "../context/fold/turns"
-import { type RecallChunk, recallChunks } from "../context/recall"
+import type { RecallChunk } from "../context/recall"
+import { subagentRecall } from "../core/subagents"
 import { readSessionEntries } from "./entries"
 import { listEntries } from "./locate"
 import { sessionMessages } from "./messages"
@@ -163,8 +164,7 @@ export function subagentChunks(sessionFile: string): RecallChunk[] {
     const parentTurn = launchTurn(run, launches)
     const hit = chunkCache.get(key)
     if (hit && hit.mtimeMs === run.mtimeMs && hit.parentTurn === parentTurn) return hit.chunks
-    const from = `subagent "${run.description}"`
-    const chunks = recallChunks([...subagentMessages(run), { role: "user", content: "" }], new Map()).map((chunk) => ({ ...chunk, from, turn: parentTurn }))
+    const chunks = subagentRecall(subagentMessages(run), run.description, parentTurn)
     chunkCache.set(key, { mtimeMs: run.mtimeMs, parentTurn, chunks })
     return chunks
   })