@genesislcap/ai-assistant 15.15.2 → 15.16.0

package/dist/ai-assistant.api.json

@@ -2270,7 +2270,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@genesislcap/ai-assistant!AiChatWidget:interface",
-          "docComment": "/**\n * Interface that AI inline interaction components implement. The `AiChatInteractionWrapper` sets `interactionId` and `interaction` on the rendered element on every (re)mount, and replaces `interaction` (pending → resolved) when the interaction completes.\n *\n * @remarks\n *\n * GENC-1390 replaced the previous flat `data` / `resolved` / `shouldAutoFocus` surface with the discriminated {@link AiChatInteraction}. This is a breaking change on this `@beta` interface — widgets read `this.interaction` (narrowing on `status`) instead of the removed flat fields.\n *\n * @beta\n */\n",
+          "docComment": "/**\n * Interface that AI inline interaction components implement. The `AiChatInteractionWrapper` sets `interactionId` and `interaction` on the rendered element on every (re)mount, and replaces `interaction` (pending → resolved) when the interaction completes.\n *\n * @remarks\n *\n * A widget talks back by dispatching two events, both caught by the wrapper: `interaction-completed` resolves the interaction (once — a second is ignored), and `interaction-cost` reports a positive USD delta for paid work done AFTER resolving, which repeated calls sum. The second exists for widgets that resolve early so the assistant stops waiting, then keep working for the user; without it that spend is billed but missing from the total the user sees.\n *\n * @beta\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -3205,6 +3205,67 @@
               ],
               "name": "primeRestoredAgentState"
             },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@genesislcap/ai-assistant!AiDriver#recordExternalCost:member(1)",
+              "docComment": "/**\n * Record external spend against an interaction that has ALREADY resolved.\n *\n * For widgets that resolve early — so the assistant stops waiting — and then keep doing paid work on the user's behalf. Reports a positive DELTA; repeated calls sum. Returns false when the spend was NOT recorded — the value was not a positive finite amount, or the message is no longer in history.\n *\n * @beta\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "recordExternalCost?(interactionId: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", costUsd: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "number"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": true,
+              "returnTypeTokenRange": {
+                "startIndex": 5,
+                "endIndex": 6
+              },
+              "releaseTag": "Beta",
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "interactionId",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "costUsd",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 3,
+                    "endIndex": 4
+                  },
+                  "isOptional": false
+                }
+              ],
+              "name": "recordExternalCost"
+            },
             {
               "kind": "MethodSignature",
               "canonicalReference": "@genesislcap/ai-assistant!AiDriver#resolveInteraction:member(1)",
@@ -4294,7 +4355,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@genesislcap/ai-assistant!ChatDriver:class",
-          "docComment": "/**\n * Plain TS class that drives a multi-turn chat conversation, including the tool-call loop. Owned by `FoundationAiAssistant` — created in `connectedCallback`, torn down in `disconnectedCallback`.\n *\n * Dispatches `'history-updated'` events on itself so the owning element can observe changes.\n *\n * @fires\n *\n * history-updated - Fired whenever the in-memory chat history changes (append, tool loop, interaction resolution) with the full history snapshot. detail: `ReadonlyArray<ChatMessage>`\n *\n * @beta\n */\n",
+          "docComment": "/**\n * Plain TS class that drives a multi-turn chat conversation, including the tool-call loop. Owned by `FoundationAiAssistant` — created in `connectedCallback`, torn down in `disconnectedCallback`.\n *\n * Dispatches `'history-updated'` events on itself so the owning element can observe changes.\n *\n * @fires\n *\n * history-updated - Fired whenever the in-memory chat history changes (append, tool loop, interaction resolution, post-resolve external cost) with the full history snapshot. detail: `ReadonlyArray<ChatMessage>`\n *\n * @beta\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -5265,6 +5326,70 @@
               "isAbstract": false,
               "name": "markAsSubAgent"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/ai-assistant!ChatDriver#recordExternalCost:member(1)",
+              "docComment": "/**\n * Add external (non-LLM) spend to an interaction's message AFTER it has resolved.\n *\n * **Why this exists separately from `resolveInteraction`.** A widget's spend reaches the session total only through `InteractionResult.costUsd`, which is read exactly once — `resolveInteraction` does its whole job inside `if (interaction)` and then deletes the entry from `pendingInteractions`. That is correct for the resolution itself, but it assumes a widget stops costing money when it resolves, and several deliberately do not: a widget that resolves EARLY so the assistant stops waiting (options shown, a preview rendered) may stay interactive for minutes afterwards and do more paid work on the user's behalf. Re-emitting `interaction-completed` does not help — with the interaction gone from the map the call is a silent no-op — so that spend had nowhere to go and was simply missing from the figure shown to the user.\n *\n * Additive by design: the caller reports a DELTA, not a running total, so repeated calls sum. It touches only `externalCostUsd`; the recorded `interaction.resolved` payload is left exactly as the resolution wrote it, because this is not a second resolution and must not read like one.\n *\n * Deliberately does NOT require the interaction to be pending, does not resurrect it, and has no loading/turn side effects — this is bookkeeping about a turn that already happened.\n *\n * @param interactionId - the interaction whose message owns the spend.\n *\n * @param costUsd - a positive delta in USD. Non-finite, zero and negative values are ignored.\n *\n * @returns `true` when the spend was recorded; `false` when it was not — either the value was not a positive finite amount, or the message is no longer in history (trimmed or condensed away). A real outcome a caller may want to log rather than a failure to throw on; every `false` also records an `interaction.external-cost-dropped` meta event here, so money can never disappear without a trace.\n *\n * @beta\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "recordExternalCost(interactionId: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", costUsd: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "number"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 5,
+                "endIndex": 6
+              },
+              "releaseTag": "Beta",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "interactionId",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "costUsd",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 3,
+                    "endIndex": 4
+                  },
+                  "isOptional": false
+                }
+              ],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "recordExternalCost"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/ai-assistant!ChatDriver#reportBudgetExhausted:member(1)",
@@ -9077,6 +9202,55 @@
               "isAbstract": false,
               "name": "handleInteractionCompleted"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/ai-assistant!FoundationAiAssistant#handleInteractionCost:member(1)",
