@genesislcap/ai-assistant 15.10.4 → 15.10.6-GENC-1480.6

package/dist/ai-assistant.api.json

@@ -5256,6 +5256,73 @@
               "isAbstract": false,
               "name": "markAsSubAgent"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/ai-assistant!ChatDriver#reportBudgetExhausted:member(1)",
+              "docComment": "",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "reportBudgetExhausted(e: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "BudgetExhaustedError",
+                  "canonicalReference": "@genesislcap/foundation-ai!BudgetExhaustedError:class"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", pendingUserMessage?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatMessage",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatMessage:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatDriverResult",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatDriverResult:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 5,
+                "endIndex": 6
+              },
+              "releaseTag": "Beta",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "e",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "pendingUserMessage",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 3,
+                    "endIndex": 4
+                  },
+                  "isOptional": true
+                }
+              ],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "reportBudgetExhausted"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/ai-assistant!ChatDriver#requestInteraction:member(1)",
@@ -5692,7 +5759,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@genesislcap/ai-assistant!ChatDriverConfig#budgetExhaustedMessage:member",
-              "docComment": "/**\n * Transcript copy appended when the AI-spend budget wall is hit (GENC-1464). Defaults to `DEFAULT_BUDGET_EXHAUSTED_MESSAGE`.\n *\n * The assistant element already lets a host override the blocked **banner** via `setBlocked(true, reason)`; without this the transcript **bubble** stayed on the default, so a white-labelled host got its own copy in the banner and the shipped default directly below it. Passing the same effective copy here keeps the two surfaces saying one thing.\n *\n * Deliberately a driver-config field rather than something read off a chat config: `ChatDriver` has no `chatConfig` and is used standalone (see `chat-driver-node`), so threading one in would be a much larger and less reversible change.\n */\n",
+              "docComment": "/**\n * Transcript copy appended when the AI-spend budget wall is hit (GENC-1464), used VERBATIM — set it only to own the copy entirely (white-labelling). When unset, the driver composes the bubble per wall: the neutral `DEFAULT_BUDGET_EXHAUSTED_MESSAGE`, upgraded with \"switch to another AI provider\" advice only when the 402's `otherVendorAvailable` positively says another metered vendor still has headroom — the same rule the blocked banner applies, so the two surfaces can no longer contradict each other.\n *\n * The assistant element already lets a host override the blocked **banner** via `setBlocked(true, reason)`; without this the transcript **bubble** stayed on the default, so a white-labelled host got its own copy in the banner and the shipped default directly below it. Passing the same effective copy here keeps the two surfaces saying one thing.\n *\n * Deliberately a driver-config field rather than something read off a chat config: `ChatDriver` has no `chatConfig` and is used standalone (see `chat-driver-node`), so threading one in would be a much larger and less reversible change.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -17701,6 +17768,74 @@
                 "endIndex": 6
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@genesislcap/ai-assistant!StatefulAgentInit#thinkingPolicy:member",
+              "docComment": "/**\n * Extended-thinking posture. Either a static `ChatThinkingPolicy` or a function resolved each tool-loop iteration with the current `state` — the function form is the point of this option on a machine agent: `'auto'` in the state that makes a real decision, `'off'` in the states that only step a known sequence, where reasoning is billed at the full output rate to re-derive what the machine already knows. Omit, or return `undefined` from the function, to keep the model's own default for that turn.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "thinkingPolicy?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatThinkingPolicy",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatThinkingPolicy:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": " | ((ctx: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "StatefulAgentContext",
+                  "canonicalReference": "@genesislcap/ai-assistant!StatefulAgentContext:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<S>) => "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatThinkingPolicy",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatThinkingPolicy:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": " | undefined | "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Promise",
+                  "canonicalReference": "!Promise:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatThinkingPolicy",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatThinkingPolicy:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": " | undefined>)"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Beta",
+              "name": "thinkingPolicy",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 11
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@genesislcap/ai-assistant!StatefulAgentInit#toolChoice:member",
@@ -18342,6 +18477,73 @@
             "endIndex": 6
           }
         },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@genesislcap/ai-assistant!ThinkingPolicyInput:type",
