@genesislcap/ai-assistant 15.15.2 → 15.16.0

package/dist/chat-driver.mjs

@@ -3518,6 +3518,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",
@@ -5003,6 +5009,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.
@@ -6442,10 +6504,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);
   }