+              "docComment": "/**\n * A widget reporting spend it incurred AFTER resolving.\n *\n * Note what this deliberately does NOT do: no `startLoadingTimer()`. This is bookkeeping about a turn that already finished, so it must be invisible — showing a spinner would tell the user the assistant is working when nothing is pending.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "handleInteractionCost(e: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Event",
+                  "canonicalReference": "!Event:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "void"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "releaseTag": "Beta",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "e",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                }
+              ],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "handleInteractionCost"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/ai-assistant!FoundationAiAssistant#handlePopout:member(1)",
@@ -14280,6 +14454,37 @@
           ],
           "extendsTokenRanges": []
         },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@genesislcap/ai-assistant!InteractionCostEventDetail:type",
+          "docComment": "/**\n * Detail payload for the `interaction-cost` event — a POSITIVE DELTA in USD, not a running total.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type InteractionCostEventDetail = "
+            },
+            {
+              "kind": "Reference",
+              "text": "ChatInteractionEventsMap",
+              "canonicalReference": "@genesislcap/ai-assistant!~ChatInteractionEventsMap:type"
+            },
+            {
+              "kind": "Content",
+              "text": "['interaction-cost']"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/components/chat-interaction-wrapper/chat-interaction-wrapper.ts",
+          "releaseTag": "Public",
+          "name": "InteractionCostEventDetail",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 3
+          }
+        },
         {
           "kind": "Function",
           "canonicalReference": "@genesislcap/ai-assistant!isAiAssistantDocked:function(1)",
@@ -15256,6 +15461,70 @@
               "isAbstract": false,
               "name": "primeRestoredAgentState"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/ai-assistant!OrchestratingDriver#recordExternalCost:member(1)",
+              "docComment": "/**\n * Delegated for the same reason as `resolveInteraction`: the history that owns the interaction — and therefore the cost — lives on the wrapped driver, not here.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "recordExternalCost(interactionId: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", costUsd: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "number"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 5,
+                "endIndex": 6
+              },
+              "releaseTag": "Beta",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "interactionId",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "costUsd",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 3,
+                    "endIndex": 4
+                  },
+                  "isOptional": false
+                }
+              ],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "recordExternalCost"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/ai-assistant!OrchestratingDriver#resolveInteraction:member(1)",

package/dist/ai-assistant.d.ts

