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

package/dist/chat-driver.cjs

@@ -1205,6 +1205,7 @@ var SUPPORTED_GEMINI_MODEL_IDS = [
   "gemini-2.5-pro",
   "gemini-2.5-flash",
   "gemini-2.5-flash-lite",
+  "gemini-3.8-flash",
   "gemini-3.5-flash",
   "gemini-3.1-flash-lite",
   "gemini-3.1-pro-preview"
@@ -1307,6 +1308,22 @@ var GEMINI_PRICING = {
     rate: { promptPerMillion: 0.25, candidatePerMillion: 1.5 }
   },
   "gemini-3.5-flash": { kind: "flat", rate: { promptPerMillion: 1.5, candidatePerMillion: 9 } },
+  // INTRODUCTORY RATE, and the only dated entry in this file. Google publishes
+  // $0.75 / $3.75 per MTok **through 2026-12-31**, rising to $1.50 / $7.50 on 2027-01-01 —
+  // so today this model is CHEAPER than gemini-3.5-flash above and in January it is not.
+  //
+  // The listed figure is the one in force, not the one coming. That is the lesson the
+  // `claude-sonnet-5` entry records from the other direction: charging a scheduled future
+  // rate early over-billed every request by 50% for as long as nobody noticed. A rate that
+  // has not taken effect is not a price, and `GeminiPricing` deliberately has no time
+  // dimension to express one — flip these two numbers on 2027-01-01 instead.
+  //
+  // That flip is ENFORCED, not remembered: `token-cost.test.ts` carries a dated assertion that
+  // turns the build red on 2027-01-01 and names the three-line edit (these two rates, plus the
+  // now-false `< gemini-3.5-flash` comparison in that same test — both models are $1.50 input
+  // from that date). There is no ticket to lose.
+  // https://ai.google.dev/gemini-api/docs/pricing
+  "gemini-3.8-flash": { kind: "flat", rate: { promptPerMillion: 0.75, candidatePerMillion: 3.75 } },
   "gemini-3.1-pro-preview": {
     kind: "tiered",
     standard: { promptPerMillion: 2, candidatePerMillion: 12 },
@@ -2793,6 +2810,7 @@ var GEMINI_CONTEXT_LIMITS = {
   "gemini-2.5-pro": 1048576,
   "gemini-2.5-flash": 1048576,
   "gemini-2.5-flash-lite": 1048576,
+  "gemini-3.8-flash": 1048576,
   "gemini-3.5-flash": 1048576,
   "gemini-3.1-flash-lite": 1048576,
   "gemini-3.1-pro-preview": 1048576
@@ -2817,6 +2835,10 @@ var GEMINI_MODEL_WARNINGS = {
   "gemini-2.5-flash": "GeminiTransport: using gemini-2.5-flash \u2014 higher cost than flash-lite; use for harder reasoning or agent tasks.",
   "gemini-2.5-pro": "GeminiTransport: using gemini-2.5-pro \u2014 significantly higher, prompt-size-tiered cost; reserve for tasks where flash reliability is insufficient.",
   "gemini-3.5-flash": "GeminiTransport: using gemini-3.5-flash \u2014 frontier model, materially higher cost than flash-lite; use for harder reasoning or agent tasks.",
+  // Warns despite currently costing LESS than gemini-3.5-flash, because that is temporary: the
+  // rate doubles on 2027-01-01 (see GEMINI_PRICING). A caller that picks this tier on today's
+  // price and never revisits the choice gets twice the bill in January without changing a line.
+  "gemini-3.8-flash": "GeminiTransport: using gemini-3.8-flash \u2014 frontier model, materially higher cost than flash-lite. Its $0.75/$3.75 per-MTok rate is introductory and DOUBLES to $1.50/$7.50 on 2027-01-01; re-check this tier choice before then.",
   "gemini-3.1-pro-preview": "GeminiTransport: using gemini-3.1-pro-preview \u2014 PREVIEW model (no stability guarantee, may be withdrawn) with significantly higher, prompt-size-tiered cost; reserve for tasks where flash reliability is insufficient."
 };
 var GEMINI_THINKING_DISABLEABLE = [
@@ -2824,15 +2846,32 @@ var GEMINI_THINKING_DISABLEABLE = [
   "gemini-2.5-flash-lite"
 ];
 var GEMINI_MEDIA_RESOLUTION_TIERS = [
+  "gemini-3.8-flash",
   "gemini-3.5-flash",
   "gemini-3.1-flash-lite",
   "gemini-3.1-pro-preview"
 ];
-var GEMINI_THINKING_LEVEL_TIERS = [
-  "gemini-3.5-flash",
-  "gemini-3.1-flash-lite",
-  "gemini-3.1-pro-preview"
-];
+var GEMINI_LEVEL_LADDER = ["minimal", "low", "medium", "high"];
+var GEMINI_THINKING_LEVELS = {
+  "gemini-3.8-flash": ["low", "medium", "high"],
+  "gemini-3.5-flash": ["minimal", "low", "medium", "high"],
+  "gemini-3.1-flash-lite": ["minimal", "low", "medium", "high"],
+  "gemini-3.1-pro-preview": ["low", "medium", "high"]
+};
+function clampThinkingLevel(supported, level) {
+  if (!(supported === null || supported === void 0 ? void 0 : supported.length) || supported.includes(level)) {
+    return level;
+  }
+  const target = GEMINI_LEVEL_LADDER.indexOf(level);
+  const distance = (candidate) => Math.abs(GEMINI_LEVEL_LADDER.indexOf(candidate) - target);
+  let best = supported[0];
+  for (const candidate of supported) {
+    if (distance(candidate) <= distance(best)) {
+      best = candidate;
+    }
+  }
+  return best;
+}
 var GEMINI_THINKING_LEVEL = {
   minimal: "minimal",
   low: "low",
@@ -2840,25 +2879,16 @@ var GEMINI_THINKING_LEVEL = {
   high: "high",
   max: "high"
 };
-var GEMINI_COARSE_LEVEL_TIERS = [
-  "gemini-3.5-flash",
-  "gemini-3.1-flash-lite",
-  "gemini-3.1-pro-preview"
-];
-var GEMINI_COARSE_LEVEL = {
-  minimal: "low",
-  low: "low",
-  medium: "high",
-  high: "high"
-};
 var isGradedLevel = (p) => p !== void 0 && p !== "auto" && p !== "off";
 function geminiThinkingConfig(model, policy) {
-  if (isGradedLevel(policy) && GEMINI_THINKING_LEVEL_TIERS.includes(model)) {
-    const level = GEMINI_THINKING_LEVEL[policy];
-    return {
-      includeThoughts: true,
-      thinkingLevel: GEMINI_COARSE_LEVEL_TIERS.includes(model) ? GEMINI_COARSE_LEVEL[level] : level
-    };
+  if (isGradedLevel(policy)) {
+    const accepted = GEMINI_THINKING_LEVELS[model];
+    if (accepted) {
+      return {
+        includeThoughts: true,
+        thinkingLevel: clampThinkingLevel(accepted, GEMINI_THINKING_LEVEL[policy])
+      };
+    }
   }
   if (policy === "off" && GEMINI_THINKING_DISABLEABLE.includes(model)) {
     return { includeThoughts: false, thinkingBudget: 0 };
@@ -2899,7 +2929,7 @@ var GeminiTransport = class _GeminiTransport {
   /**
    * Warn once when a requested policy cannot be honoured on this model — a *cost* decision the
    * caller made that the wire silently reversed, so they hear about it, but only once, not per
-   * turn. Two shapes reach here (the Anthropic twin warns on the same two):
+   * turn. Three shapes reach here (the Anthropic twin warns on the first two):
    *
    * - `'off'` on a tier that can't disable thinking — only the flash tiers accept a zero thinking
    *   budget; everything else keeps paying for reasoning it was told to stop. (`'auto'` is NOT this
@@ -2909,6 +2939,12 @@ var GeminiTransport = class _GeminiTransport {
    *   not the Gemini 3 `thinkingLevel` enum, so the level is dropped and the turn runs at the
    *   default posture. Without this, a caller asking for `high` on `gemini-2.5-pro` and quietly
    *   getting the default is left to wonder why.
+   * - A graded depth whose DIALECT a Gemini 3 tier speaks but whose particular value it does not
+   *   accept — `minimal` on `gemini-3.8-flash` or `gemini-3.1-pro-preview`, the two tiers that
+   *   reject it outright. Nothing is dropped here; `clampThinkingLevel` MOVES the level onto the
+   *   nearest one the tier takes, and since ties resolve upward the move is usually to something
+   *   DEARER than the caller chose. A cost decision reversed on the wire in the expensive
+   *   direction is exactly what this warning exists for — without it the only trace is the bill.
    */
   warnIfThinkingUnclampable(policy) {
     if (this.warnedThinkingClamped) {
@@ -2919,9 +2955,19 @@ var GeminiTransport = class _GeminiTransport {
       logger.warn(`GeminiTransport: thinkingPolicy 'off' ignored \u2014 ${this.model} runs its default thinking posture and takes no budget we can safely set. Reasoning tokens are still billed at the candidate rate; use a flash tier if you need them gone.`);
       return;
     }
-    if (isGradedLevel(policy) && !GEMINI_THINKING_LEVEL_TIERS.includes(this.model)) {
-      this.warnedThinkingClamped = true;
-      logger.warn(`GeminiTransport: thinkingPolicy '${policy}' ignored \u2014 ${this.model} takes a numeric thinking budget, not the graded 'thinkingLevel' the Gemini 3 tiers use, so this turn runs at its default reasoning posture. Use a Gemini 3 tier to set reasoning depth.`);
+    if (isGradedLevel(policy)) {
+      const accepted = GEMINI_THINKING_LEVELS[this.model];
+      if (!accepted) {
+        this.warnedThinkingClamped = true;
+        logger.warn(`GeminiTransport: thinkingPolicy '${policy}' ignored \u2014 ${this.model} takes a numeric thinking budget, not the graded 'thinkingLevel' the Gemini 3 tiers use, so this turn runs at its default reasoning posture. Use a Gemini 3 tier to set reasoning depth.`);
+        return;
+      }
+      const requested = GEMINI_THINKING_LEVEL[policy];
+      const sent = clampThinkingLevel(accepted, requested);
+      if (sent !== requested) {
+        this.warnedThinkingClamped = true;
+        logger.warn(`GeminiTransport: thinkingPolicy '${policy}' sent as thinkingLevel '${sent}' \u2014 ${this.model} does not accept '${requested}' (it takes ${accepted.join("/")}). Reasoning bills at the candidate rate, so an upward clamp costs more than you asked for.`);
+      }
     }
   }
   constructor(config = {}) {
@@ -3812,6 +3858,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;
@@ -3856,66 +3917,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,
@@ -4183,8 +4244,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;
@@ -4205,9 +4266,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) {
@@ -5171,7 +5237,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})`
@@ -5359,6 +5425,10 @@ Output format (strict):
     this.loadHistory([summaryMessage, ...tail]);
     return summaryMessage;
   }
+  /** {@inheritDoc AiDriver.getPreambleTokens} */
+  getPreambleTokens() {
+    return this.lastPreambleTokens;
+  }
   isBusy() {
     return this.busy;
   }
@@ -6221,6 +6291,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
@@ -6890,6 +6965,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.
 
@@ -7091,6 +7173,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);
@@ -7212,6 +7298,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;
@@ -7721,6 +7833,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) {