@chroxify/eunoe 1.3.0 → 1.3.1

package/src/core/rewrite.ts

@@ -8,8 +8,9 @@ import type { CoreConfig } from "./config"
 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 { activeRecalls, applyRecall, dropLiveRecall, prefetchFor, wantsRecall } from "./recall"
 import type { ThreadStore } from "./state"
+import { limitKey } from "./usage"
 
 export interface ThreadSources {
   guide?: string | null
@@ -119,7 +120,7 @@ function strategize(input: RewriteInput): Rewrite {
   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 recalling = wantsRecall(input)
   const result = compact({
     body: based,
     config,
@@ -129,7 +130,7 @@ function strategize(input: RewriteInput): Rewrite {
     transcriptDir: sources.transcriptDir ?? null,
     mayCompact: input.mayCompact && !off,
     omittedBefore: input.omittedBefore,
-    decorate: (messages) => withRecall(withHandoffs(messages, handoffs), messageFingerprint, recalls),
+    decorate: (messages) => withRecall(withHandoffs(messages, handoffs), messageFingerprint, recalling ? activeRecalls(state.recalls) : {}),
   })
   if (result.stateChanged) store.save(threadKey, state)
   return { body: result.messages === body.messages ? based : { ...based, messages: result.messages }, threadKey, note: result.note }
@@ -165,22 +166,33 @@ function carried(from: Rewrite, to: Rewrite): Rewrite {
   return { ...to, note: { ...to.note, compacted: Boolean(to.note.compacted || from.note.compacted), actions } }
 }
 
-export function rewrite(input: RewriteInput, before?: Rewrite): Rewrite {
+function withLearnedLimit(input: RewriteInput): RewriteInput {
+  const threadKey = input.threadId && Array.isArray(input.body.messages) ? threadKeyOf(input.threadId, input.body.messages) : null
+  const limit = threadKey ? input.store.read(threadKey).limits?.[limitKey(input.body.model)] : undefined
+  if (!limit || (input.window !== null && input.window <= limit)) return input
+  return { ...input, window: limit }
+}
+
+export function rewrite(given: RewriteInput, before?: Rewrite): Rewrite {
+  const input = withLearnedLimit(given)
   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 } } }))
+  if (recut.threadKey && wantsRecall(input)) dropLiveRecall(input, recut.threadKey)
+  const bare = carried(recut, once(input))
   return { ...bare, note: { ...bare.note, fit: overLimit(input, bare) ? "over" : "bare", fitEstimate: sentEstimate(input, bare) } }
 }
 