@@ -532,6 +532,14 @@ export declare class AiChatMarkdown extends GenesisElement {
  * change on this `@beta` interface — widgets read `this.interaction` (narrowing on
  * `status`) instead of the removed flat fields.
  *
+ * @remarks
+ * A widget talks back by dispatching two events, both caught by the wrapper:
+ * `interaction-completed` resolves the interaction (once — a second is ignored), and
+ * `interaction-cost` reports a positive USD delta for paid work done AFTER resolving,
+ * which repeated calls sum. The second exists for widgets that resolve early so the
+ * assistant stops waiting, then keep working for the user; without it that spend is
+ * billed but missing from the total the user sees.
+ *
  * @beta
  */
 export declare interface AiChatWidget<TData = unknown, TResult = unknown> {
@@ -597,6 +605,17 @@ export declare interface AiDriver extends EventTarget {
      * Resolve a pending blocking interaction with the given result.
      */
     resolveInteraction(interactionId: string, result: unknown): void;
+    /**
+     * Record external spend against an interaction that has ALREADY resolved.
+     *
+     * For widgets that resolve early — so the assistant stops waiting — and then keep doing paid work
+     * on the user's behalf. Reports a positive DELTA; repeated calls sum. Returns false when the
+     * spend was NOT recorded — the value was not a positive finite amount, or the message is no
+     * longer in history.
+     *
+     * @beta
+     */
+    recordExternalCost?(interactionId: string, costUsd: number): boolean;
     /**
      * The live {@link InteractionContext} for a pending interaction (GENC-1390), or
      * `undefined` if the interaction is resolved/evicted or the driver owns no
@@ -1196,7 +1215,7 @@ export declare type CachePolicyInput = CachePolicy | ((ctx: SystemPromptContext)
  *
  * Dispatches `'history-updated'` events on itself so the owning element can observe changes.
  *
- * @fires history-updated - Fired whenever the in-memory chat history changes (append, tool loop, interaction resolution) with the full history snapshot. detail: `ReadonlyArray<ChatMessage>`
+ * @fires history-updated - Fired whenever the in-memory chat history changes (append, tool loop, interaction resolution, post-resolve external cost) with the full history snapshot. detail: `ReadonlyArray<ChatMessage>`
  *
  * @beta
  */
@@ -1858,6 +1877,36 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      *   bubble and/or shows the "Assistant" label.
      */
     requestInteraction<T>(componentName: string, data: any, options?: InteractionRequestOptions): Promise<T>;
+    /**
+     * Add external (non-LLM) spend to an interaction's message AFTER it has resolved.
+     *
+     * **Why this exists separately from `resolveInteraction`.** A widget's spend reaches the session
+     * total only through `InteractionResult.costUsd`, which is read exactly once — `resolveInteraction`
+     * does its whole job inside `if (interaction)` and then deletes the entry from
+     * `pendingInteractions`. That is correct for the resolution itself, but it assumes a widget stops
+     * costing money when it resolves, and several deliberately do not: a widget that resolves EARLY so
+     * the assistant stops waiting (options shown, a preview rendered) may stay interactive for minutes
+     * afterwards and do more paid work on the user's behalf. Re-emitting `interaction-completed` does
+     * not help — with the interaction gone from the map the call is a silent no-op — so that spend had
+     * nowhere to go and was simply missing from the figure shown to the user.
+     *
+     * Additive by design: the caller reports a DELTA, not a running total, so repeated calls sum. It
+     * touches only `externalCostUsd`; the recorded `interaction.resolved` payload is left exactly as
+     * the resolution wrote it, because this is not a second resolution and must not read like one.
+     *
+     * Deliberately does NOT require the interaction to be pending, does not resurrect it, and has no
+     * loading/turn side effects — this is bookkeeping about a turn that already happened.
+     *
+     * @param interactionId the interaction whose message owns the spend.
+     * @param costUsd a positive delta in USD. Non-finite, zero and negative values are ignored.
+     * @returns `true` when the spend was recorded; `false` when it was not — either the value was
+     *   not a positive finite amount, or the message is no longer in history (trimmed or condensed
+     *   away). A real outcome a caller may want to log rather than a failure to throw on; every
+     *   `false` also records an `interaction.external-cost-dropped` meta event here, so money can
+     *   never disappear without a trace.
+     * @beta
+     */
+    recordExternalCost(interactionId: string, costUsd: number): boolean;
     /**
      * Resolve a pending interaction. The wrapper component calls this on completion.
      * Marks the interaction message as resolved so it renders read-only on re-render.
@@ -2057,6 +2106,10 @@ declare type ChatInteractionEventsMap = {
     'interaction-completed': InteractionResult<unknown> & {
         interactionId: string;
     };
+    'interaction-cost': {
+        interactionId: string;
+        costUsd: number;
+    };
 };
 
 export { ChatThinkingPolicy }
@@ -3637,6 +3690,22 @@ export declare class FoundationAiAssistant extends GenesisElement {
     persistenceChanged(oldValue: SessionPersistenceConfig | undefined, newValue: SessionPersistenceConfig | undefined): void;
     showingSplashChanged(): void;
     private syncShowingSplash;
+    /**
+     * Recompute the session's cost and token buckets from a transcript.
+     *
+     * Takes the list rather than reading `this.messages`, because it has two callers with
+     * different sources: the `messages` setter passes the rendered list, and post-resolve external
+     * cost passes the DRIVER's history — spend recorded there must reach the total WITHOUT
+     * reassigning `messages`, which would re-render the live interaction row. See
+     * `onExternalCostRecorded`.
+     *
+     * Recomputing (rather than incrementing on append) keeps the totals correct under any mutation
+     * of the message list — clear-chat, re-render, restore. `sumUsage` recurses into
+     * `toolCall.subAgentTrace`, so work a sub-agent did (possibly on another provider at other
+     * rates) counts, and it reads the usage a compaction banked onto its summary, so shrinking
+     * history no longer shrinks the totals.
+     */
+    private syncUsageTotals;
     /**
      * Runs side effects that were previously in `messagesChanged()`.
      * Called from the `messages` setter after dispatching to the store.
@@ -4043,6 +4112,9 @@ export declare class FoundationAiAssistant extends GenesisElement {
     removeAttachmentError(message: string): void;
     private isAcceptedFile;
     private readFileAsText;
+    /** The base64 payload of a file, without any `data:` prefix — the raw form
+     *  `ChatImageAttachment.data` specifies (transports add their own framing). */
+    private readFileAsBase64;
     private processFiles;
     private loadSelectedFiles;
     handleSendClick(): void;
@@ -4089,6 +4161,14 @@ export declare class FoundationAiAssistant extends GenesisElement {
     private send;
     onChatHeaderMouseDown(e: MouseEvent): void;
     handleInteractionCompleted(e: Event): void;
+    /**
+     * A widget reporting spend it incurred AFTER resolving.
+     *
+     * Note what this deliberately does NOT do: no `startLoadingTimer()`. This is bookkeeping about a
+     * turn that already finished, so it must be invisible — showing a spinner would tell the user the
+     * assistant is working when nothing is pending.
+     */
+    handleInteractionCost(e: Event): void;
     /**
      * The live {@link InteractionContext} for a pending interaction (GENC-1390).
      * `AiChatInteractionWrapper` pierces this across the shadow boundary to build the
@@ -4305,6 +4385,12 @@ export declare interface InteractionContext<TState extends object = Record<strin
     onDispose(fn: () => void): void;
 }
 
+/**
+ * Detail payload for the `interaction-cost` event — a POSITIVE DELTA in USD, not a running total.
+ * @public
+ */
+export declare type InteractionCostEventDetail = ChatInteractionEventsMap['interaction-cost'];
+
 /** True when the assistant is active in the layout panel (docked) rather than the bubble. */
 export declare function isAiAssistantDocked(): boolean;
 
@@ -4422,6 +4508,9 @@ export declare class OrchestratingDriver extends EventTarget implements AiDriver
         budgetExhaustedMessage?: string;
     });
     resolveInteraction(interactionId: string, result: unknown): void;
+    /** Delegated for the same reason as `resolveInteraction`: the history that owns the
+     *  interaction — and therefore the cost — lives on the wrapped driver, not here. */
+    recordExternalCost(interactionId: string, costUsd: number): boolean;
     getInteractionContext(interactionId: string): InteractionContext | undefined;
     isBusy(): boolean;
     /** Currently active provider name from the underlying ChatDriver. */

package/dist/chat-driver.cjs

@@ -3585,6 +3585,12 @@ var META_EVENT_IMPORTANCE = {
   "provider.selected": "normal",
   "interaction.requested": "normal",
   "interaction.resolved": "normal",
+  // Bookkeeping about an already-finished turn; interesting when reconciling a session total.
+  "interaction.external-cost": "normal",
+  // Spend that was billed but could NOT be recorded (the message was trimmed/condensed away, or
+  // the value was not real spend). 'high': it is the one way the session total goes quietly
+  // wrong, so it must stand out when reconciling.
+  "interaction.external-cost-dropped": "high",
   "external-diagnostics.folded": "normal",
   "session.cleared": "normal",
   "session.switched": "low",
@@ -5070,6 +5076,62 @@ Output format (strict):
       });
     });
   }
