@buoy-gg/agent-core 7.0.35 → 7.0.38

package/lib/module/engine/evidence.js

@@ -0,0 +1,107 @@
+"use strict";
+
+/**
+ * The evidence store: every tool result this conversation produced, kept in
+ * full so the model can go back to it.
+ *
+ * Two markers used to point nowhere. A result over 24 000 characters was cut
+ * with "ask for a narrower slice" — and no tool offers one, so the bank has
+ * cases tagged `capability` (Pokémon `stats` sit at offset ~180 000 of a
+ * 400 000-character detail; unreadable by design). And a result compressed
+ * out of memory said "ask again" — a re-dispatch returns the CURRENT value,
+ * not what the model saw before it wrote, which is the one it needs when a
+ * write is refused and it has to say what it changed FROM.
+ *
+ * So the full text is kept here, keyed by a short ref the markers carry, and
+ * `ask-buoy.retrieve` reads any part of it back: a path, a substring, a
+ * window. Borrowed from Strands' ContextOffloader (`retrieve_offloaded_content`
+ * with pattern / line_range), minus the storage layer — this is in-memory and
+ * per session on purpose: persisted transcripts deliberately carry no tool
+ * result payloads (see ask-buoy transcriptPersistence.ts), and this must not
+ * quietly change that.
+ *
+ * What goes in is what the MODEL was given: after `redact` (credential names
+ * and value shapes) and `stripSelfTraffic`. Never the raw adapter value.
+ *
+ * Bounded by bytes and entries, oldest out first; an evicted ref is remembered
+ * so the answer is "evicted" rather than "never existed" — the marker still
+ * names a real thing, and the honest reply is to call the tool again.
+ */
+
+const DEFAULT_MAX_CHARS = 4_000_000;
+const DEFAULT_MAX_ENTRIES = 200;
+export class EvidenceStore {
+  entries = new Map();
+  evictedRefs = new Set();
+  chars = 0;
+  seq = 0;
+  constructor(opts = {}) {
+    this.maxChars = opts.maxChars ?? DEFAULT_MAX_CHARS;
+    this.maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+
+  /** Keep a result. Returns its ref — `ev_<n>`, counting up for the life of the store. */
+  stash(input) {
+    const ref = `ev_${++this.seq}`;
+    const entry = {
+      ...input,
+      ref
+    };
+    // A single result larger than the whole store still gets a ref — it is
+    // the case the store exists for — and simply evicts everything else.
+    this.entries.set(ref, entry);
+    this.chars += entry.text.length;
+    this.evict();
+    return ref;
+  }
+  get(ref) {
+    return this.entries.get(ref);
+  }
+
+  /** True when the ref was real and has since been dropped for space. */
+  wasEvicted(ref) {
+    return this.evictedRefs.has(ref);
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get totalChars() {
+    return this.chars;
+  }
+
+  /** New conversation: nothing from the old one is retrievable. */
+  clear() {
+    this.entries.clear();
+    this.evictedRefs.clear();
+    this.chars = 0;
+  }
+  evict() {
+    // Map iteration is insertion order, so the first key is the oldest.
+    for (const [ref, entry] of this.entries) {
+      const over = this.chars > this.maxChars || this.entries.size > this.maxEntries;
+      if (!over || this.entries.size === 1) return;
+      this.entries.delete(ref);
+      this.evictedRefs.add(ref);
+      this.chars -= entry.text.length;
+    }
+  }
+}
+
+// ── the markers ──────────────────────────────────────────────────────────────
+
+const RETRIEVE_HINT = "ask-buoy.retrieve";
+
+/** The tail of a result cut at the engine's cap. */
+export function truncationMarker(totalChars, ref) {
+  const size = totalChars.toLocaleString("en-US");
+  if (!ref) return `\n\n[truncated — ${size} characters total. Ask for a narrower slice if you need more.]`;
+  return `\n\n[truncated — ${size} characters total; ref ${ref}. Call ${RETRIEVE_HINT} {"ref":"${ref}"} to see its shape, then {"ref":"${ref}","path":"…"} or {"ref":"${ref}","pattern":"…"} to read the part you need.]`;
+}
+
+/** What a consumed result is replaced with when history is compressed. Keep the `[earlier result` prefix — historyBudget skips on it. */
+export function compressedMarker(totalChars, ref) {
+  const size = totalChars.toLocaleString("en-US");
+  if (!ref) return `[earlier result — ${size} characters, already read. Ask again if you need it.]`;
+  return `[earlier result — ${size} characters, already read; ref ${ref}. ${RETRIEVE_HINT} {"ref":"${ref}",…} re-reads exactly what you saw then; calling the tool again gives the CURRENT value.]`;
+}
+//# sourceMappingURL=evidence.js.map

package/lib/module/engine/evidence.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DEFAULT_MAX_CHARS","DEFAULT_MAX_ENTRIES","EvidenceStore","entries","Map","evictedRefs","Set","chars","seq","constructor","opts","maxChars","maxEntries","stash","input","ref","entry","set","text","length","evict","get","wasEvicted","has","size","totalChars","clear","over","delete","add","RETRIEVE_HINT","truncationMarker","toLocaleString","compressedMarker"],"sourceRoot":"../../../src","sources":["engine/evidence.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/engine/historyBudget.js

@@ -0,0 +1,355 @@
+"use strict";
+
+/**
+ * How much conversation the model is allowed to be sent, and what gets cut.
+ *
+ * Lives here, not in `session.ts`, because it is needed in TWO places and used
+ * to run in only one. The session trims once per turn, before the loop starts
+ * — and a turn is not one request. A twelve-step investigation appends an
+ * assistant message and a tool-results message per step, each result capped at
+ * 24,000 characters, so a long read chain could add well over a hundred
+ * thousand characters AFTER the only check had already happened and walk
+ * straight into the provider's context limit. The engine now applies the same
+ * budget before every request; the session still applies it when a turn opens.
+ */
+
+import { compressedMarker } from "./evidence";
+import { DEFAULT_CHARS_PER_TOKEN } from "./tokenCalibration";
+
+/**
+ * A long QA session must not die on the provider's context limit with an
+ * opaque error, so the history is kept under a budget.
+ *
+ * TWO STAGES, AND THE ORDER IS THE POINT. Dropping the oldest rounds was the
+ * only stage, and in a QA session the oldest round is usually the SETUP — the
+ * override that was armed, the store that was written, the user someone is
+ * impersonating. Drop it and the model can no longer explain the screen it is
+ * looking at, or that a "wrong" response is its own mock. The reply gets worse
+ * in exactly the sessions long enough to need trimming.
+ *
+ * So: COMPRESS first, DROP only if that was not enough.
+ *
+ * A tool result is "consumed" once the model has produced an assistant message
+ * after seeing it — it has already been reasoned over, and what remains is
+ * bulk. Replacing it with a marker keeps the round, its decision and its
+ * ordering while giving back nearly all the bytes. Three exemptions carry
+ * their weight:
+ *
+ * - Errors are never compressed. A failure is the diagnostic value.
+ * - The newest tool-results message is never compressed. The model is about
+ *   to answer from it.
+ * - The last read before a WRITE is never compressed: that is the shape the
+ *   model matched its edit to, and it is the thing it re-reads when the write
+ *   is refused and it has to correct itself.
+ *
+ * Only if the history is still over budget do whole rounds get dropped, as
+ * before — a round starts at a user message, so the assistant/tool-result
+ * pairing every provider requires stays intact.
+ */
+/**
+ * The limits are in TOKENS — the unit the provider enforces — and turned into
+ * characters at the ratio the session has measured (engine/tokenCalibration.ts).
+ * The `_CHARS` constants below are those limits at the default 4 chars/token,
+ * kept for callers that have no calibration in hand (tests, one-shot use).
+ */
+export const MAX_HISTORY_TOKENS = 37_500;
+/**
+ * The ceiling on a WHOLE request: tools, system prompt, messages and the room
+ * reserved for the reply. 100k tokens fits the smallest context Ask Buoy is
+ * pointed at in practice (a 128k-token gateway) with headroom, and leaves
+ * Anthropic's 200k far from the limit.
+ */
+export const MAX_REQUEST_TOKENS = 100_000;
+export const MAX_HISTORY_CHARS = MAX_HISTORY_TOKENS * DEFAULT_CHARS_PER_TOKEN;
+export const MAX_REQUEST_CHARS = MAX_REQUEST_TOKENS * DEFAULT_CHARS_PER_TOKEN;
+const MIN_KEEP_MESSAGES = 4;
+/** Below this a marker costs more than the payload it replaces. */
+const MIN_COMPRESS_CHARS = 400;
+export function messageSize(m) {
+  try {
+    return JSON.stringify(m).length;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Replace consumed tool results with a marker. See the note above
+ * MAX_HISTORY_CHARS for what "consumed" means and why the exemptions exist.
+ */
+export function compressConsumed(messages, exemptNewest = true) {
+  // The newest tool-results message: the model is about to answer from it.
+  // Unless the caller says otherwise — `budgetForRequest` hands in the rounds
+  // BEFORE the current one, whose last result was answered long ago.
+  let newest = messages.length;
+  if (exemptNewest) {
+    newest = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].role === "tool-results") {
+        newest = i;
+        break;
+      }
+    }
+    if (newest <= 0) return messages;
+  }
+
+  // The reads a later write depended on. An assistant turn that called a
+  // write was matching a shape it read in the round before, and that is the
+  // read it goes back to when the write is refused.
+  const beforeWrite = new Set();
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (m.role !== "assistant" || !m.toolCalls?.length) continue;
+    if (!m.toolCalls.some(c => WRITE_ISH.test(JSON.stringify(c.input ?? {}) + c.name))) continue;
+    for (let j = i - 1; j >= 0 && j >= i - 3; j--) {
+      if (messages[j].role === "tool-results") {
+        beforeWrite.add(j);
+        break;
+      }
+    }
+  }
+  let changed = false;
+  const out = messages.map((m, i) => {
+    if (m.role !== "tool-results" || i >= newest || beforeWrite.has(i)) return m;
+    let touched = false;
+    const results = m.results.map(r => {
+      if (r.isError || r.content.length < MIN_COMPRESS_CHARS) return r;
+      if (r.content.startsWith("[earlier result")) return r;
+      touched = true;
+      // The ref survives the compression: the marker names it, and a later
+      // `retrieve` reads the full text back. See engine/evidence.ts.
+      return {
+        ...r,
+        content: compressedMarker(r.content.length, r.ref)
+      };
+    });
+    if (!touched) return m;
+    changed = true;
+    return {
+      ...m,
+      results
+    };
+  });
+  return changed ? out : messages;
+}
+
+/**
+ * Heuristic for "this call changed something". Deliberately loose: the cost of
+ * a false positive is one uncompressed read, the cost of a false negative is
+ * the model losing the shape it was editing.
+ */
+const WRITE_ISH = /set|write|dispatch|navigate|tap|override|restore|delete|remove|clear|save|run|impersonat|reload/i;
+
+/**
+ * A round: a user message and everything up to the next one. `pinned` when
+ * one of its tool calls made a change that is still applied — see
+ * `dropRounds`.
+ */
+
+function splitRounds(messages, pinnedCallIds) {
+  const rounds = [];
+  for (const m of messages) {
+    if (m.role === "user" || rounds.length === 0) rounds.push({
+      messages: [],
+      size: 0,
+      pinned: false
+    });
+    const round = rounds[rounds.length - 1];
+    round.messages.push(m);
+    round.size += messageSize(m);
+    if (pinnedCallIds?.size && m.role === "assistant" && m.toolCalls?.some(c => pinnedCallIds.has(c.id))) round.pinned = true;
+  }
+  return rounds;
+}
+
+/**
+ * Drop whole rounds, oldest first, until `keepSize + dropped` fits — but the
+ * PINNED rounds last.
+ *
+ * Dropping oldest-first was the whole rule, and in a QA session the oldest
+ * round is usually the SETUP: the override that was armed, the store that
+ * was written, the user someone is impersonating. Lose it and the model can
+ * no longer explain the screen it is looking at, or that a "wrong" response
+ * is its own mock — and the changes list in the prompt names the change but
+ * not the reasoning around it. The ledger knows which changes are still
+ * applied, so a round that made one is kept (compressed, like any other) for
+ * as long as an unpinned round remains to drop instead. Only when nothing
+ * else is left do pinned rounds go, oldest first, and the caller says so.
+ * Strands' `pin-message.ts` is the same idea, keyed on message metadata.
+ *
+ * `minMessages` is the floor the session-level trim keeps (a history that
+ * opens mid-exchange is rejected by every provider; the floor is applied on
+ * STARTING a drop, so a drop always runs to the next user boundary).
+ */
+function dropRounds(rounds, budget, keepSize, minMessages) {
+  const remaining = [...rounds];
+  let size = remaining.reduce((n, r) => n + r.size, 0);
+  let droppedRounds = 0;
+  let droppedPinned = 0;
+  const messageCount = () => remaining.reduce((n, r) => n + r.messages.length, 0);
+  while (remaining.length > 0 && size + keepSize > budget && messageCount() > minMessages) {
+    let i = remaining.findIndex(r => !r.pinned);
+    if (i < 0) {
+      i = 0;
+      droppedPinned += 1;
+    }
+    size -= remaining[i].size;
+    remaining.splice(i, 1);
+    droppedRounds += 1;
+  }
+  return {
+    kept: remaining.flatMap(r => r.messages),
+    droppedRounds,
+    droppedPinned
+  };
+}
+
+/**
+ * Trim, and say how many whole rounds were dropped — the number the UI turns
+ * into "older messages were trimmed from the agent's memory".
+ *
+ * A round is a user message and everything up to the next one. Once a drop
+ * starts it ALWAYS runs to the next user boundary: the inner loop used to stop
+ * at `MIN_KEEP_MESSAGES` as well, so a history could come out starting with an
+ * assistant or tool-results message — which every provider rejects. The
+ * minimum-keep guard belongs on STARTING a drop, not on finishing one.
+ */
+export function trimHistoryReport(messages, charsPerToken = DEFAULT_CHARS_PER_TOKEN, /** Tool-call ids whose change is still applied — their rounds are dropped last. See dropRounds. */
+pinnedCallIds) {
+  const limit = Math.floor(MAX_HISTORY_TOKENS * charsPerToken);
+  let total = 0;
+  for (const m of messages) total += messageSize(m);
+  if (total <= limit) return {
+    messages,
+    droppedRounds: 0,
+    droppedPinned: 0
+  };
+
+  // Compress before dropping — a compressed round still explains the screen.
+  const compressed = compressConsumed(messages);
+  let after = 0;
+  for (const m of compressed) after += messageSize(m);
+  if (after <= limit) return {
+    messages: compressed,
+    droppedRounds: 0,
+    droppedPinned: 0
+  };
+  const {
+    kept,
+    droppedRounds,
+    droppedPinned
+  } = dropRounds(splitRounds(compressed, pinnedCallIds), limit, 0, MIN_KEEP_MESSAGES);
+  return {
+    messages: kept,
+    droppedRounds,
+    droppedPinned
+  };
+}
+
+/** Exported for the history tests; not part of the package surface. */
+export function trimHistory(messages) {
+  return trimHistoryReport(messages).messages;
+}
+
+/**
+ * Trim the working history of a turn that is still running.
+ *
+ * Differs from `trimHistoryReport` in one way that matters: the CURRENT round
+ * is never touched. A turn's own user message and the reads it has taken since
+ * are the thing being answered, so compressing or dropping them would make the
+ * request cheaper and the answer wrong. Everything before the last user
+ * message is fair game, in the same order as always — compress, then drop.
+ *
+ * `reserve` is what the request costs BEFORE any messages: the tool
+ * definitions (~8k tokens for a typical install, ~23k with everything
+ * installed), the system prompt, and the reply the model is allowed to write.
+ * Budgeting messages alone would leave the biggest fixed cost out of the sum.
+ */
+export function budgetForRequest(messages, reserve,
+/**
+ * A tighter ceiling on the messages than MAX_HISTORY_CHARS — set by the
+ * engine after the provider refused a request as too big. The proactive
+ * budget is an estimate; the provider's refusal is the truth.
+ */
+cap = MAX_HISTORY_CHARS, /** The session's measured ratio; scales the whole-request ceiling. */
+charsPerToken = DEFAULT_CHARS_PER_TOKEN, /** Tool-call ids whose change is still applied — their rounds are dropped last. See dropRounds. */
+pinnedCallIds) {
+  /**
+   * `MAX_HISTORY_CHARS` is a MESSAGES budget and always was — subtracting the
+   * reserve from it is wrong by a wide margin. The tool block alone is ~94,000
+   * characters with every tool installed, and the system prompt another
+   * ~16,000, so `150,000 - reserve` left about 24,000 characters for the
+   * conversation and dropped every earlier round of a two-turn chat. Caught by
+   * the bank, which is exactly what it is for.
+   *
+   * So the messages budget is the smaller of the two ceilings: the one that
+   * has always applied, and whatever is left of the whole-request ceiling once
+   * the fixed cost is counted. In an ordinary install the first wins and
+   * nothing changes; the second only bites when the tools are huge.
+   */
+  const budget = Math.min(cap, Math.floor(MAX_REQUEST_TOKENS * charsPerToken) - reserve);
+  let total = 0;
+  for (const m of messages) total += messageSize(m);
+  if (total <= budget) return {
+    messages,
+    droppedRounds: 0,
+    droppedPinned: 0
+  };
+
+  // Where the current round begins. Nothing from here on is eligible.
+  let currentRound = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      currentRound = i;
+      break;
+    }
+  }
+  if (currentRound <= 0) {
+    // The whole history is this one round and it is over the limit by
+    // itself. Its consumed results are compressed, the newest kept — see the
+    // last-resort note below; this is the same move with nothing to drop.
+    return {
+      messages: compressConsumed(messages),
+      droppedRounds: 0,
+      droppedPinned: 0
+    };
+  }
+  const earlier = messages.slice(0, currentRound);
+  const current = messages.slice(currentRound);
+  let currentSize = 0;
+  for (const m of current) currentSize += messageSize(m);
+
+  // `false`: the earlier rounds' last result was answered long ago — the
+  // newest-result exemption is about the round being answered NOW.
+  const compressed = compressConsumed(earlier, false);
+  let earlierSize = 0;
+  for (const m of compressed) earlierSize += messageSize(m);
+  if (earlierSize + currentSize <= budget) {
+    return {
+      messages: [...compressed, ...current],
+      droppedRounds: 0,
+      droppedPinned: 0
+    };
+  }
+  const {
+    kept: out,
+    droppedRounds,
+    droppedPinned
+  } = dropRounds(splitRounds(compressed, pinnedCallIds), budget, currentSize, 0);
+  earlierSize = out.reduce((n, m) => n + messageSize(m), 0);
+  /**
+   * LAST RESORT, inside the current round. Everything earlier is gone and the
+   * turn's own reads are still over the limit — a twelve-step investigation
+   * of 24k-character results does that by itself. The consumed ones (an
+   * assistant message came after them) are compressed the same way earlier
+   * rounds were, newest result and the reads before a write still exempt.
+   * Their refs make this lossless for the model: `retrieve` reads them back.
+   */
+  const currentOut = out.length === 0 && earlierSize + currentSize > budget ? compressConsumed(current) : current;
+  return {
+    messages: [...out, ...currentOut],
+    droppedRounds,
+    droppedPinned
+  };
+}
+//# sourceMappingURL=historyBudget.js.map

package/lib/module/engine/historyBudget.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["compressedMarker","DEFAULT_CHARS_PER_TOKEN","MAX_HISTORY_TOKENS","MAX_REQUEST_TOKENS","MAX_HISTORY_CHARS","MAX_REQUEST_CHARS","MIN_KEEP_MESSAGES","MIN_COMPRESS_CHARS","messageSize","m","JSON","stringify","length","compressConsumed","messages","exemptNewest","newest","i","role","beforeWrite","Set","toolCalls","some","c","WRITE_ISH","test","input","name","j","add","changed","out","map","has","touched","results","r","isError","content","startsWith","ref","splitRounds","pinnedCallIds","rounds","push","size","pinned","round","id","dropRounds","budget","keepSize","minMessages","remaining","reduce","n","droppedRounds","droppedPinned","messageCount","findIndex","splice","kept","flatMap","trimHistoryReport","charsPerToken","limit","Math","floor","total","compressed","after","trimHistory","budgetForRequest","reserve","cap","min","currentRound","earlier","slice","current","currentSize","earlierSize","currentOut"],"sourceRoot":"../../../src","sources":["engine/historyBudget.ts"],"mappings":"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","ignoreList":[]}