@animalabs/agent-framework 0.23.1 → 0.24.0

package/src/types/module.ts

@@ -27,7 +27,8 @@ export interface MessageQuery {
 
 /**
  * A message as a module context's reads answer it: a stored row, or a row
- * for a write the framework holds (`held`).
+ * for a write the framework holds (`held`). Either is marked
+ * `heldFromResidents` when a tune-out holds it from the residents.
  */
 export type ModuleMessage = StoredMessage & {
   /**
@@ -39,9 +40,31 @@ export type ModuleMessage = StoredMessage & {
    * and `timestamp` are provisional: the sequence comes after every stored
    * row's, the timestamp is when the framework held the write (for a write
    * an older release held, when its queue was read back), and both change
-   * when it lands. Absent on a stored row.
+   * when it lands. A held write whose earlier write may already be stored
+   * is looked up first, and answered as the stored row it is when the store
+   * holds it. Absent on a stored row.
    */
   held?: true;
+  /**
+   * True on a message a tune-out holds from the residents: one that arrived
+   * in a tuned-out channel, stamped `metadata.tuneOut` as it came in. The
+   * store keeps it, but no resident is shown the row itself: no resident's
+   * compiled view includes it, during the tune-out or after it, and a tool
+   * boundary of a turn alive when it arrived stores it without injecting it
+   * into the live turn. The subconscious reads it. Its text can still reach
+   * a resident in rows of their own, which aren't marked, such as the
+   * cancel's `<tuned-out-backlog>` row, with the text of the tune-out's newest
+   * messages, up to `backlogCap` of them and as many as fit in one of the
+   * residents' messages, the stored ones first and then those still held;
+   * what the subconscious says of it, in its report or its note; and the
+   * result of a tool that reads history on request, such as a
+   * channel's `fetch_history` or the history module's `extract`. A module
+   * that builds on what the residents see, such as one choosing from the
+   * recent conversation, leaves a marked row out, and one that matches
+   * what's stored, such as a sync's dedupe, keeps it. A held write (`held`)
+   * is marked too when it carries the stamp. Absent on every other row.
+   */
+  heldFromResidents?: true;
 };
 
 /**
@@ -290,13 +313,17 @@ export interface ModuleContext {
 
   /**
    * Edit a message, by its id or a held write's handle. A held write is
-   * stored with the new content.
+   * stored with the new content. One whose earlier write may already be
+   * stored, where the store can't be searched to tell, throws with nothing
+   * changed.
    */
   editMessage(id: MessageId, content: ContentBlock[]): void;
 
   /**
    * Remove a message, by its id or a held write's handle. A held write is
-   * dropped, so the agent never reads it.
+   * dropped, so the agent never reads it. One whose earlier write may
+   * already be stored, where the store can't be searched to tell, throws
+   * with nothing changed.
    */
   removeMessage(id: MessageId): void;
 
@@ -312,7 +339,9 @@ export interface ModuleContext {
   findMessageByExternalId(source: string, externalId: string): MessageId | null;
 
   /**
-   * Get a message by its id or a held write's handle.
+   * Get a message by its id or a held write's handle, marked
+   * `heldFromResidents` when a tune-out holds it from the residents
+   * (ModuleMessage).
    */
   getMessage(id: MessageId): ModuleMessage | null;
 
@@ -322,7 +351,9 @@ export interface ModuleContext {
    * The rows of writes the framework holds come after the stored rows, as
    * the newest, or before them in a reversed query, marked `held`
    * (ModuleMessage). Those the last process held show once create() has
-   * restored them, after every module's start() (addMessage).
+   * restored them, after every module's start() (addMessage). A message a
+   * tune-out holds from the residents is among the rows, marked
+   * `heldFromResidents` (ModuleMessage).
    */
   queryMessages(filter: MessageQuery): MessageQueryResult;
 
@@ -571,8 +602,9 @@ export interface SpeechContext {
 
   /**
    * The turn this speech ends: the same id as `ToolCall.callerTurnId` on the
-   * calls made in it (its model's calls and its foreground scripts' inner
-   * calls), kept across the turn's streams (a context-budget restart or a
+   * calls made in it (its model's calls, and a script's calls that reach the
+   * host while a code_execution call of the turn watches the script), kept across the
+   * turn's streams (a context-budget restart or a
    * retry), and larger for the agent's next turn. Unique only within one run
    * of the process.
    */

package/src/types/trace.ts

@@ -33,9 +33,23 @@ export type TraceEvent =
   | (TraceEventBase & {
       type: 'process:completed';
       processEvent: ProcessEvent;
+      /** The modules' responses that applied: one refused for malformed
+       *  content is left out, and named by process:response-refused. */
       responses: ModuleProcessResponse[];
       durationMs: number;
     })
+  /** A module's process response held content context-manager won't store,
+   *  in a message it adds or an edit it makes, and was refused whole before
+   *  any response to the event applied. `where` names the first such message
+   *  or edit in the response, such as `addMessages[1]`, and `places` is
+   *  malformedContentPlaces' answer for it. */
+  | (TraceEventBase & {
+      type: 'process:response-refused';
+      moduleName: string;
+      eventType: string;
+      where: string;
+      places: string[];
+    })
 
   // Inference lifecycle
   | (TraceEventBase & {
@@ -124,9 +138,15 @@ export type TraceEvent =
       blockType: 'text' | 'thinking' | 'tool_call' | 'tool_result';
       /** 0-indexed block position in the current assistant turn. */
       blockIndex: number;
-      /** The channel this stream shows typing in: the turn's locus as the
-       *  stream started (see inference:started), or in explicit mode the
-       *  channel the start's wake came from. */
+      /** The channel this stream shows typing in, the conversation the turn
+       *  is attending. Locus and hybrid mode: the turn's locus, which an
+       *  addressed re-pin or the agent's own `channel_open` can move between
+       *  rounds, so it can change within one stream; the indicator and these
+       *  traces follow it from the next round on, at the model's first
+       *  content in it or its retry after a refusal, and a tool result the
+       *  boundary reports carries the channel of the round it answers. In
+       *  hybrid mode a `>>>` envelope can send the text itself elsewhere.
+       *  Explicit mode: the channel the start's wake came from. */
       channelId?: string;
     })
   | (TraceEventBase & {
@@ -141,9 +161,15 @@ export type TraceEvent =
       phase: 'block_start' | 'block_complete';
       blockType: 'text' | 'thinking' | 'tool_call' | 'tool_result';
       blockIndex: number;
-      /** The channel this stream shows typing in: the turn's locus as the
-       *  stream started (see inference:started), or in explicit mode the
-       *  channel the start's wake came from. */
+      /** The channel this stream shows typing in, the conversation the turn
+       *  is attending. Locus and hybrid mode: the turn's locus, which an
+       *  addressed re-pin or the agent's own `channel_open` can move between
+       *  rounds, so it can change within one stream; the indicator and these
+       *  traces follow it from the next round on, at the model's first
+       *  content in it or its retry after a refusal, and a tool result the
+       *  boundary reports carries the channel of the round it answers. In
+       *  hybrid mode a `>>>` envelope can send the text itself elsewhere.
+       *  Explicit mode: the channel the start's wake came from. */
       channelId?: string;
     })
   | (TraceEventBase & {
@@ -173,6 +199,66 @@ export type TraceEvent =
       type: 'inference:turn_ended';
       agentName: string;
     })
+  | (TraceEventBase & {
+      /**
+       * Prose that delivery published, sent once the publish succeeds: the
+       * outgoing stream's chunk (MCPL Spec 14.3 `channels/outgoing/chunk`),
+       * emitted whether or not the channel's server takes the stream. It
+       * carries only what was published, so a consumer that speaks or shows
+       * it, such as a voice relay, never gets text that delivery withholds (a
+       * `skip_reply`, a silencing send, a private `think`, a hold, a bounce,
+       * a draft) or a publish the server didn't confirm (`delivered: true`):
+       * one refused before sending, one that threw, timed out or got an
+       * error answer, one the server reported undelivered
+       * (`delivered: false`), and one whose reply leaves `delivered` out.
+       * `inference:tokens` stays the model's text as it is written (held, as
+       * before, while a tool-result guard's batch is pending). A later
+       * publish to the same destination, a server and its channel, by the
+       * same stream opens with a paragraph break (`\n\n`), so a
+       * destination's chunks joined in `index` order are its text, its
+       * messages kept apart.
+       * `mcpl:speech-routed` also reports speech publishes, with no stream
+       * id, index or end, each once delivered: deliverSpeech's, the `sleep`
+       * tool's announcement among them, and a subconscious's
+       * `speak_in_channel`'s. A relay that voices the agent's prose takes
+       * this trace, with `inference:published_complete`, and not
+       * `mcpl:speech-routed` as well, and takes each message's id from its
+       * `messageId` to edit what it voiced.
+       */
+      type: 'inference:published';
+      agentName: string;
+      /** The server the prose is published to, and its channel there: two
+       *  servers' channels with the same id are two destinations. */
+      serverId: string;
+      channelId: string;
+      /** The stream's id, shared with its `channels/outgoing/*` notifications. */
+      inferenceId: string;
+      /** Increases by one per chunk of the stream, across its channels. */
+      index: number;
+      text: string;
+      /** The id the channel's server returned for this chunk's publish
+       *  (`ChannelsPublishResult.messageId`); absent when it returned none.
+       *  Each chunk is one publish, so each carries its own. */
+      messageId?: string;
+    })
+  | (TraceEventBase & {
+      /**
+       * A stream's end for one destination it published to, a server and
+       * its channel, emitted on every exit path once the stream has ended
+       * and its deliveries have run, or, when the host stops, before its
+       * connections close: `text` is everything its `inference:published`
+       * chunks carried there by then, and none follows it. Like those
+       * chunks, it's emitted whether or not that server takes the stream,
+       * or registers the channel still; the MCPL
+       * `channels/outgoing/complete` goes to the server only when it does.
+       */
+      type: 'inference:published_complete';
+      agentName: string;
+      serverId: string;
+      channelId: string;
+      inferenceId: string;
+      text: string;
+    })
 
   // Tool lifecycle
   | (TraceEventBase & {
@@ -216,10 +302,11 @@ export type TraceEvent =
     })
   | (TraceEventBase & {
       /**
-       * A writable workspace existed but the oversized-result spill write
-       * failed (size cap, storeBlob failure, …) — the over-cap tail was NOT
+       * The workspace had a writable mount without an include, where spills
+       * go, but the oversized-result spill write failed (size cap, storeBlob failure, …) — the over-cap tail was NOT
        * retained. Distinct from the no-workspace fallback, which is silent
-       * by design (nothing unexpected happened).
+       * by design (nothing unexpected happened), whether the setup has no
+       * writable mount or every writable mount has an include, as configured.
        */
       type: 'tool:spill_failed';
       label: string;
@@ -302,6 +389,18 @@ export type TraceEvent =
       field?: string;
       detail?: string;
     })
+  /** MCPL content that context-manager won't store, because it doesn't
+   *  match ContentBlock, reached the store/wake site and was refused there:
+   *  no row, no wake. `places` is malformedContentPlaces' answer for it. */
+  | (TraceEventBase & {
+      type: 'mcpl:malformed-content-refused';
+      lane: 'push' | 'channel';
+      serverId: string;
+      places: string[];
+      eventId?: string;
+      channelId?: string;
+      messageId?: string;
+    })
   /** MCPL content with nothing model-visible reached the store/wake site
    *  (module-emitted or coalescer-delivered) and was dropped: no row, no wake. */
   | (TraceEventBase & {
@@ -442,13 +541,16 @@ export type TraceEvent =
     })
 
   // Host-owned speech routing (ChannelRegistry.routeSpeech). One trace per
-  // delivered prose segment. `text` is the segment verbatim — the same content
+  // delivered prose segment, and one per publish the subconscious's
+  // speak_in_channel delivers (ChannelRegistry.publishForAgent): that one's
+  // conversationId is the speaking agent's name, and it carries no
+  // messageId. `text` is the segment verbatim — the same content
   // already on the bus chunk-by-chunk via inference:tokens, and mcpl:* traces
   // are 'ops'-scoped on the webui wire — and `messageId` is the surface's id
-  // for the posted message (when the MCPL server reports one). Together they
-  // give external taps the (channelId, messageId, text) tuple needed to edit
-  // a just-posted message, e.g. a TTS interruption truncating a reply to the
-  // words actually voiced.
+  // for the posted message (on routeSpeech's traces, when the MCPL server
+  // reports one). Together they give external taps the (channelId,
+  // messageId, text) tuple needed to edit a just-posted message, e.g. a TTS
+  // interruption truncating a reply to the words actually voiced.
   | (TraceEventBase & {
       type: 'mcpl:speech-routed';
       /** Agent / conversation whose speech was routed. */
@@ -459,7 +561,8 @@ export type TraceEvent =
       textLen: number;
       /** The routed prose segment, verbatim. */
       text: string;
-      /** Surface message id (e.g. Discord message id), when reported. */
+      /** Surface message id (e.g. Discord message id), when reported, on
+       *  routeSpeech's traces. speak_in_channel's carry none. */
       messageId?: string;
     })
   | (TraceEventBase & {
@@ -473,6 +576,9 @@ export type TraceEvent =
       /** `failed`: nothing was posted; `unknown`: the request was dispatched
        *  and no valid receipt came back, so it may have been. */
       outcome?: 'failed' | 'unknown';
+      /** The connector error's structured data, bounded (connectorText),
+       *  when it sent some: it may say what a multi-part send posted. */
+      detail?: string;
     })
 
   // Admin puppet: an operator executed a tool AS an agent and stored the

package/src/usage/types.ts

@@ -3,13 +3,29 @@ export interface SessionUsage {
   outputTokens: number;
   cacheCreationTokens: number;
   cacheReadTokens: number;
+  /** The summed estimated cost of the inferences counted here that membrane
+   *  priced, in one currency. An inference it couldn't price adds nothing, so
+   *  this is a lower bound when any were unpriced. Absent when none was
+   *  priced, and from the moment costs in two currencies meet here, since the
+   *  two can't be summed, which `mixedCurrencies` records. */
   estimatedCost?: { total: number; currency: string };
+  /** Set once inferences priced in two currencies have been counted here:
+   *  `estimatedCost` stays absent from then on, since the two can't be
+   *  summed and a later cost alone isn't this tally's. Stored and restored
+   *  with it, and carried into the shared ephemeral entry when stored
+   *  entries fold into it. */
+  mixedCurrencies?: true;
 }
 
 export interface AgentUsage {
   agentName: string;
   usage: SessionUsage;
   inferenceCount: number;
+  /** Set on the one entry that holds every ephemeral agent's usage together
+   *  (agentName EPHEMERAL_USAGE_NAME), apart from any agent of that name. Each
+   *  ephemeral agent runs under a new name, so an entry per name would grow
+   *  the record by one for every run, for good. */
+  ephemeral?: true;
 }
 
 export interface SessionUsageSnapshot {

package/src/usage/usage-tracker.ts

@@ -7,10 +7,13 @@ function snapshotUsage(usage: SessionUsage): SessionUsage {
   };
 }
 
+/** Add one count into a tally. `mixedCurrencies`: what's added is itself a
+ *  tally in which two currencies met, as a stored entry being folded can be. */
 function accumulateUsage(
   target: SessionUsage,
   tokens: { inputTokens: number; outputTokens: number; cacheCreationTokens: number; cacheReadTokens: number },
-  estimatedCost?: { total: number; currency: string }
+  estimatedCost?: { total: number; currency: string },
+  mixedCurrencies = false,
 ): void {
   // A provider's usage can lack a count (membrane 0.5.87's Bedrock stream
   // takes a message_delta's output count as reported); adding it would make
@@ -20,14 +23,16 @@ function accumulateUsage(
   target.outputTokens += count(tokens.outputTokens);
   target.cacheCreationTokens += count(tokens.cacheCreationTokens);
   target.cacheReadTokens += count(tokens.cacheReadTokens);
+  // Costs in two currencies can't be summed, and a cost counted after they
+  // met is only part of this tally's, so once they meet the cost stays absent.
+  if (target.mixedCurrencies) return;
+  if (mixedCurrencies || (estimatedCost && target.estimatedCost && target.estimatedCost.currency !== estimatedCost.currency)) {
+    target.estimatedCost = undefined;
+    target.mixedCurrencies = true;
+    return;
+  }
   if (estimatedCost) {
-    if (!target.estimatedCost) {
-      target.estimatedCost = { total: 0, currency: estimatedCost.currency };
-    } else if (target.estimatedCost.currency !== estimatedCost.currency) {
-      // Mixed currencies — drop cost tracking rather than produce garbage
-      target.estimatedCost = undefined;
-      return;
-    }
+    target.estimatedCost ??= { total: 0, currency: estimatedCost.currency };
     target.estimatedCost.total += estimatedCost.total;
   }
 }
@@ -47,18 +52,35 @@ function parseUsage(raw: unknown): SessionUsage | null {
     outputTokens,
     cacheCreationTokens: typeof o.cacheCreationTokens === 'number' ? o.cacheCreationTokens : 0,
     cacheReadTokens: typeof o.cacheReadTokens === 'number' ? o.cacheReadTokens : 0,
-    estimatedCost: o.estimatedCost && typeof o.estimatedCost === 'object'
-      ? { total: (o.estimatedCost as any).total, currency: (o.estimatedCost as any).currency }
-      : undefined,
+    ...(o.mixedCurrencies === true
+      ? { mixedCurrencies: true as const }
+      : {
+          estimatedCost: o.estimatedCost && typeof o.estimatedCost === 'object'
+            ? { total: (o.estimatedCost as any).total, currency: (o.estimatedCost as any).currency }
+            : undefined,
+        }),
   };
 }
 
 export interface PersistedUsageState {
   totals: SessionUsage;
-  byAgent: Array<{ agentName: string; usage: SessionUsage; inferenceCount: number }>;
+  byAgent: Array<{ agentName: string; usage: SessionUsage; inferenceCount: number; ephemeral?: true }>;
   inferenceCount: number;
 }
 
+/** The name the entry for every ephemeral agent's usage together goes by. */
+export const EPHEMERAL_USAGE_NAME = 'ephemeral agents';
+
+type Tally = { usage: SessionUsage; inferenceCount: number };
+
+const emptyUsage = (): SessionUsage => ({ inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 });
+
+/** Add one tally's stored usage and inference count into another. */
+function addTally(target: Tally, usage: SessionUsage, inferenceCount: number): void {
+  accumulateUsage(target.usage, usage, usage.estimatedCost, usage.mixedCurrencies === true);
+  target.inferenceCount += inferenceCount;
+}
+
 /** What keeps a stored usage record from restoring, or undefined when it
  *  restores: it must be an object whose totals are token counts and whose
  *  byAgent, if it has one, is a list. Its per-agent entries are checked one
@@ -72,22 +94,30 @@ export function persistedUsageProblem(value: unknown): 'not a record' | 'totals'
 }
 
 export class UsageTracker {
-  private totals: SessionUsage = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
-  private byAgent: Map<string, { usage: SessionUsage; inferenceCount: number }> = new Map();
+  private totals: SessionUsage = emptyUsage();
+  private byAgent: Map<string, Tally> = new Map();
+  /** Every ephemeral agent's usage together, kept apart from byAgent so an
+   *  agent named EPHEMERAL_USAGE_NAME has an entry of its own. */
+  private ephemeral: Tally | undefined;
   private inferenceCount = 0;
   private emitTrace: (event: UsageUpdatedEvent) => void;
 
+  /** `wasEphemeral` names the stored unmarked entries that belong in the
+   *  shared entry, such as an ephemeral agent's own from before ephemeral
+   *  agents shared one: each restores into the shared entry instead. A stored
+   *  entry marked ephemeral restores into it whatever its name. */
   constructor(opts: {
     emitTrace: (event: UsageUpdatedEvent) => void;
     restored?: PersistedUsageState;
+    wasEphemeral?: (agentName: string) => boolean;
   }) {
     this.emitTrace = opts.emitTrace;
     if (opts.restored) {
-      this.restoreFrom(opts.restored);
+      this.restoreFrom(opts.restored, opts.wasEphemeral ?? (() => false));
     }
   }
 
-  private restoreFrom(state: PersistedUsageState): void {
+  private restoreFrom(state: PersistedUsageState, wasEphemeral: (agentName: string) => boolean): void {
     const totals = parseUsage(state.totals);
     if (!totals) return;
     this.totals = totals;
@@ -95,36 +125,43 @@ export class UsageTracker {
     if (Array.isArray(state.byAgent)) {
       for (const item of state.byAgent as unknown[]) {
         if (!item || typeof item !== 'object') continue;
-        const entry = item as { agentName?: unknown; usage?: unknown; inferenceCount?: unknown };
+        const entry = item as { agentName?: unknown; usage?: unknown; inferenceCount?: unknown; ephemeral?: unknown };
         const usage = parseUsage(entry.usage);
         if (usage && typeof entry.agentName === 'string') {
-          this.byAgent.set(entry.agentName, {
-            usage,
-            inferenceCount: typeof entry.inferenceCount === 'number' ? entry.inferenceCount : 0,
-          });
+          const inferenceCount = typeof entry.inferenceCount === 'number' ? entry.inferenceCount : 0;
+          if (entry.ephemeral === true || wasEphemeral(entry.agentName)) {
+            this.ephemeral ??= { usage: emptyUsage(), inferenceCount: 0 };
+            addTally(this.ephemeral, usage, inferenceCount);
+          } else {
+            this.byAgent.set(entry.agentName, { usage, inferenceCount });
+          }
         }
       }
     }
+    // The totals count every entry's inferences, so stored entries whose
+    // costs are in two currencies, or one where two met, mean two met in the
+    // totals too. A record written before mixedCurrencies shows it only so.
+    const tallies = [...this.byAgent.values(), ...(this.ephemeral ? [this.ephemeral] : [])].map((tally) => tally.usage);
+    const currencies = new Set(tallies.flatMap((usage) => (usage.estimatedCost ? [usage.estimatedCost.currency] : [])));
+    if (this.totals.estimatedCost) currencies.add(this.totals.estimatedCost.currency);
+    if (!this.totals.mixedCurrencies && (currencies.size > 1 || tallies.some((usage) => usage.mixedCurrencies))) {
+      this.totals.estimatedCost = undefined;
+      this.totals.mixedCurrencies = true;
+    }
   }
 
   toJSON(): PersistedUsageState {
-    return {
-      totals: snapshotUsage(this.totals),
-      byAgent: [...this.byAgent.entries()].map(([name, data]) => ({
-        agentName: name,
-        usage: snapshotUsage(data.usage),
-        inferenceCount: data.inferenceCount,
-      })),
-      inferenceCount: this.inferenceCount,
-    };
+    return this.getSnapshot();
   }
 
+  /** `ephemeral`: the agent is an ephemeral one, whose usage counts in the
+   *  shared entry; the trace still names the agent. */
   onInferenceCompleted(agentName: string, usage: {
     inputTokens: number;
     outputTokens: number;
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
-  }, estimatedCost?: { total: number; currency: string }): void {
+  }, estimatedCost?: { total: number; currency: string }, ephemeral = false): void {
     const tokens = {
       inputTokens: usage.inputTokens,
       outputTokens: usage.outputTokens,
@@ -135,10 +172,11 @@ export class UsageTracker {
     accumulateUsage(this.totals, tokens, estimatedCost);
     this.inferenceCount++;
 
-    let agent = this.byAgent.get(agentName);
+    let agent = ephemeral ? this.ephemeral : this.byAgent.get(agentName);
     if (!agent) {
-      agent = { usage: { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 }, inferenceCount: 0 };
-      this.byAgent.set(agentName, agent);
+      agent = { usage: emptyUsage(), inferenceCount: 0 };
+      if (ephemeral) this.ephemeral = agent;
+      else this.byAgent.set(agentName, agent);
     }
     accumulateUsage(agent.usage, tokens, estimatedCost);
     agent.inferenceCount++;
@@ -152,14 +190,19 @@ export class UsageTracker {
   }
 
   getSnapshot(): SessionUsageSnapshot {
-    return {
-      totals: snapshotUsage(this.totals),
-      byAgent: [...this.byAgent.entries()].map(([name, data]) => ({
-        agentName: name,
-        usage: snapshotUsage(data.usage),
-        inferenceCount: data.inferenceCount,
-      })),
-      inferenceCount: this.inferenceCount,
-    };
+    const byAgent: SessionUsageSnapshot['byAgent'] = [...this.byAgent.entries()].map(([name, data]) => ({
+      agentName: name,
+      usage: snapshotUsage(data.usage),
+      inferenceCount: data.inferenceCount,
+    }));
+    if (this.ephemeral) {
+      byAgent.push({
+        agentName: EPHEMERAL_USAGE_NAME,
+        usage: snapshotUsage(this.ephemeral.usage),
+        inferenceCount: this.ephemeral.inferenceCount,
+        ephemeral: true,
+      });
+    }
+    return { totals: snapshotUsage(this.totals), byAgent, inferenceCount: this.inferenceCount };
   }
 }