@buoy-gg/agent-core 7.0.40 → 7.0.42

package/lib/module/engine/effectFor.js

@@ -1,173 +1 @@
-"use strict";
-
-/**
- * Turn a completed mutation into a ledger entry.
- *
- * The shape is Scenarios' `extractEffect`, but the classification here is much
- * more conservative, because auditing the catalog's undo claims found almost
- * all of them unsound: the information needed to reverse a call usually does
- * not survive the call. So an effect is only marked reversible when THIS
- * module can point at the exact input the reversal needs.
- *
- * Everything else becomes `state-write` (changed something, no automatic
- * inverse) or `transient` (one-shot). Both are shown to the user as such. A
- * banner that says "4 changes" and then reverses one of them is worse than a
- * banner that admits three of them are permanent.
- */
-
-import { describeCall } from "../policy/policy";
-import { digestOf, jsonLength } from "../effects/digest";
-
-/**
- * The largest prior value an undo will hold. The ledger is persisted with the
- * transcript under a 256KB cap; a payload past this is recorded as a visible,
- * honestly-permanent change instead of silently evicting the conversation.
- */
-const MAX_UNDO_JSON_CHARS = 64_000;
-
-/** The `getQueryData` read the engine takes on both sides of a cache write. */
-
-const cacheRead = v => v && typeof v === "object" ? v : undefined;
-
-/**
- * How each query change is actually put back, named in the row so the bar is
- * useful rather than merely honest. A cache edit's real inverse is a refetch:
- * the tool's own description says a cache edit "lasts until the next
- * successful refetch".
- */
-const QUERY_RESTORES = {
-  setQueryData: "query.invalidate",
-  triggerError: "query.restoreError",
-  triggerLoading: "query.restoreLoading",
-  setOnline: "query.setOnline"
-};
-export function effectFor(toolId, descriptor, params, result, before, /** The query cache read before and after a `setQueryData` — see runAgentTurn. */
-cache) {
-  const label = describeCall(toolId, descriptor, params);
-  const rec = result ?? {};
-
-  // A network override rule. Reversible ONLY when we created it: `upsert` with
-  // an id that already exists UPDATES that rule in place, so deleting it would
-  // destroy a rule the user had set up themselves rather than undo our change.
-  // The model supplying no id is the create case.
-  if (toolId === "network" && descriptor.action === "upsertOverrideRule") {
-    const rule = rec.rule;
-    const ruleId = rule?.id ?? rec.id;
-    const wasCreate = params.id === undefined;
-    if (ruleId && wasCreate) return {
-      kind: "network-override",
-      ruleId,
-      label
-    };
-    return {
-      kind: "state-write",
-      toolId,
-      action: descriptor.action,
-      label
-    };
-  }
-
-  // Impersonation. `stopImpersonation` restores the identity but ALSO re-runs
-  // the data nuke — it clears react-query, redux, AsyncStorage and MMKV per
-  // the app's dataNukeSettings. So this is reversible in the sense that
-  // matters (the user stops being someone else) and the label has to say the
-  // rest out loud, because caches do not come back.
-  if (toolId === "impersonate" && descriptor.action === "startImpersonation") {
-    return {
-      kind: "impersonation",
-      label: `${label} — stopping also clears cached app data`
-    };
-  }
-
-  // Storage, reversible because we read the old value first (see captureBefore).
-  // `before` is undefined when the pre-read could not be made — an MMKV write
-  // with no instance, a secure key behind biometrics — and that must fall
-  // through to a one-off rather than claim an undo it cannot perform.
-  if (toolId === "storage" && typeof params.key === "string" && before) {
-    const isMmkv = descriptor.action.startsWith("mmkv.");
-    const writeAction = isMmkv ? "mmkv.set" : "async.setItem";
-    return {
-      kind: "storage-write",
-      toolId,
-      action: writeAction,
-      key: params.key,
-      instanceId: isMmkv && typeof params.instanceId === "string" ? params.instanceId : undefined,
-      before: before.had ? before.value : undefined,
-      wrote: typeof params.value === "string" ? params.value : undefined,
-      removeAction: isMmkv ? "mmkv.remove" : "async.removeItem",
-      label
-    };
-  }
-
-  /**
-   * A cache edit is a CHANGE, not a one-shot.
-   *
-   * `setQueryData` is the headline write of the whole product — "THE way to
-   * change what a server-backed screen shows" — and it fell through to
-   * `transient` here, which the changes bar deliberately does not count. So
-   * the sheet said "Anything it changes shows up in a bar at the top, and you
-   * can undo it" and then changed the screen in front of you with no row, no
-   * count and no undo. Same for `triggerError` and `triggerLoading`: the app
-   * is left showing a failure state that nothing on screen admits to putting
-   * there, which is exactly how a QA tester files a bug against a state Buoy
-   * created.
-   *
-   * `setQueryData` is now a real `query-write` above, because the engine
-   * reads the query's data before the write (captureStoreState) — the same
-   * pre-read that makes storage reversible. The rest — triggerError,
-   * triggerLoading, setOnline, a setQueryData whose pre-read failed — stay
-   * `state-write` (visible, honestly permanent): this module only claims an
-   * undo it can actually perform, and the label carries the real revert so
-   * the row is still useful.
-   */
-  if (toolId === "query" && descriptor.action === "setQueryData") {
-    const prior = cacheRead(cache?.before);
-    const queryHash = typeof params.queryHash === "string" ? params.queryHash : prior?.queryHash;
-    if (prior?.found === true && typeof queryHash === "string") {
-      const had = prior.hasData !== false && prior.data !== undefined;
-      const beforeData = had ? prior.data : undefined;
-      if (jsonLength(beforeData) <= MAX_UNDO_JSON_CHARS) {
-        const after = cacheRead(cache?.after);
-        const wroteDigest = after?.found === true && after.hasData !== false ? digestOf(after.data) : undefined;
-        return {
-          kind: "query-write",
-          queryHash,
-          before: beforeData,
-          wroteDigest,
-          label
-        };
-      }
-      return {
-        kind: "state-write",
-        toolId,
-        action: descriptor.action,
-        label: `${label} — prior value too large to hold for undo; undo with query.invalidate`
-      };
-    }
-  }
-  if (toolId === "query" && descriptor.effect !== "read") {
-    const restores = QUERY_RESTORES[descriptor.action];
-    return {
-      kind: "state-write",
-      toolId,
-      action: descriptor.action,
-      label: restores ? `${label} — undo with ${restores}` : label
-    };
-  }
-
-  // Wipes with no captured prior state are permanent. Say so rather than
-  // filing them under something Undo appears to cover.
-  if (descriptor.effect === "destructive") {
-    return {
-      kind: "state-write",
-      toolId,
-      action: descriptor.action,
-      label
-    };
-  }
-  return {
-    kind: "transient",
-    label
-  };
-}
-//# sourceMappingURL=effectFor.js.map
+"use strict";import{describeCall as v}from"../policy/policy";import{digestOf as k,jsonLength as h}from"../effects/digest";const q=64e3;const l=n=>n&&typeof n==="object"?n:void 0;const w={setQueryData:"query.invalidate",triggerError:"query.restoreError",triggerLoading:"query.restoreLoading",setOnline:"query.setOnline"};export function effectFor(n,t,i,y,u,c){const r=v(n,t,i);const f=y??{};if(n==="network"&&t.action==="upsertOverrideRule"){const e=f.rule;const a=e?.id??f.id;const s=i.id===void 0;if(a&&s)return{kind:"network-override",ruleId:a,label:r};return{kind:"state-write",toolId:n,action:t.action,label:r}}if(n==="impersonate"&&t.action==="startImpersonation"){return{kind:"impersonation",label:`${r} \u2014 stopping also clears cached app data`}}if(n==="storage"&&typeof i.key==="string"&&u){const e=t.action.startsWith("mmkv.");const a=e?"mmkv.set":"async.setItem";return{kind:"storage-write",toolId:n,action:a,key:i.key,instanceId:e&&typeof i.instanceId==="string"?i.instanceId:void 0,before:u.had?u.value:void 0,wrote:typeof i.value==="string"?i.value:void 0,removeAction:e?"mmkv.remove":"async.removeItem",label:r}}if(n==="query"&&t.action==="setQueryData"){const e=l(c?.before);const a=typeof i.queryHash==="string"?i.queryHash:e?.queryHash;if(e?.found===true&&typeof a==="string"){const s=e.hasData!==false&&e.data!==void 0;const d=s?e.data:void 0;if(h(d)<=q){const o=l(c?.after);const g=o?.found===true&&o.hasData!==false?k(o.data):void 0;return{kind:"query-write",queryHash:a,before:d,wroteDigest:g,label:r}}return{kind:"state-write",toolId:n,action:t.action,label:`${r} \u2014 prior value too large to hold for undo; undo with query.invalidate`}}}if(n==="query"&&typeof i.queryHash==="string"){const e=t.action==="triggerLoading"?"restoreLoading":t.action==="triggerError"?"restoreError":void 0;if(e){return{kind:"inverse-call",toolId:n,action:e,params:{queryHash:i.queryHash},label:r}}}if(n==="query"&&["refetch","invalidate","restoreLoading"].includes(t.action)){return{kind:"transient",label:r}}if(n==="network"&&(t.action==="setOverrideRuleEnabled"||t.action==="setOverridesEnabled")&&u?.had&&(u.value==="true"||u.value==="false")){const e=u.value==="true";const a=i.enabled===true;if(e===a)return void 0;const s=t.action==="setOverrideRuleEnabled"?{id:i.id,enabled:e}:{enabled:e};return{kind:"inverse-call",toolId:n,action:t.action,params:s,label:r}}if(n==="query"&&t.effect!=="read"){const e=w[t.action];return{kind:"state-write",toolId:n,action:t.action,label:e?`${r} \u2014 undo with ${e}`:r}}if(t.effect==="destructive"){return{kind:"state-write",toolId:n,action:t.action,label:r}}return{kind:"transient",label:r}}