-export async function prefetchRecall(input: RewriteInput, rerank: Reranker): Promise<{ reranked: boolean; rerankError: null; recalled: number } | null> {
+export async function prefetchRecall(given: RewriteInput, rerank: Reranker): Promise<{ reranked: boolean; rerankError: null; recalled: number } | null> {
+  const input = withLearnedLimit(given)
   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, rerank: Reranker = identityReranker): Promise<Rewrite> {
+export async function rewriteAsync(given: RewriteInput, rerank: Reranker = identityReranker): Promise<Rewrite> {
+  const input = withLearnedLimit(given)
   if (!wantsRecall(input) || rerank === identityReranker) return rewrite(input)
   const first = strategize(input)
   const recalled = await prefetchFor(input, first, rerank)

package/src/core/state.ts

@@ -1,3 +1,7 @@
+import type { Message } from "../context/content"
+import { isPrompt } from "../context/fold/turns"
+import { messageFingerprint } from "./fingerprint"
+
 export interface Handoff {
   label: string
   source: string
@@ -13,6 +17,7 @@ export interface ThreadState {
   host?: boolean
   pins?: string[]
   ratio?: number
+  limits?: Record<string, number>
   recalls?: Record<string, string>
 }
 
@@ -31,6 +36,11 @@ export function memoryStore(initial: Record<string, ThreadState> = {}): ThreadSt
   }
 }
 
+export function retireRecalls(state: ThreadState, folded: Message[][]) {
+  if (!state.recalls) return
+  for (const message of folded.flat()) if (isPrompt(message)) delete state.recalls[messageFingerprint(message)]
+}
+
 export function resetCut(state: ThreadState) {
   delete state.cut
   delete state.keep

package/src/core/usage.ts

@@ -67,9 +67,12 @@ 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
+function overflowOf(errorText: string): { tokens: number; maximum: number | null } | null {
+  const match = errorText.match(/prompt is too long[^0-9]*(\d+)\s*tokens?\s*>\s*(\d+)/i)
+  const tokens = Number(match?.[1])
+  const maximum = Number(match?.[2])
+  if (!Number.isFinite(tokens) || tokens <= 0) return null
+  return { tokens, maximum: Number.isFinite(maximum) && maximum > 0 ? maximum : null }
 }
 
 export function recordUsage(store: ThreadStore, threadKey: string, sent: Body | number, usage: Usage): boolean {
@@ -82,12 +85,18 @@ export function recordUsage(store: ThreadStore, threadKey: string, sent: Body |
   return true
 }
 
-export function recordOverflow(store: ThreadStore, threadKey: string, sent: Body | number, errorText: string): number | null {
-  const tokens = overflowTokens(errorText)
+export const limitKey = (model: unknown) => String(model ?? "")
+
+export function recordOverflow(store: ThreadStore, threadKey: string, sent: Body | number, errorText: string, model: unknown = typeof sent === "number" ? undefined : sent.model): number | null {
+  const overflow = overflowOf(errorText)
   const chars = charsOf(sent)
-  if (!tokens || chars <= 0) return null
+  if (!overflow || chars <= 0) return null
   const state = store.read(threadKey)
-  state.ratio = Math.max(state.ratio ?? 0, tokens / chars) * OVERFLOW_MARGIN
+  state.ratio = Math.max(state.ratio ?? 0, overflow.tokens / chars) * OVERFLOW_MARGIN
+  if (overflow.maximum) {
+    const key = limitKey(model)
+    state.limits = { ...state.limits, [key]: Math.min(state.limits?.[key] ?? Number.POSITIVE_INFINITY, overflow.maximum) }
+  }
   store.save(threadKey, state)
-  return tokens
+  return overflow.tokens
 }

package/src/core/window.ts

@@ -1,6 +1,19 @@
 export type WindowLookup = (model: unknown, requestHeaders: Headers, upstream?: string) => Promise<number | null>
 
-const LOOKUP_TIMEOUT_MS = 5_000
+export interface WindowLookupOptions {
+  known?: Map<string, number>
+  onLearn?: (windows: Map<string, number>) => void
+  timeoutMs?: number
+  retryAfterMs?: number
+}
+
+const LOOKUP_TIMEOUT_MS = 1_500
+
+const RETRY_AFTER_MS = 10 * 60_000
+
+const LONG_SUFFIX = /\[1m\]$/i
+
+const SUFFIX = /\[[^\]]*\]$/
 
 function lookupHeaders(requestHeaders: Headers): Headers {
   const headers = new Headers()
@@ -12,10 +25,19 @@ function lookupHeaders(requestHeaders: Headers): Headers {
   return headers
 }
 
-export function createWindowLookup({ known = new Map<string, number>(), onLearn }: { known?: Map<string, number>; onLearn?: (windows: Map<string, number>) => void } = {}): WindowLookup {
+function familyWindow(model: string): number | null {
+  if (LONG_SUFFIX.test(model)) return 1_000_000
+  const id = model.replace(SUFFIX, "")
+  if (/^claude-(?:(?:opus|sonnet|haiku|fable)-5|opus-4-8)/.test(id)) return 1_000_000
+  if (id.startsWith("claude-")) return 200_000
+  return null
+}
+
+export function createWindowLookup({ known = new Map<string, number>(), onLearn, timeoutMs = LOOKUP_TIMEOUT_MS, retryAfterMs = RETRY_AFTER_MS }: WindowLookupOptions = {}): WindowLookup {
   const lookups = new Map<string, Promise<number | null>>()
+  const failedAt = new Map<string, number>()
   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) })
+    const response = await fetch(`${upstream}/v1/models/${encodeURIComponent(id)}`, { headers: lookupHeaders(requestHeaders), signal: AbortSignal.timeout(timeoutMs) })
     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
@@ -24,16 +46,24 @@ export function createWindowLookup({ known = new Map<string, number>(), onLearn
     return info.max_input_tokens
   }
   return (model, requestHeaders, upstream = "https://api.anthropic.com") => {
-    const id = String(model ?? "").replace(/\[[^\]]*\]$/, "")
+    const given = String(model ?? "")
+    const id = given.replace(SUFFIX, "")
     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))
+    const fallback = familyWindow(given)
+    const failed = failedAt.get(id)
+    if (failed !== undefined && Date.now() - failed < retryAfterMs) return Promise.resolve(fallback)
+    const pending =
+      lookups.get(id) ??
+      lookup(id, requestHeaders, upstream)
+        .catch(() => null)
+        .then((found) => {
+          if (found === null) failedAt.set(id, Date.now())
+          return found
+        })
+        .finally(() => lookups.delete(id))
     lookups.set(id, pending)
-    return pending
+    return pending.then((found) => found ?? fallback)
   }
 }