+          "docComment": "/**\n * Extended-thinking posture for an agent — whether the model reasons before answering. Either a static `ChatThinkingPolicy` (resolved once) or a function resolved each tool-loop iteration — pick the function form to vary it by current state, which is where the cost lives: `'auto'` on the planning turn, `'off'` on the mechanical ones that only need to pick the next tool. On a thinking model those turns bill reasoning at the full output rate to decide something the state machine already determined.\n *\n * **Omit — or return `undefined` from the function — to keep the model's own default**, which is a distinct third state rather than a synonym for either value: Sonnet 5 and Fable 5 think by default, the rest do not. So an agent that leaves this unset, or a resolver that answers `undefined` on some turns, behaves and prices exactly as it did before this option existed.\n *\n * A request, not a guarantee — transports clamp what a model cannot honour (Fable 5 and Gemini 2.5 Pro always think) and warn once instead of failing the turn. Resolved and applied the same way as {@link TemperatureInput}. See `ChatThinkingPolicy`.\n *\n * @beta\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type ThinkingPolicyInput = "
+            },
+            {
+              "kind": "Reference",
+              "text": "ChatThinkingPolicy",
+              "canonicalReference": "@genesislcap/foundation-ai!ChatThinkingPolicy:type"
+            },
+            {
+              "kind": "Content",
+              "text": " | ((ctx: "
+            },
+            {
+              "kind": "Reference",
+              "text": "SystemPromptContext",
+              "canonicalReference": "@genesislcap/ai-assistant!SystemPromptContext:interface"
+            },
+            {
+              "kind": "Content",
+              "text": ") => "
+            },
+            {
+              "kind": "Reference",
+              "text": "ChatThinkingPolicy",
+              "canonicalReference": "@genesislcap/foundation-ai!ChatThinkingPolicy:type"
+            },
+            {
+              "kind": "Content",
+              "text": " | undefined | "
+            },
+            {
+              "kind": "Reference",
+              "text": "Promise",
+              "canonicalReference": "!Promise:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<"
+            },
+            {
+              "kind": "Reference",
+              "text": "ChatThinkingPolicy",
+              "canonicalReference": "@genesislcap/foundation-ai!ChatThinkingPolicy:type"
+            },
+            {
+              "kind": "Content",
+              "text": " | undefined>)"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/config/config.ts",
+          "releaseTag": "Beta",
+          "name": "ThinkingPolicyInput",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 11
+          }
+        },
         {
           "kind": "TypeAlias",
           "canonicalReference": "@genesislcap/ai-assistant!TimelineMessage:type",

package/dist/ai-assistant.d.ts

@@ -11,6 +11,7 @@ import type { ChatDriverResult } from '@genesislcap/foundation-ai';
 import type { ChatFallback } from '@genesislcap/foundation-ai';
 import type { ChatInputDuringExecutionMode } from '@genesislcap/foundation-ai';
 import type { ChatMessage } from '@genesislcap/foundation-ai';
+import type { ChatThinkingPolicy } from '@genesislcap/foundation-ai';
 import type { ChatToolChoice } from '@genesislcap/foundation-ai';
 import type { ChatToolDefinition } from '@genesislcap/foundation-ai';
 import type { ChatToolHandlers } from '@genesislcap/foundation-ai';
@@ -969,6 +970,17 @@ declare interface BaseAgentConfig {
      * @beta
      */
     cachePolicy?: CachePolicyInput;
+    /**
+     * Extended-thinking posture for this agent — whether the model reasons before answering. Either
+     * a static value or a function resolved each tool-loop iteration (vary by state: `'auto'` where
+     * the turn is a genuine decision, `'off'` on the mechanical ones, where reasoning is billed at
+     * the full output rate for no benefit). Omit — or return `undefined` — to keep the model's own
+     * default, which is neither `'auto'` nor `'off'` uniformly. Provider-neutral; transports clamp
+     * models that cannot honour it. See {@link ThinkingPolicyInput}.
+     *
+     * @beta
+     */
+    thinkingPolicy?: ThinkingPolicyInput;
     /**
      * Volatile per-turn context injected at the tail of every model-call (after the history and any
      * cache breakpoint), so it is seen each turn without busting the cached prefix — the place to put
@@ -1425,6 +1437,12 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      * `undefined` requests no caching (equivalent to `{ scope: 'default' }`).
      */
     private activeCachePolicyInput?;
+    /**
+     * Active agent's extended-thinking selector (static value or per-turn resolver). `undefined` —
+     * unset, or returned by the resolver — leaves the model on its own default posture, which is
+     * neither uniformly on nor off, so an agent that never sets this is unaffected by the option.
+     */
+    private activeThinkingPolicyInput?;
     /**
      * Active agent's tail-context selector (static value or per-turn resolver). The driver frames
      * the resolved string in a `<system-reminder>` marker and injects it at the message tail.
@@ -1492,8 +1510,12 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
     private readonly sessionKey;
     /** Injected activity bus; defaults to a no-op off-browser (Node/tests/headless). */
     private readonly activityBus;
-    /** Transcript copy for a budget wall — see `ChatDriverConfig.budgetExhaustedMessage`. */
-    private readonly budgetExhaustedMessage;
+    /**
+     * Host override for the budget-wall transcript copy, used verbatim — see
+     * `ChatDriverConfig.budgetExhaustedMessage`. `undefined` means no override,
+     * and the bubble is composed per wall by {@link ChatDriver.budgetExhaustedBubble}.
+     */
+    private readonly budgetExhaustedMessageOverride?;
     /**
      * Set the moment a budget wall is observed anywhere in this turn — this
      * driver's own 402, or a sub-agent's (which surfaces here only as a
@@ -1597,6 +1619,7 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      *
      * @internal
      */
+    private budgetExhaustedBubble;
     reportBudgetExhausted(e: BudgetExhaustedError, pendingUserMessage?: ChatMessage): ChatDriverResult;
     /** The typed failure reason on a loop result, or `undefined` for a clean turn / handoff. */
     private static failureReasonOf;
@@ -1821,9 +1844,20 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      *   `condenseWhen` can register against the right call (it stamps the clocks
      *   straight off the driver). Absent for dispatch paths with no addressable tool
      *   call (e.g. the fold-close handler), where `condenseWhen` is a no-op.
-     * @param traceCapture - Optional per-invocation slot. When provided, the trace
-     *   from any sub-agent call is written here rather than to shared instance state,
-     *   so parallel tool calls each capture their own trace independently.
+     * @param traceCapture - Optional per-tool-call accumulator. When provided, every
+     *   sub-agent call's trace is **appended** here rather than written to shared
+     *   instance state, so parallel tool calls each capture their own traces
+     *   independently.
+     *
+     *   Deliberately a list of traces, not one slot. A single handler may call
+     *   `requestSubAgent` more than once — a code-driven scheduler dispatching a
+     *   dependency graph, a retry of a timed-out child, any fan-out helper — and a
+     *   single slot kept only the last, so every other child ran, was billed by the
+     *   provider, and then vanished from history. The loss was silent in the worst
+     *   way: `sumUsage` and `usageRows` both recurse into the trace, so they summed a
+     *   truncated input and still agreed with each other. Measured at 1 of 7 traces
+     *   kept on a seven-way fan-out, reporting ~2.3x under the real cost, with the
+     *   error growing as the fan-out widens.
      */
     private buildHandlerContext;
     /**
@@ -1914,8 +1948,13 @@ export declare interface ChatDriverConfig {
      */
     activityBus?: ActivityBus;
     /**
-     * Transcript copy appended when the AI-spend budget wall is hit (GENC-1464).
-     * Defaults to `DEFAULT_BUDGET_EXHAUSTED_MESSAGE`.
+     * Transcript copy appended when the AI-spend budget wall is hit (GENC-1464),
+     * used VERBATIM — set it only to own the copy entirely (white-labelling).
+     * When unset, the driver composes the bubble per wall: the neutral
+     * `DEFAULT_BUDGET_EXHAUSTED_MESSAGE`, upgraded with "switch to another AI
+     * provider" advice only when the 402's `otherVendorAvailable` positively says
+     * another metered vendor still has headroom — the same rule the blocked
+     * banner applies, so the two surfaces can no longer contradict each other.
      *
      * The assistant element already lets a host override the blocked **banner**
      * via `setBlocked(true, reason)`; without this the transcript **bubble** stayed
@@ -1958,6 +1997,8 @@ declare type ChatInteractionEventsMap = {
     };
 };
 
+export { ChatThinkingPolicy }
+
 export { ChatToolChoice }
 
 /**
@@ -2859,24 +2900,26 @@ export declare class FoundationAiAssistant extends GenesisElement {
      */
     get effectiveBlockedReason(): string;
     /**
-     * Copy the driver writes into the TRANSCRIPT when a turn hits the budget wall.
-     *
-     * A host-set `blockedReason` still wins, so a white-labelled host does not read
-     * its own explanation in the banner and the shipped default directly below it —
-     * that is the whole reason the driver takes this at all.
-     *
-     * What it deliberately is NOT is
-     * {@link FoundationAiAssistant.effectiveBlockedReason}. That getter
-     * composes advice — `"…Switch to Gemini to keep going."` — which is true only
-     * while that vendor has headroom, and the transcript is a permanent record. The
-     * driver reads this once at CONSTRUCTION, and `getOrCreateDriver` keys on the
-     * agents list, so an agents swap *after* a wall re-runs `createDriver` and would
-     * freeze that sentence into every later turn's bubble. Reading the latch's own
-     * copy instead is structurally incapable of carrying the advice: the only
-     * writer of `blockedReason` is the vendor-agnostic branch of
-     * `latchBlockedFrom`, whose `formatBlockedReason(budget)` form has no switch
-     * clause. Per-vendor copy lives in `blockedVendorReasons` and reaches the
-     * banner alone.
+     * Copy the driver writes into the TRANSCRIPT when a turn hits the budget wall,
+     * or `undefined` to let the driver compose it per wall.
+     *
+     * A set `blockedReason` still wins — a white-labelled host must not read its
+     * own explanation in the banner and shipped copy directly below it, and the
+     * vendor-agnostic latch's `formatBlockedReason(budget)` form stays advice-free
+     * exactly as before.
+     *
+     * `undefined` (the usual case) is NOT the old `DEFAULT_BUDGET_EXHAUSTED_MESSAGE`
+     * fallback: it hands composition to the driver, which builds the bubble from
+     * EACH wall's own 402 — naming the exhausted vendor and advising a switch only
+     * when that refusal's `otherVendorAvailable` positively vouched for headroom
+     * elsewhere. That is immune to the staleness this getter used to guard against
+     * by freezing the copy: construction-time advice could outlive its truth
+     * (`getOrCreateDriver` re-runs on an agents swap and would have baked the
+     * sentence into every later bubble), but per-wall advice is derived from the
+     * refusal it annotates and dies with the turn. Forcing the default here was
+     * also what made the driver's composed bubble unreachable in every real
+     * mount — the banner advised switching while the bubble under it never did
+     * (the GENC-1464 tester finding, root cause).
      */
     private get transcriptBudgetExhaustedMessage();
     /**
@@ -4677,6 +4720,15 @@ export declare interface StatefulAgentInit<S> {
      * request no caching.
      */
     cachePolicy?: CachePolicy | ((ctx: StatefulAgentContext<S>) => CachePolicy | Promise<CachePolicy>);
+    /**
+     * Extended-thinking posture. Either a static `ChatThinkingPolicy` or a function resolved each
+     * tool-loop iteration with the current `state` — the function form is the point of this option
+     * on a machine agent: `'auto'` in the state that makes a real decision, `'off'` in the states
+     * that only step a known sequence, where reasoning is billed at the full output rate to
+     * re-derive what the machine already knows. Omit, or return `undefined` from the function, to
+     * keep the model's own default for that turn.
+     */
+    thinkingPolicy?: ChatThinkingPolicy | ((ctx: StatefulAgentContext<S>) => ChatThinkingPolicy | undefined | Promise<ChatThinkingPolicy | undefined>);
     /**
      * Volatile per-turn tail context (current file/spec, diagnostics, live state). Either a static
      * string or a function resolved each tool-loop iteration with the current `state`. Provide raw
@@ -4839,6 +4891,27 @@ export declare type TailContextInput = string | ((ctx: SystemPromptContext) => s
  */
 export declare type TemperatureInput = number | ((ctx: SystemPromptContext) => number | Promise<number>);
 
+/**
+ * Extended-thinking posture for an agent — whether the model reasons before answering. Either a
+ * static `ChatThinkingPolicy` (resolved once) or a function resolved each tool-loop iteration —
+ * pick the function form to vary it by current state, which is where the cost lives: `'auto'` on
+ * the planning turn, `'off'` on the mechanical ones that only need to pick the next tool. On a
+ * thinking model those turns bill reasoning at the full output rate to decide something the
+ * state machine already determined.
+ *
+ * **Omit — or return `undefined` from the function — to keep the model's own default**, which is
+ * a distinct third state rather than a synonym for either value: Sonnet 5 and Fable 5 think by
+ * default, the rest do not. So an agent that leaves this unset, or a resolver that answers
+ * `undefined` on some turns, behaves and prices exactly as it did before this option existed.
+ *
+ * A request, not a guarantee — transports clamp what a model cannot honour (Fable 5 and Gemini
+ * 2.5 Pro always think) and warn once instead of failing the turn. Resolved and applied the same
+ * way as {@link TemperatureInput}. See `ChatThinkingPolicy`.
+ *
+ * @beta
+ */
+export declare type ThinkingPolicyInput = ChatThinkingPolicy | ((ctx: SystemPromptContext) => ChatThinkingPolicy | undefined | Promise<ChatThinkingPolicy | undefined>);
+
 /**
  * A chat message lifted into the debug-log timeline as a `kind: 'message'` entry.
  *