@genesislcap/ai-assistant 15.23.0 → 15.23.1-FUI-0.4

package/dist/chat-driver.mjs

@@ -3787,6 +3787,21 @@ function createInteractionContext(interactionId) {
 var APPROX_CHARS_PER_TOKEN = 4;
 var IMAGE_TOKEN_ESTIMATE = 1600;
 var PER_MESSAGE_FRAMING_TOKENS = 4;
+var PREAMBLE_PROSE_CHARS_PER_TOKEN = 4;
+var PREAMBLE_JSON_CHARS_PER_TOKEN = 3;
+var PER_TOOL_FRAMING_TOKENS = 8;
+function estimatePreambleTokens(input) {
+  const prose = (input.systemPrompt?.length ?? 0) + (input.tailContext?.length ?? 0);
+  let json = 0;
+  for (const def of input.toolDefinitions ?? []) {
+    try {
+      json += JSON.stringify(def).length;
+    } catch {
+      json += def.name?.length ?? 0;
+    }
+  }
+  return Math.ceil(prose / PREAMBLE_PROSE_CHARS_PER_TOKEN) + Math.ceil(json / PREAMBLE_JSON_CHARS_PER_TOKEN) + (input.toolDefinitions?.length ?? 0) * PER_TOOL_FRAMING_TOKENS;
+}
 var COMPACTION_SUMMARY_TOKEN_ESTIMATE = 1200;
 function reachesProvider(m) {
   if (m.role === "system-event" || m.role === "synthetic-user") return false;
@@ -3831,66 +3846,66 @@ function usableAnchor(m, compactedAt) {
 function firstAnchor(history, compactedAt) {
   return history.findIndex((m) => usableAnchor(m, compactedAt));
 }
-function estimateMessageTokens(history) {
-  const estimates = history.map(baselineTokens);
-  const compactedAt = compactedAtOf(history);
-  const anchors = [];
-  history.forEach((m, i) => {
-    if (usableAnchor(m, compactedAt)) anchors.push(i);
-  });
-  for (let a = 0; a < anchors.length - 1; a += 1) {
-    const from = anchors[a];
-    const to = anchors[a + 1];
-    const measured = history[to].inputTokens - history[from].inputTokens;
-    if (measured <= 0) continue;
-    let baseline = 0;
-    for (let i = from; i < to; i += 1) baseline += estimates[i];
-    if (baseline <= 0) {
-      estimates[from] = measured;
-      continue;
-    }
-    const scale = measured / baseline;
-    let assigned = 0;
-    for (let i = from; i < to - 1; i += 1) {
-      estimates[i] = Math.round(estimates[i] * scale);
-      assigned += estimates[i];
-    }
-    estimates[to - 1] = measured - assigned;
+function lastAnchor(history, compactedAt) {
+  for (let i = history.length - 1; i >= 0; i -= 1) {
+    if (usableAnchor(history[i], compactedAt)) return i;
   }
-  return estimates;
+  return -1;
 }
-function estimateSystemOverhead(history) {
-  const first = firstAnchor(history, compactedAtOf(history));
-  if (first < 0) return 0;
-  const estimates = estimateMessageTokens(history);
-  let messages = 0;
-  for (let i = 0; i < first; i += 1) messages += estimates[i];
-  return Math.max(0, history[first].inputTokens - messages);
-}
-function estimateContextTokens(history) {
-  const estimates = estimateMessageTokens(history);
-  let total = estimateSystemOverhead(history);
-  for (const t of estimates) total += t;
-  return total;
-}
-function estimateRequestTokens(storedHistory, requestHistory) {
-  const overhead = estimateSystemOverhead(storedHistory);
-  const calibratedMessages = Math.max(0, estimateContextTokens(storedHistory) - overhead);
-  let storedBaseline = 0;
-  for (const m of storedHistory) storedBaseline += baselineTokens(m);
+function calibrate(history, preambleTokens) {
+  const baselines = history.map(baselineTokens);
+  let baselineTotal = 0;
+  for (const b of baselines) baselineTotal += b;
+  const compactedAt = compactedAtOf(history);
+  const first = firstAnchor(history, compactedAt);
+  const last = lastAnchor(history, compactedAt);
+  if (first < 0 || last < 0) {
+    const measured = Math.max(0, preambleTokens ?? 0);
+    return {
+      overhead: measured,
+      total: baselineTotal + measured,
+      estimates: baselines,
+      scale: 1
+    };
+  }
+  let sinceLast = 0;
+  for (let i = last; i < baselines.length; i += 1) sinceLast += baselines[i];
+  const total = history[last].inputTokens + sinceLast;
+  let beforeFirst = 0;
+  for (let i = 0; i < first; i += 1) beforeFirst += baselines[i];
+  const derived = Math.max(0, history[first].inputTokens - beforeFirst);
+  const claimed = preambleTokens ?? derived;
+  const contradicted = baselineTotal > 0 && claimed >= total;
+  const overhead = Math.min(contradicted ? derived : claimed, total);
+  const messages = Math.max(0, total - overhead);
+  if (baselineTotal <= 0) {
+    return { overhead, total, estimates: baselines, scale: 1 };
+  }
+  const scale = messages / baselineTotal;
+  const estimates = baselines.map((b) => Math.round(b * scale));
+  let assigned = 0;
+  let heaviest = -1;
+  for (let i = 0; i < estimates.length; i += 1) {
+    assigned += estimates[i];
+    if (baselines[i] > 0 && (heaviest < 0 || baselines[i] > baselines[heaviest])) heaviest = i;
+  }
+  if (heaviest >= 0) estimates[heaviest] += messages - assigned;
+  return { overhead, total, estimates, scale };
+}
+function estimateMessageTokens(history, preambleTokens) {
+  return calibrate(history, preambleTokens).estimates;
+}
+function estimateRequestTokens(storedHistory, requestHistory, preambleTokens) {
+  const { overhead } = calibrate(storedHistory, preambleTokens);
   let requestBaseline = 0;
   for (const m of requestHistory) requestBaseline += baselineTokens(m);
-  if (storedBaseline <= 0) return overhead + requestBaseline;
-  return Math.round(overhead + calibratedMessages * (requestBaseline / storedBaseline));
+  return Math.round(overhead + requestBaseline);
 }
-function projectCompaction(history, cut, summaryTokens = COMPACTION_SUMMARY_TOKEN_ESTIMATE) {
-  const estimates = estimateMessageTokens(history);
-  const overhead = estimateSystemOverhead(history);
+function projectCompaction(history, cut, summaryTokens = COMPACTION_SUMMARY_TOKEN_ESTIMATE, preambleTokens) {
+  const { estimates, overhead, total } = calibrate(history, preambleTokens);
   let tail = 0;
   for (let i = cut; i < estimates.length; i += 1) tail += estimates[i];
-  let all = 0;
-  for (const t of estimates) all += t;
-  const tokensBefore = overhead + all;
+  const tokensBefore = total;
   const tokensAfter = overhead + summaryTokens + tail;
   return {
     cut,
@@ -4158,8 +4173,8 @@ function isSafeCompactionCut(history, i) {
   }
   return true;
 }
-function findCompactionCut(history, tailTokenBudget = DEFAULT_TAIL_TOKEN_BUDGET) {
-  const estimates = estimateMessageTokens(history);
+function findCompactionCut(history, tailTokenBudget = DEFAULT_TAIL_TOKEN_BUDGET, preambleTokens) {
+  const estimates = estimateMessageTokens(history, preambleTokens);
   let messagesTotal = 0;
   for (const t of estimates) messagesTotal += t;
   if (messagesTotal <= tailTokenBudget) return null;
@@ -4180,9 +4195,14 @@ function planCompaction(history, options = {}) {
     tailTokenBudget = DEFAULT_TAIL_TOKEN_BUDGET,
     minReclaimTokens = DEFAULT_MIN_RECLAIM_TOKENS
   } = options;
-  const cut = findCompactionCut(history, tailTokenBudget);
+  const cut = findCompactionCut(history, tailTokenBudget, options.preambleTokens);
   if (cut == null) return null;
-  const projection = projectCompaction(history, cut);
+  const projection = projectCompaction(
+    history,
+    cut,
+    COMPACTION_SUMMARY_TOKEN_ESTIMATE,
+    options.preambleTokens
+  );
   return projection.reclaimed >= minReclaimTokens ? projection : null;
 }
 function renderMessageForSummary(m) {
@@ -5146,7 +5166,7 @@ var ChatDriver = class _ChatDriver extends EventTarget {
         attachments: pendingInput.attachments
       }
     ] : requestHistory;
-    const estimated = estimateRequestTokens(this.history, request);
+    const estimated = estimateRequestTokens(this.history, request, this.lastPreambleTokens);
     if (estimated < threshold) return void 0;
     logger2.error(
       `ChatDriver: ending the turn \u2014 the request would fill the context window (~${estimated} of ${limit})`
@@ -5334,6 +5354,10 @@ Output format (strict):
     this.loadHistory([summaryMessage, ...tail]);
     return summaryMessage;
   }
+  /** {@inheritDoc AiDriver.getPreambleTokens} */
+  getPreambleTokens() {
+    return this.lastPreambleTokens;
+  }
   isBusy() {
     return this.busy;
   }
@@ -6196,6 +6220,11 @@ ${tailBody}
       const attachmentsForCall = currentAttachments;
       currentInput = "";
       currentAttachments = void 0;
+      this.lastPreambleTokens = estimatePreambleTokens({
+        systemPrompt,
+        toolDefinitions: this.toolDefinitions,
+        tailContext
+      });
       const options = {
         systemPrompt,
         // Strip fold-only properties (foldEvent, foldPath) before sending to provider
@@ -6865,6 +6894,13 @@ function isSpecialist(agent) {
 function isFallback(agent) {
   return agent.fallback === true;
 }
+function normalizeContextReserve(input) {
+  if (input == null) return void 0;
+  const positive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+  if (typeof input === "number") return positive(input) ? { tokens: input } : void 0;
+  if (!positive(input.tokens)) return void 0;
+  return positive(input.warnAheadTokens) ? { tokens: input.tokens, warnAheadTokens: input.warnAheadTokens } : { tokens: input.tokens };
+}
 var UNROUTABLE_PLACEHOLDER = "{{unroutable}}";
 var UNROUTABLE_INSTRUCTION = `When the request is substantive but nothing above covers it, say so directly. Do not offer to do it yourself, and do not imply a specialist will pick it up.
 
@@ -7066,6 +7102,10 @@ var OrchestratingDriver = class extends EventTarget {
   canCompact(options) {
     return this.chatDriver.canCompact(options);
   }
+  /** {@inheritDoc AiDriver.getPreambleTokens} */
+  getPreambleTokens() {
+    return this.chatDriver.getPreambleTokens();
+  }
   /** {@inheritDoc AiDriver.getCompactionPlan} */
   getCompactionPlan(options) {
     return this.chatDriver.getCompactionPlan(options);
@@ -7187,6 +7227,32 @@ var OrchestratingDriver = class extends EventTarget {
   primeRestoredAgentState(snapshots) {
     this.restoredAgentStates = { ...snapshots };
   }
+  /**
+   * {@inheritDoc AiDriver.getContextReserve}
+   *
+   * Two cases, because routing has two modes and they need opposite answers.
+   */
+  getContextReserve() {
+    const locked = this.resolvePinnedAgent();
+    if (locked) {
+      const reserve = normalizeContextReserve(locked.contextReserve);
+      return reserve == null ? void 0 : { ...reserve, agentName: locked.name, basis: "locked" };
+    }
+    const candidates = [...this.specialists];
+    if (this.fallback) candidates.push(this.fallback);
+    if (this.activeAgent) candidates.push(this.activeAgent);
+    let winner;
+    let agentName = "";
+    for (const agent of candidates) {
+      const reserve = normalizeContextReserve(agent.contextReserve);
+      if (!reserve) continue;
+      if (!winner || reserve.tokens > winner.tokens) {
+        winner = reserve;
+        agentName = agent.name;
+      }
+    }
+    return winner ? { ...winner, agentName, basis: "reachable-max" } : void 0;
+  }
   /** {@inheritDoc AiDriver.getActiveAgent} */
   getActiveAgent() {
     return this.activeAgent;
@@ -7696,6 +7762,7 @@ function defineStatefulAgent(opts) {
     onUnresolvedTool: wrappedOnUnresolvedTool,
     resumable: wrappedResumable,
     notResumableMessage: opts.notResumableMessage,
+    contextReserve: opts.contextReserve,
     onActivate: async (ctx) => {
       state = await opts.init(ctx);
       if (opts.toolHandlers) {