@chroxify/eunoe 1.3.0 → 1.3.1

package/dist/core/index.js

@@ -545,6 +545,16 @@ function splitTurns(messages) {
 function turnFingerprint(turn) {
   return shortHash(JSON.stringify(blocks(turn[0]).map(withoutCacheControl)), 24);
 }
+function turnKeys(turns) {
+  const copies = new Map;
+  return turns.map((turn) => {
+    const fingerprint = turnFingerprint(turn);
+    const earlier = copies.get(fingerprint) ?? 0;
+    copies.set(fingerprint, earlier + 1);
+    return earlier === 0 ? fingerprint : `${fingerprint}~${earlier}`;
+  });
+}
+var fingerprintOfKey = (key) => key.split("~")[0];
 function isHarness(message) {
   return message.role === "system";
 }
@@ -593,8 +603,19 @@ function reduceTurn(turn, options = {}) {
 }
 
 // src/context/fold/strategies.ts
-var pinnedBy = ({ pinned }) => (turn) => pinned !== undefined && pinned.size > 0 && pinned.has(turnFingerprint(turn));
-var countPinned = (turns, pinned) => pinned.size > 0 ? turns.filter((turn) => pinned.has(turnFingerprint(turn))).length : 0;
+function pinnedAt(turns, { pinned }) {
+  if (pinned === undefined || pinned.size === 0)
+    return () => false;
+  const keys = turnKeys(turns);
+  return (index) => pinned.has(keys[index]);
+}
+function pinnedPrompt({ pinned }) {
+  if (pinned === undefined || pinned.size === 0)
+    return () => false;
+  const fingerprints = new Set([...pinned].map(fingerprintOfKey));
+  return (turn) => fingerprints.has(turnFingerprint(turn));
+}
+var countPinned = (keys, pinned) => pinned.size > 0 ? keys.filter((key) => pinned.has(key)).length : 0;
 function trimMessages(messages, options = {}) {
   const { preamble, turns } = splitTurns(messages);
   if (turns.length < 2)
@@ -624,18 +645,19 @@ function compactMessages(messages, cutIndex, options) {
   if (cutIndex <= 0 || cutIndex >= turns.length)
     return messages;
   const reduce = options.reduce ?? reduceTurn;
-  const isPinned = pinnedBy(options);
+  const isPinned = pinnedAt(turns, options);
+  const indexed = turns.map((turn, index) => ({ turn, pinned: isPinned(index) }));
   const keptFrom = Math.max(1, cutIndex - options.keepTurns);
   const [first, ...rest] = turns[0];
-  const openingPinned = isPinned(turns[0]);
+  const openingPinned = indexed[0].pinned;
   const openingFolded = !openingPinned && foldsOpening(turns[0], keptFrom);
-  const dropped = turns.slice(1, keptFrom);
-  const whole = dropped.filter(isPinned);
-  const pinned = whole.length + turns.slice(keptFrom, cutIndex).filter(isPinned).length + (openingPinned ? 1 : 0);
+  const dropped = indexed.slice(1, keptFrom);
+  const whole = dropped.filter((t) => t.pinned).map((t) => t.turn);
+  const pinned = whole.length + indexed.slice(keptFrom, cutIndex).filter((t) => t.pinned).length + (openingPinned ? 1 : 0);
   const kept = cutIndex - keptFrom + (openingFolded ? 1 : 0);
   const notice = compactionNotice({ omitted: dropped.length - whole.length + (options.omittedBefore ?? 0), kept, pinned, guide: options.guide });
-  const removed = [...openingPinned || openingFolded ? [] : rest, ...dropped.filter((turn) => !isPinned(turn)).flat()];
-  const shown = (turn) => isPinned(turn) ? turn.map(clean) : reduce(turn, options);
+  const removed = [...openingPinned || openingFolded ? [] : rest, ...dropped.filter((t) => !t.pinned).flatMap((t) => t.turn)];
+  const shown = (t) => t.pinned ? t.turn.map(clean) : reduce(t.turn, options);
   return [
     ...preamble,
     first,
@@ -643,7 +665,7 @@ function compactMessages(messages, cutIndex, options) {
     { role: "user", content: [{ type: "text", text: notice }, ...carriedHarness(removed)] },
     ...openingFolded ? reduce(turns[0], options).slice(1) : [],
     ...whole.flatMap((turn) => turn.map(clean)),
-    ...turns.slice(keptFrom, cutIndex).flatMap(shown),
+    ...indexed.slice(keptFrom, cutIndex).flatMap(shown),
     ...turns.slice(cutIndex).flat()
   ];
 }
@@ -655,7 +677,7 @@ function capTurns(messages, options) {
   if (turns.length < 3)
     return messages;
   const live = turns.length - 1;
-  const isPinned = pinnedBy(options);
+  const isPinned = pinnedPrompt(options);
   const over = (turn, i) => i > 0 && i < live && !isPinned(turn) && JSON.stringify(turn).length > capChars;
   if (!turns.some(over))
     return messages;
@@ -716,6 +738,7 @@ function appendSystem(system, text) {
 }
 
 // src/context/recall/index.ts
+var RECALL_CHARS_TOTAL = 30000;
 var SHOWN_LINES = 8;
 var BM25_K1 = 1.2;
 var BM25_B = 0.75;
@@ -1037,7 +1060,8 @@ async function pickRecallWith(prompt, chunks, rerank, options = {}) {
 function renderRecall(prompt, chunks, picks, options = {}) {
   if (picks.length === 0)
     return null;
-  const budget = queriesOf(prompt).length > 1 ? options.maxCharsMulti ?? 30000 : options.maxChars ?? 18000;
+  const own = queriesOf(prompt).length > 1 ? options.maxCharsMulti ?? 30000 : options.maxChars ?? 18000;
+  const budget = Math.min(own, (options.maxCharsTotal ?? RECALL_CHARS_TOTAL) - (options.charsInUse ?? 0));
   const entries = [];
   let used = 0;
   for (const { index, query } of [...picks].sort((a, b) => chunks[a.index].turn - chunks[b.index].turn || a.index - b.index)) {
@@ -1109,6 +1133,13 @@ function targetSize(size, window) {
   return size.fixed + 0.3 * Math.max(0, window - size.fixed);
 }
 
+// src/core/fingerprint.ts
+var isInjected = (text) => /^<(?:recalled-context|handoff)[\s>]/.test(String(text ?? ""));
+function messageFingerprint(message) {
+  const own = blocks(message).filter((b) => !(b.type === "text" && isInjected(b.text))).map(withoutCacheControl);
+  return shortHash(JSON.stringify(own), 24);
+}
+
 // src/core/state.ts
 function memoryStore(initial = {}) {
   const threads = new Map(Object.entries(initial).map(([key, state]) => [key, structuredClone(state)]));
@@ -1119,6 +1150,13 @@ function memoryStore(initial = {}) {
     }
   };
 }
+function retireRecalls(state, folded) {
+  if (!state.recalls)
+    return;
+  for (const message of folded.flat())
+    if (isPrompt(message))
+      delete state.recalls[messageFingerprint(message)];
+}
 function resetCut(state) {
   delete state.cut;
   delete state.keep;
@@ -1145,15 +1183,14 @@ function reduceRemembered(turn, options) {
   return reduced;
 }
 var PROTECTED_OUTPUTS = 5;
-var STUCK_STEP = 0.1;
 function settledCut(turns, index) {
   let cut = index;
   while (cut > 1 && JSON.stringify(turns[cut][0].content).includes("[Request interrupted"))
     cut -= 1;
   return cut;
 }
-function resolveCut(turns, state, config, rollingKeep) {
-  let cutIndex = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1;
+function resolveCut(turns, keys, state, config, rollingKeep) {
+  let cutIndex = state.cut ? keys.indexOf(state.cut) : -1;
   let stateChanged = false;
   if (state.cut && cutIndex === -1) {
     resetCut(state);
@@ -1161,7 +1198,8 @@ function resolveCut(turns, state, config, rollingKeep) {
   }
   if (cutIndex <= 0 && config.eval?.forceCut && turns.length >= 3) {
     cutIndex = settledCut(turns, Math.max(1, turns.length - 1 - (rollingKeep ?? 1)));
-    state.cut = turnFingerprint(turns[cutIndex]);
+    state.cut = keys[cutIndex];
+    retireRecalls(state, turns.slice(0, cutIndex));
     stateChanged = true;
   }
   return { cutIndex, stateChanged };
@@ -1188,29 +1226,55 @@ function shrinkToTarget(over, step, actions, rebuild) {
     const action = step();
     actions.push(action);
     if (action === "stuck")
-      return true;
+      return;
     rebuild();
   }
-  return false;
 }
-var holdsStuck = (state, estimate, window) => window !== null && state.stuck !== undefined && estimate <= state.stuck + STUCK_STEP * window;
-var headLength = (preamble, first, state) => preamble.length + 1 + (countPinned([first], new Set(state.pins)) > 0 ? first.length : 1);
+function shrinkOrHold(state, actions, shrink) {
+  const overWindow = (tokens) => shrink.window !== null && tokens > shrink.window;
+  const held = state.stuck === undefined ? null : { keep: state.keep, cleared: state.cleared, actions: actions.length, overWindow: overWindow(shrink.estimate()) };
+  shrinkToTarget(() => shrink.estimate() > shrink.target, shrink.step, actions, shrink.rebuild);
+  const helped = (estimate) => estimate <= shrink.limit || held?.overWindow === true && !overWindow(estimate);
+  if (held && !helped(shrink.estimate())) {
+    restoreShrink(state, held);
+    actions.length = held.actions;
+    shrink.rebuild();
+  }
+  if (shrink.estimate() > shrink.limit)
+    state.stuck = shrink.estimate();
+  else {
+    delete state.stuck;
+    if (actions.at(-1) === "stuck")
+      actions.pop();
+  }
+}
+function restoreShrink(state, held) {
+  if (held.keep === undefined)
+    delete state.keep;
+  else
+    state.keep = held.keep;
+  if (held.cleared === undefined)
+    delete state.cleared;
+  else
+    state.cleared = held.cleared;
+}
+var headLength = (preamble, first, firstKey, state) => preamble.length + 1 + (countPinned([firstKey], new Set(state.pins)) > 0 ? first.length : 1);
 function stuckSizes(messages, headEnd, liveFrom, size) {
   const of = (list) => size.of(list) - size.fixed;
   return { fixed: size.fixed, head: of(messages.slice(0, headEnd)), folded: of(messages.slice(headEnd, liveFrom)), live: of(messages.slice(liveFrom)) };
 }
-function cutNote(state, turns, cutIndex, configuredKeep, actions) {
+function cutNote(state, turns, keys, cutIndex, configuredKeep, actions) {
   const pins = new Set(state.pins);
   const keptFrom = cutIndex > 0 ? Math.max(1, cutIndex - (state.keep ?? configuredKeep)) : 0;
-  const omitted = cutIndex > 0 ? keptFrom - 1 - countPinned(turns.slice(1, keptFrom), pins) : 0;
+  const omitted = cutIndex > 0 ? keptFrom - 1 - countPinned(keys.slice(1, keptFrom), pins) : 0;
   return {
     action: cutIndex > 0 ? "compact" : "full",
     compacted: actions.includes("cut") || actions.includes("roll"),
     actions: actions.length > 0 ? actions : undefined,
     cutTurn: cutIndex > 0 ? cutIndex : null,
     omitted,
-    folded: cutIndex > 0 ? cutIndex - keptFrom - countPinned(turns.slice(keptFrom, cutIndex), pins) + (foldsOpening(turns[0], keptFrom) && countPinned([turns[0]], pins) === 0 ? 1 : 0) : 0,
-    pinned: cutIndex > 0 ? countPinned(turns.slice(0, cutIndex), pins) : 0,
+    folded: cutIndex > 0 ? cutIndex - keptFrom - countPinned(keys.slice(keptFrom, cutIndex), pins) + (foldsOpening(turns[0], keptFrom) && countPinned([keys[0]], pins) === 0 ? 1 : 0) : 0,
+    pinned: cutIndex > 0 ? countPinned(keys.slice(0, cutIndex), pins) : 0,
     host: state.host,
     keep: state.keep,
     cleared: state.cleared
@@ -1219,7 +1283,8 @@ function cutNote(state, turns, cutIndex, configuredKeep, actions) {
 function compact({ body, config, state, window, guide, transcriptDir, mayCompact, omittedBefore = 0, decorate = (m) => m, reduce }) {
   const { preamble, turns } = splitTurns(body.messages);
   const rolling = config.eval?.rolling ?? (config.mode === "default" ? { keep: config.keep, budget: config.budget } : undefined);
-  const resolved = resolveCut(turns, state, config, rolling?.keep);
+  const keys = turnKeys(turns);
+  const resolved = resolveCut(turns, keys, state, config, rolling?.keep);
   let cutIndex = resolved.cutIndex;
   let stateChanged = resolved.stateChanged;
   const configuredKeep = config.keepTurns === "all" ? Number.MAX_SAFE_INTEGER : config.keepTurns;
@@ -1248,7 +1313,8 @@ function compact({ body, config, state, window, guide, transcriptDir, mayCompact
   const moveCut = (index, action) => {
     cutIndex = index;
     resetCut(state);
-    state.cut = turnFingerprint(turns[index]);
+    state.cut = keys[index];
+    retireRecalls(state, turns.slice(0, index));
     actions.push(action);
     rebuild();
   };
@@ -1261,21 +1327,18 @@ function compact({ body, config, state, window, guide, transcriptDir, mayCompact
     const current = turns.length - 1;
     if (current > 0 && current > cutIndex)
       moveCut(current, "cut");
-    if (!holdsStuck(state, estimate, window)) {
-      const stuck = shrinkToTarget(() => estimate > target, () => shrinkOnce(state, cutIndex, configuredKeep, liveResults), actions, rebuild);
-      if (stuck)
-        state.stuck = estimate;
-      else
-        delete state.stuck;
-    }
+    shrinkOrHold(state, actions, { estimate: () => estimate, step: () => shrinkOnce(state, cutIndex, configuredKeep, liveResults), rebuild, target, limit, window });
+    stateChanged = true;
+  } else if (state.stuck !== undefined) {
+    delete state.stuck;
     stateChanged = true;
   }
   return {
     messages,
     stateChanged,
     note: {
-      ...cutNote(state, turns, cutIndex, configuredKeep, actions),
-      stuck: state.stuck === undefined ? undefined : stuckSizes(messages, headLength(preamble, turns[0], state), liveStart(messages), size),
+      ...cutNote(state, turns, keys, cutIndex, configuredKeep, actions),
+      stuck: state.stuck === undefined ? undefined : stuckSizes(messages, headLength(preamble, turns[0], keys[0], state), liveStart(messages), size),
       turns: turns.length,
       messagesIn: body.messages.length,
       messagesOut: messages.length,
@@ -1285,13 +1348,6 @@ function compact({ body, config, state, window, guide, transcriptDir, mayCompact
   };
 }
 
-// src/core/fingerprint.ts
-var isInjected = (text) => /^<(?:recalled-context|handoff)[\s>]/.test(String(text ?? ""));
-function messageFingerprint(message) {
-  const own = blocks(message).filter((b) => !(b.type === "text" && isInjected(b.text))).map(withoutCacheControl);
-  return shortHash(JSON.stringify(own), 24);
-}
-
 // src/context/fold/index.ts
 var FOLD_CAP_CHARS = 400000;
 var spoken = (message) => textOf(message).replace(/<(system-reminder|system-message|recalled-context|handoff)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, "").trim();
@@ -1431,6 +1487,26 @@ function recallTarget(original) {
   const live = livePrompt(original.messages);
   return live ? { key: messageFingerprint(original.messages[live.index]), text: live.text } : null;
 }
+function charsInUse(messages, recalls) {
+  return messages.reduce((sum, message) => sum + (isPrompt(message) ? recalls[messageFingerprint(message)]?.length ?? 0 : 0), 0);
+}
+var RECALL_SHARE = 0.25;
+var RECALL_FLOOR = 6000;
+function withinTotal(input, result, recalls) {
+  const options = input.config.eval?.recallOptions;
+  const share = Math.max(RECALL_FLOOR, RECALL_SHARE * JSON.stringify(result.body.messages).length);
+  return { ...options, maxCharsTotal: Math.min(options?.maxCharsTotal ?? RECALL_CHARS_TOTAL, share), charsInUse: charsInUse(result.body.messages, recalls) };
+}
+function dropLiveRecall(input, threadKey) {
+  const target = recallTarget(input.body);
+  if (!target)
+    return;
+  const state = input.store.read(threadKey);
+  if (state.recalls?.[target.key] === "")
+    return;
+  state.recalls = { ...state.recalls, [target.key]: "" };
+  input.store.save(threadKey, state);
+}
 function applyRecall(input, result) {
   if (!touched(input, result) || !result.threadKey)
     return result;
@@ -1439,7 +1515,7 @@ function applyRecall(input, result) {
   const target = recallTarget(input.body);
   let note = result.note;
   if (target && !(target.key in state.recalls)) {
-    state.recalls[target.key] = recallFor(target.text, droppedChunks(input, result, result.threadKey), input.config.eval?.recallOptions) ?? "";
+    state.recalls[target.key] = recallFor(target.text, droppedChunks(input, result, result.threadKey), withinTotal(input, result, state.recalls)) ?? "";
     input.store.save(result.threadKey, state);
     note = { ...note, recalled: state.recalls[target.key].length };
   }
@@ -1456,12 +1532,112 @@ async function prefetchFor(input, result, rerank) {
   state.recalls ??= {};
   if (target.key in state.recalls)
     return null;
-  const options = { candidates: input.config.eval?.rerank?.candidates, ...input.config.eval?.recallOptions };
+  const options = { candidates: input.config.eval?.rerank?.candidates, ...withinTotal(input, result, state.recalls) };
   state.recalls[target.key] = await recallForWith(target.text, droppedChunks(input, result, result.threadKey), rerank, options) ?? "";
   input.store.save(result.threadKey, state);
   return state.recalls[target.key].length;
 }
 
+// src/core/usage.ts
+function usageIn(line) {
+  if (!line.startsWith("data:") || !line.includes("message_start"))
+    return null;
+  try {
+    return JSON.parse(line.slice(5)).message?.usage ?? null;
+  } catch {
+    return null;
+  }
+}
+function trailingUsage(buffer) {
+  if (!buffer.trim().startsWith("{"))
+    return null;
+  try {
+    const json = JSON.parse(buffer);
+    if (json.usage)
+      return json.usage;
+    return typeof json.input_tokens === "number" ? { input_tokens: json.input_tokens } : null;
+  } catch {
+    return null;
+  }
+}
+function scanEvents(buffer) {
+  let rest = buffer;
+  for (let newline = rest.indexOf(`
+`);newline !== -1; newline = rest.indexOf(`
+`)) {
+    const usage = usageIn(rest.slice(0, newline).trim());
+    rest = rest.slice(newline + 1);
+    if (usage)
+      return { usage, rest };
+  }
+  return { usage: null, rest };
+}
+async function readUsage(stream) {
+  const reader = stream.pipeThrough(new TextDecoderStream).getReader();
+  let buffer = "";
+  let usage = null;
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done)
+      return usage ?? trailingUsage(buffer);
+    if (usage)
+      continue;
+    const scanned = scanEvents(buffer + value);
+    usage = scanned.usage;
+    buffer = scanned.rest.length > 4000000 ? "" : scanned.rest;
+  }
+}
+function watchUsage(response, onUsage) {
+  if (!response.body)
+    return response;
+  const [toClient, toUs] = response.body.tee();
+  readUsage(toUs).then((usage) => {
+    if (usage)
+      onUsage(usage);
+  }).catch(() => {
+    return;
+  });
+  return new Response(toClient, { status: response.status, statusText: response.statusText, headers: response.headers });
+}
+function inputTokens(usage) {
+  return (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+}
+var OVERFLOW_MARGIN = 1.1;
+var charsOf = (sent) => typeof sent === "number" ? sent : sizeOf(sent);
+function overflowOf(errorText) {
+  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 };
+}
+function recordUsage(store, threadKey, sent, usage) {
+  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;
+}
+var limitKey = (model) => String(model ?? "");
+function recordOverflow(store, threadKey, sent, errorText, model = typeof sent === "number" ? undefined : sent.model) {
+  const overflow = overflowOf(errorText);
+  const chars = charsOf(sent);
+  if (!overflow || chars <= 0)
+    return null;
+  const state = store.read(threadKey);
+  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 overflow.tokens;
+}
+
 // src/core/rewrite.ts
 var pass = (body) => ({ body, threadKey: null, note: { action: "pass" } });
 var isAgentThread = (body) => Array.isArray(body.tools) && body.tools.length > 0;
@@ -1521,7 +1697,7 @@ function strategize(input) {
   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,
@@ -1531,7 +1707,7 @@ function strategize(input) {
     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);
@@ -1566,17 +1742,28 @@ function carried(from, to) {
     return to;
   return { ...to, note: { ...to.note, compacted: Boolean(to.note.compacted || from.note.compacted), actions } };
 }
-function rewrite(input, before) {
+function withLearnedLimit(input) {
+  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 };
+}
+function rewrite(given, before) {
+  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) } };
 }
-async function rewriteAsync(input, rerank = identityReranker) {
+async function rewriteAsync(given, rerank = identityReranker) {
+  const input = withLearnedLimit(given);
   if (!wantsRecall(input) || rerank === identityReranker)
     return rewrite(input);
   const first = strategize(input);
@@ -1590,7 +1777,8 @@ function located({ store, threadId, messages }) {
   const threadKey = threadKeyOf(threadId, messages);
   if (!threadKey)
     throw new RangeError("eunoe can only fold a thread that has at least one user turn");
-  return { threadKey, turns: splitTurns(messages).turns, state: store.read(threadKey) };
+  const turns = splitTurns(messages).turns;
+  return { threadKey, turns, keys: turnKeys(turns), state: store.read(threadKey) };
 }
 function checkedTurn(turn, turns, from) {
   if (turns.length <= from)
@@ -1599,19 +1787,19 @@ function checkedTurn(turn, turns, from) {
     throw new RangeError(`turn ${turn} is outside turns ${from}..${turns.length - 1}`);
   return turn;
 }
-function folded2(threadKey, turns, state) {
-  const cutTurn = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1;
+function folded2(threadKey, keys, state) {
+  const cutTurn = state.cut ? keys.indexOf(state.cut) : -1;
   const pins = new Set(state.pins);
-  return { threadKey, cutTurn: cutTurn > 0 ? cutTurn : null, pinned: turns.flatMap((turn, i) => pins.has(turnFingerprint(turn)) ? [i] : []) };
+  return { threadKey, cutTurn: cutTurn > 0 ? cutTurn : null, pinned: keys.flatMap((key, i) => pins.has(key) ? [i] : []) };
 }
-function withPins(state, turns, indices, pinned) {
+function withPins(state, turns, keys, indices, pinned) {
   const pins = new Set(state.pins);
   for (const index of indices) {
-    const fingerprint = turnFingerprint(turns[checkedTurn(index, turns, 0)]);
+    const key = keys[checkedTurn(index, turns, 0)];
     if (pinned)
-      pins.add(fingerprint);
+      pins.add(key);
     else
-      pins.delete(fingerprint);
+      pins.delete(key);
   }
   if (pins.size > 0)
     state.pins = [...pins].sort();
@@ -1619,115 +1807,28 @@ function withPins(state, turns, indices, pinned) {
     delete state.pins;
 }
 function foldThread(target, { at = "latest", pin = [] } = {}) {
-  const { threadKey, turns, state } = located(target);
+  const { threadKey, turns, keys, state } = located(target);
   const cut = checkedTurn(at === "latest" ? turns.length - 1 : at, turns, 1);
-  withPins(state, turns, pin, true);
+  withPins(state, turns, keys, pin, true);
   resetCut(state);
-  state.cut = turnFingerprint(turns[cut]);
+  state.cut = keys[cut];
+  retireRecalls(state, turns.slice(0, cut));
   state.keep = cut - 1;
   state.host = true;
   target.store.save(threadKey, state);
-  return folded2(threadKey, turns, state);
+  return folded2(threadKey, keys, state);
 }
 function pinTurns(target, indices, pinned = true) {
-  const { threadKey, turns, state } = located(target);
-  withPins(state, turns, indices, pinned);
+  const { threadKey, turns, keys, state } = located(target);
+  withPins(state, turns, keys, indices, pinned);
   target.store.save(threadKey, state);
-  return folded2(threadKey, turns, state);
-}
-// src/core/usage.ts
-function usageIn(line) {
-  if (!line.startsWith("data:") || !line.includes("message_start"))
-    return null;
-  try {
-    return JSON.parse(line.slice(5)).message?.usage ?? null;
-  } catch {
-    return null;
-  }
-}
-function trailingUsage(buffer) {
-  if (!buffer.trim().startsWith("{"))
-    return null;
-  try {
-    const json = JSON.parse(buffer);
-    if (json.usage)
-      return json.usage;
-    return typeof json.input_tokens === "number" ? { input_tokens: json.input_tokens } : null;
-  } catch {
-    return null;
-  }
-}
-function scanEvents(buffer) {
-  let rest = buffer;
-  for (let newline = rest.indexOf(`
-`);newline !== -1; newline = rest.indexOf(`
-`)) {
-    const usage = usageIn(rest.slice(0, newline).trim());
-    rest = rest.slice(newline + 1);
-    if (usage)
-      return { usage, rest };
-  }
-  return { usage: null, rest };
-}
-async function readUsage(stream) {
-  const reader = stream.pipeThrough(new TextDecoderStream).getReader();
-  let buffer = "";
-  let usage = null;
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done)
-      return usage ?? trailingUsage(buffer);
-    if (usage)
-      continue;
-    const scanned = scanEvents(buffer + value);
-    usage = scanned.usage;
-    buffer = scanned.rest.length > 4000000 ? "" : scanned.rest;
-  }
+  return folded2(threadKey, keys, state);
 }
-function watchUsage(response, onUsage) {
-  if (!response.body)
-    return response;
-  const [toClient, toUs] = response.body.tee();
-  readUsage(toUs).then((usage) => {
-    if (usage)
-      onUsage(usage);
-  }).catch(() => {
-    return;
-  });
-  return new Response(toClient, { status: response.status, statusText: response.statusText, headers: response.headers });
-}
-function inputTokens(usage) {
-  return (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
-}
-var OVERFLOW_MARGIN = 1.1;
-var charsOf = (sent) => typeof sent === "number" ? sent : sizeOf(sent);
-function overflowTokens(errorText) {
-  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 recordUsage(store, threadKey, sent, usage) {
-  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;
-}
-function recordOverflow(store, threadKey, sent, errorText) {
-  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;
-}
-
 // src/core/window.ts
-var LOOKUP_TIMEOUT_MS = 5000;
+var LOOKUP_TIMEOUT_MS = 1500;
+var RETRY_AFTER_MS = 10 * 60000;
+var LONG_SUFFIX = /\[1m\]$/i;
+var SUFFIX = /\[[^\]]*\]$/;
 function lookupHeaders(requestHeaders) {
   const headers = new Headers;
   for (const name of ["authorization", "x-api-key", "anthropic-version", "anthropic-beta"]) {
@@ -1739,10 +1840,21 @@ function lookupHeaders(requestHeaders) {
     headers.set("anthropic-version", "2023-06-01");
   return headers;
 }
-function createWindowLookup({ known = new Map, onLearn } = {}) {
+function familyWindow(model) {
+  if (LONG_SUFFIX.test(model))
+    return 1e6;
+  const id = model.replace(SUFFIX, "");
+  if (/^claude-(?:(?:opus|sonnet|haiku|fable)-5|opus-4-8)/.test(id))
+    return 1e6;
+  if (id.startsWith("claude-"))
+    return 200000;
+  return null;
+}
+function createWindowLookup({ known = new Map, onLearn, timeoutMs = LOOKUP_TIMEOUT_MS, retryAfterMs = RETRY_AFTER_MS } = {}) {
   const lookups = new Map;
+  const failedAt = new Map;
   const lookup = async (id, requestHeaders, upstream) => {
-    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();
@@ -1753,18 +1865,24 @@ function createWindowLookup({ known = new Map, 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);
   };
 }
 
@@ -1801,7 +1919,7 @@ function defaultPrepare(options, upstream) {
     return rewriteAsync({ body, threadId, config: options.config ?? CORE_DEFAULTS, store: options.store, sources, window, mayCompact }, options.reranker);
   };
 }
-var passthrough = (bodyText) => ({ note: { action: "pass" }, threadKey: null, bodyText, sentSize: 0, givenSize: 0, fixedSize: 0 });
+var passthrough = (bodyText) => ({ note: { action: "pass" }, model: undefined, threadKey: null, bodyText, sentSize: 0, givenSize: 0, fixedSize: 0 });
 async function outgoing(prepare, request, givenText, mayCompact) {
   try {
     const given = JSON.parse(givenText);
@@ -1809,6 +1927,7 @@ async function outgoing(prepare, request, givenText, mayCompact) {
     const sentSize = sizeOf(result.body);
     return {
       note: result.note,
+      model: given.model,
       threadKey: result.threadKey,
       bodyText: result.body !== given ? JSON.stringify(result.body, wellFormed) : givenText,
       sentSize,
@@ -1889,7 +2008,7 @@ function createForwarder(options) {
     if (answer.status >= 400 && out.note.action !== "pass") {
       const errorText = await answer.text();
       const logged = { path: url.pathname, status: answer.status, thread: out.threadKey, ...out.note };
-      const overflow = out.threadKey && !isCountTokens ? recordOverflow(options.store, out.threadKey, out.sentSize, errorText) : null;
+      const overflow = out.threadKey && !isCountTokens ? recordOverflow(options.store, out.threadKey, out.sentSize, errorText, out.model) : null;
       if (!overflow) {
         log({ ...logged, error: clipped(errorText) });
         return errorResponse(errorText);