package/lib/module/engine/evidence.js

@@ -1,107 +1,5 @@
-"use strict";
+"use strict";const i=4e6;const n=200;export class EvidenceStore{entries=new Map;evictedRefs=new Set;chars=0;seq=0;constructor(e={}){this.maxChars=e.maxChars??i;this.maxEntries=e.maxEntries??n}stash(e){const t=`ev_${++this.seq}`;const s={...e,ref:t};this.entries.set(t,s);this.chars+=s.text.length;this.evict();return t}get(e){return this.entries.get(e)}wasEvicted(e){return this.evictedRefs.has(e)}get size(){return this.entries.size}get totalChars(){return this.chars}clear(){this.entries.clear();this.evictedRefs.clear();this.chars=0}evict(){for(const[e,t]of this.entries){const s=this.chars>this.maxChars||this.entries.size>this.maxEntries;if(!s||this.entries.size===1)return;this.entries.delete(e);this.evictedRefs.add(e);this.chars-=t.text.length}}}const a="ask-buoy.retrieve";export function truncationMarker(r,e){const t=r.toLocaleString("en-US");if(!e)return`
 
-/**
- * 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.
- */
+[truncated \u2014 ${t} characters total. Ask for a narrower slice if you need more.]`;return`
 
-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
+[truncated \u2014 ${t} characters total; ref ${e}. Call ${a} {"ref":"${e}"} to see its shape, then {"ref":"${e}","path":"\u2026"} or {"ref":"${e}","pattern":"\u2026"} to read the part you need.]`}export function compressedMarker(r,e){const t=r.toLocaleString("en-US");if(!e)return`[earlier result \u2014 ${t} characters, already read. Ask again if you need it.]`;return`[earlier result \u2014 ${t} characters, already read; ref ${e}. ${a} {"ref":"${e}",\u2026} re-reads exactly what you saw then; calling the tool again gives the CURRENT value.]`}