+  /**
+   * Add external (non-LLM) spend to an interaction's message AFTER it has resolved.
+   *
+   * **Why this exists separately from `resolveInteraction`.** A widget's spend reaches the session
+   * total only through `InteractionResult.costUsd`, which is read exactly once — `resolveInteraction`
+   * does its whole job inside `if (interaction)` and then deletes the entry from
+   * `pendingInteractions`. That is correct for the resolution itself, but it assumes a widget stops
+   * costing money when it resolves, and several deliberately do not: a widget that resolves EARLY so
+   * the assistant stops waiting (options shown, a preview rendered) may stay interactive for minutes
+   * afterwards and do more paid work on the user's behalf. Re-emitting `interaction-completed` does
+   * not help — with the interaction gone from the map the call is a silent no-op — so that spend had
+   * nowhere to go and was simply missing from the figure shown to the user.
+   *
+   * Additive by design: the caller reports a DELTA, not a running total, so repeated calls sum. It
+   * touches only `externalCostUsd`; the recorded `interaction.resolved` payload is left exactly as
+   * the resolution wrote it, because this is not a second resolution and must not read like one.
+   *
+   * Deliberately does NOT require the interaction to be pending, does not resurrect it, and has no
+   * loading/turn side effects — this is bookkeeping about a turn that already happened.
+   *
+   * @param interactionId the interaction whose message owns the spend.
+   * @param costUsd a positive delta in USD. Non-finite, zero and negative values are ignored.
+   * @returns `true` when the spend was recorded; `false` when it was not — either the value was
+   *   not a positive finite amount, or the message is no longer in history (trimmed or condensed
+   *   away). A real outcome a caller may want to log rather than a failure to throw on; every
+   *   `false` also records an `interaction.external-cost-dropped` meta event here, so money can
+   *   never disappear without a trace.
+   * @beta
+   */
+  recordExternalCost(interactionId, costUsd) {
+    const drop = (reason) => {
+      recordMetaEvent(this.sessionKey, "interaction.external-cost-dropped", {
+        interactionId,
+        costUsd,
+        reason
+      });
+      return false;
+    };
+    if (!interactionId) return drop("no interactionId");
+    if (typeof costUsd !== "number" || !Number.isFinite(costUsd) || costUsd <= 0) {
+      return drop("not a positive finite amount");
+    }
+    const idx = this.history.findIndex((m) => m.interaction?.interactionId === interactionId);
+    if (idx === -1) return drop("interaction message no longer in history");
+    this.history[idx] = {
+      ...this.history[idx],
+      externalCostUsd: (this.history[idx].externalCostUsd ?? 0) + costUsd
+    };
+    recordMetaEvent(this.sessionKey, "interaction.external-cost", { interactionId, costUsd });
+    this.dispatchEvent(
+      new CustomEvent("external-cost-recorded", {
+        detail: { interactionId, costUsd }
+      })
+    );
+    return true;
+  }
   /**
    * Resolve a pending interaction. The wrapper component calls this on completion.
    * Marks the interaction message as resolved so it renders read-only on re-render.
@@ -6509,10 +6571,20 @@ var OrchestratingDriver = class extends EventTarget {
         new CustomEvent("provider-changed", { detail: e.detail })
       );
     });
+    this.chatDriver.addEventListener("external-cost-recorded", (e) => {
+      this.dispatchEvent(
+        new CustomEvent("external-cost-recorded", { detail: e.detail })
+      );
+    });
   }
   resolveInteraction(interactionId, result) {
     this.chatDriver.resolveInteraction(interactionId, result);
   }
+  /** Delegated for the same reason as `resolveInteraction`: the history that owns the
+   *  interaction — and therefore the cost — lives on the wrapped driver, not here. */
+  recordExternalCost(interactionId, costUsd) {
+    return this.chatDriver.recordExternalCost(interactionId, costUsd);
+  }
   getInteractionContext(interactionId) {
     return this.chatDriver.getInteractionContext(interactionId);
   }