package/lib/module/engine/historyBudget.js

@@ -1,355 +1 @@
-"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
+"use strict";import{compressedMarker as P}from"./evidence";import{DEFAULT_CHARS_PER_TOKEN as a}from"./tokenCalibration";export const MAX_HISTORY_TOKENS=37500;export const MAX_REQUEST_TOKENS=1e5;export const MAX_HISTORY_CHARS=MAX_HISTORY_TOKENS*a;export const MAX_REQUEST_CHARS=MAX_REQUEST_TOKENS*a;const x=4;const A=400;export function messageSize(e){try{return JSON.stringify(e).length}catch{return 0}}export function compressConsumed(e,c=true){let i=e.length;if(c){i=-1;for(let t=e.length-1;t>=0;t--){if(e[t].role==="tool-results"){i=t;break}}if(i<=0)return e}const d=new Set;for(let t=0;t<e.length;t++){const u=e[t];if(u.role!=="assistant"||!u.toolCalls?.length)continue;if(!u.toolCalls.some(s=>z.test(JSON.stringify(s.input??{})+s.name)))continue;for(let s=t-1;s>=0&&s>=t-3;s--){if(e[s].role==="tool-results"){d.add(s);break}}}let o=false;const l=e.map((t,u)=>{if(t.role!=="tool-results"||u>=i||d.has(u))return t;let s=false;const n=t.results.map(r=>{if(r.isError||r.content.length<A)return r;if(r.content.startsWith("[earlier result"))return r;s=true;return{...r,content:P(r.content.length,r.ref)}});if(!s)return t;o=true;return{...t,results:n}});return o?l:e}const z=/set|write|dispatch|navigate|tap|override|restore|delete|remove|clear|save|run|impersonat|reload/i;function S(e,c){const i=[];for(const d of e){if(d.role==="user"||i.length===0)i.push({messages:[],size:0,pinned:false});const o=i[i.length-1];o.messages.push(d);o.size+=messageSize(d);if(c?.size&&d.role==="assistant"&&d.toolCalls?.some(l=>c.has(l.id)))o.pinned=true}return i}function m(e,c,i,d){const o=[...e];let l=o.reduce((n,r)=>n+r.size,0);let t=0;let u=0;const s=()=>o.reduce((n,r)=>n+r.messages.length,0);while(o.length>0&&l+i>c&&s()>d){let n=o.findIndex(r=>!r.pinned);if(n<0){n=0;u+=1}l-=o[n].size;o.splice(n,1);t+=1}return{kept:o.flatMap(n=>n.messages),droppedRounds:t,droppedPinned:u}}export function trimHistoryReport(e,c=a,i){const d=Math.floor(MAX_HISTORY_TOKENS*c);let o=0;for(const r of e)o+=messageSize(r);if(o<=d)return{messages:e,droppedRounds:0,droppedPinned:0};const l=compressConsumed(e);let t=0;for(const r of l)t+=messageSize(r);if(t<=d)return{messages:l,droppedRounds:0,droppedPinned:0};const{kept:u,droppedRounds:s,droppedPinned:n}=m(S(l,i),d,0,x);return{messages:u,droppedRounds:s,droppedPinned:n}}export function trimHistory(e){return trimHistoryReport(e).messages}export function budgetForRequest(e,c,i=MAX_HISTORY_CHARS,d=a,o){const l=Math.min(i,Math.floor(MAX_REQUEST_TOKENS*d)-c);let t=0;for(const p of e)t+=messageSize(p);if(t<=l)return{messages:e,droppedRounds:0,droppedPinned:0};let u=-1;for(let p=e.length-1;p>=0;p--){if(e[p].role==="user"){u=p;break}}if(u<=0){return{messages:compressConsumed(e),droppedRounds:0,droppedPinned:0}}const s=e.slice(0,u);const n=e.slice(u);let r=0;for(const p of n)r+=messageSize(p);const h=compressConsumed(s,false);let f=0;for(const p of h)f+=messageSize(p);if(f+r<=l){return{messages:[...h,...n],droppedRounds:0,droppedPinned:0}}const{kept:R,droppedRounds:_,droppedPinned:g}=m(S(h,o),l,r,0);f=R.reduce((p,M)=>p+messageSize(M),0);const E=R.length===0&&f+r>l?compressConsumed(n):n;return{messages:[...R,...E],droppedRounds:_,droppedPinned:g}}