@teaflask/assistant 0.3.0 → 0.6.0

package/src/core/turn-failed-anchors.ts

@@ -1,44 +0,0 @@
-// The failure-receipt anchor model: a turn_failed CUSTOM event is the
-// durable record that this turn ended in failure outside any single tool
-// — quota, provider, transport, orchestration, or a sweep —
-// carrying the wire's own reader-aware sentence (the same string as the
-// turn's `error`). It is the failed turn's only replay-stable record:
-// the run's live RUN_ERROR demotes to RUN_FINISHED on replay. The
-// mechanics — narrow, merge, seed, record — are the shared
-// string-receipt family's (receipt-anchors.ts); this module binds them
-// to the turn_failed event under the failure vocabulary its consumers
-// speak.
-
-import {
-  receiptMarkerRecorder,
-  receiptOf,
-  wellFormedReceiptAnchorsOf,
-  withReceiptAnchored,
-  type AnchoredReceipts,
-} from "./receipt-anchors.js";
-import { TURN_FAILED_EVENT_NAME } from "../contract/events.js";
-import type { AgentSubscriber } from "@ag-ui/client";
-
-export type AnchoredTurnFailReceipts = AnchoredReceipts;
-
-export const EMPTY_TURN_FAILED_ANCHORS: ReadonlyMap<
-  string,
-  AnchoredTurnFailReceipts
-> = new Map();
-
-export const turnFailedReceiptOf = receiptOf;
-
-export const withTurnFailedAnchored = withReceiptAnchored;
-
-export const wellFormedFailAnchorsOf = wellFormedReceiptAnchorsOf;
-
-export function turnFailedMarkerRecorder(
-  onReceiptAnchored: (
-    failedRunId: string,
-    messageId: string,
-    position: keyof AnchoredTurnFailReceipts,
-    receipts: string[],
-  ) => void,
-): AgentSubscriber {
-  return receiptMarkerRecorder(TURN_FAILED_EVENT_NAME, onReceiptAnchored);
-}

package/src/core/turn-failure-copy.ts

@@ -1,57 +0,0 @@
-// The failure banner's copy rules: which settled turn earns the failure
-// banner at all (failureSentenceOf), and when the banner yields to the
-// transcript's own durable receipt (bannerFailureSentenceOf). The pins in
-// tests/turn-stopped.test.ts and tests/turn-failed.test.ts import from
-// here.
-
-import type { ServingAssistantTurn } from "../contract/threads.js";
-import type { AnchoredTurnFailReceipts } from "./turn-failed-anchors.js";
-
-// Exported for the status-taxonomy pins: failed is the ONLY status that
-// earns the failure banner — parked is resumable and superseded is a
-// receipt, and neither may ever read as an error. And only a VISITOR
-// turn's failure (kind null) earns it: a failed machine turn (delivery,
-// or any future kind — the additive rule) fails in a conversation the
-// visitor isn't driving, and the fallback copy ("the last answer") would
-// be a lie about a message they never sent. Its honest record stays in
-// the activity feed (settledResultOf, deliberately) and the org-facing
-// conversations log.
-export function failureSentenceOf(
-  turns: ServingAssistantTurn[],
-): string | null {
-  const newestTurn = turns.at(-1);
-  if (newestTurn?.status === "failed" && newestTurn.kind == null) {
-    return newestTurn.error ?? "The last answer didn't finish.";
-  }
-  return null;
-}
-
-// The banner's yielding rule: once the transcript itself
-// anchors the failed turn's durable receipt (the turn_failed marker),
-// the notice banner is a duplicate telling — the row IS the record, in
-// place, and it survives reload. The banner therefore renders only for
-// histories with no anchored receipt: turns that failed before the
-// marker existed, or a REST adoption that outran the stream. Matching
-// is by sentence content because the receipt is BY CONSTRUCTION the
-// same string as the turn's error (the backend writes both in one
-// settle); two distinct failed turns sharing one canned sentence would
-// suppress on the older turn's receipt, which still points the reader
-// at a true failure record.
-export function bannerFailureSentenceOf(
-  sentence: string | null,
-  failedReceiptAnchors:
-    ReadonlyMap<string, AnchoredTurnFailReceipts> | undefined,
-): string | null {
-  if (sentence === null || failedReceiptAnchors === undefined) {
-    return sentence;
-  }
-  for (const anchored of failedReceiptAnchors.values()) {
-    if (
-      anchored.before.includes(sentence) ||
-      anchored.after.includes(sentence)
-    ) {
-      return null;
-    }
-  }
-  return sentence;
-}

package/src/core/turn-usage-anchors.ts

@@ -1,216 +0,0 @@
-// The turn-usage anchor model, pure of React: the recorder maps each
-// turn_usage_recorded CUSTOM marker to its turn id, consumers read the
-// map to show honest token totals where a surface is entitled to them
-// (today none in the conversation chrome — slot contract §7), and the
-// resume store holds the map across remounts (the marker never becomes a
-// message, and a snapshot-seeded reconnect replays only past the cursor).
-// An absent entry means usage is UNKNOWN and the number hides cleanly —
-// the wire never carries a client-side estimate, and this module never
-// invents one. finality is an open vocabulary: only "final" reads as
-// settled truth; any other token — "partial" (a
-// call was cut short before the provider reported a count, so the sums
-// are known lower bounds), "stopped" (the member stopped a
-// segment mid-flight and its rows are still landing) or tomorrow's
-// unknowns — reads as not-final.
-
-import type { AgentSubscriber } from "@ag-ui/client";
-
-import { TURN_USAGE_RECORDED_EVENT_NAME } from "../contract/events.js";
-
-// Vocabulary tokens are single words by contract; a runaway token is
-// retained capped and resolves to not-final downstream.
-const TOKEN_MAX_CHARS = 64;
-
-// The one finality token that reads as settled truth — deliberately a
-// plain string, not an enum: finality is an OPEN wire vocabulary (the
-// "open vocabularies, not wire enums" ruling), and this constant
-// exists so the schema default and the truth test can never drift apart.
-const FINAL_FINALITY = "final";
-
-export interface TurnUsage {
-  turnId: string;
-  /** Open vocabulary: "final" is settled truth; anything else is not. */
-  finality: string;
-  inputTokens: number;
-  outputTokens: number;
-  cacheReadTokens: number;
-  cacheWriteTokens: number;
-  totalTokens: number;
-}
-
-export const EMPTY_TURN_USAGE_ANCHORS: ReadonlyMap<string, TurnUsage> =
-  new Map();
-
-/** Whether a narrowed usage entry is settled truth. */
-export function usageIsFinal(usage: TurnUsage): boolean {
-  return usage.finality === FINAL_FINALITY;
-}
-
-/**
- * Narrow a turn_usage_recorded marker's value. Null means ignore — the
- * contract's "clients MUST ignore events and fields they do not
- * recognize": a malformed count is not honest evidence, and a usage row
- * without its turn id has no durable join.
- */
-export function turnUsageAnchorOf(value: unknown): TurnUsage | null {
-  if (typeof value !== "object" || value === null) {
-    return null;
-  }
-  const {
-    turn_id: turnId,
-    finality,
-    input_tokens: inputTokens,
-    output_tokens: outputTokens,
-    cache_read_tokens: cacheReadTokens,
-    cache_write_tokens: cacheWriteTokens,
-    total_tokens: totalTokens,
-  } = value as {
-    turn_id?: unknown;
-    finality?: unknown;
-    input_tokens?: unknown;
-    output_tokens?: unknown;
-    cache_read_tokens?: unknown;
-    cache_write_tokens?: unknown;
-    total_tokens?: unknown;
-  };
-  if (typeof turnId !== "string" || turnId === "") {
-    return null;
-  }
-  // The wire schema declares finality optional with a server-side
-  // default of "final" — an ABSENT field resolves to that default (the
-  // counts are still honest evidence), while a PRESENT-but-malformed one
-  // is a shape surprise and drops the row like any other.
-  const resolvedFinality = finality === undefined ? FINAL_FINALITY : finality;
-  if (typeof resolvedFinality !== "string" || resolvedFinality.trim() === "") {
-    return null;
-  }
-  if (
-    !_isCount(inputTokens) ||
-    !_isCount(outputTokens) ||
-    !_isCount(cacheReadTokens) ||
-    !_isCount(cacheWriteTokens) ||
-    !_isCount(totalTokens)
-  ) {
-    return null;
-  }
-  return {
-    turnId,
-    finality: resolvedFinality.slice(0, TOKEN_MAX_CHARS),
-    inputTokens,
-    outputTokens,
-    cacheReadTokens,
-    cacheWriteTokens,
-    totalTokens,
-  };
-}
-
-/**
- * Reconcile-by-id, never append: a delayed or replayed marker updates the
- * turn's existing entry. A FINAL entry is never demoted by a non-final
- * one (a replay can interleave a future partial behind its final), and
- * an identical re-delivery returns the map unchanged — identity is the
- * publish gate.
- */
-export function withTurnUsageAnchored(
-  previous: ReadonlyMap<string, TurnUsage>,
-  usage: TurnUsage,
-): ReadonlyMap<string, TurnUsage> {
-  const existing = previous.get(usage.turnId);
-  if (existing !== undefined) {
-    if (usageIsFinal(existing) && !usageIsFinal(usage)) {
-      return previous;
-    }
-    if (_sameUsage(existing, usage)) {
-      return previous;
-    }
-  }
-  const next = new Map(previous);
-  next.set(usage.turnId, usage);
-  return next;
-}
-
-/**
- * A defensive copy for seeding from the resume store: entries that are
- * not a well-formed usage record are dropped rather than rendered — a
- * dropped entry degrades to a hidden number until the next full replay,
- * never a crash.
- */
-export function wellFormedTurnUsageAnchorsOf(
-  stored: ReadonlyMap<string, TurnUsage>,
-): ReadonlyMap<string, TurnUsage> {
-  const seeded = new Map<string, TurnUsage>();
-  const entries = stored as ReadonlyMap<unknown, unknown>;
-  for (const [turnId, usage] of entries) {
-    if (typeof turnId !== "string" || !_isWellFormedUsage(usage)) {
-      continue;
-    }
-    seeded.set(turnId, usage);
-  }
-  return seeded;
-}
-
-/** Records each usage marker's turn id → narrowed totals. */
-export function turnUsageRecorder(
-  onUsageAnchored: (usage: TurnUsage) => void,
-): AgentSubscriber {
-  return {
-    onCustomEvent({ event }) {
-      if (event.name !== TURN_USAGE_RECORDED_EVENT_NAME) {
-        return;
-      }
-      const usage = turnUsageAnchorOf(event.value);
-      if (usage !== null) {
-        onUsageAnchored(usage);
-      }
-    },
-  };
-}
-
-function _isCount(value: unknown): value is number {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-
-function _sameUsage(a: TurnUsage, b: TurnUsage): boolean {
-  return (
-    a.finality === b.finality &&
-    a.inputTokens === b.inputTokens &&
-    a.outputTokens === b.outputTokens &&
-    a.cacheReadTokens === b.cacheReadTokens &&
-    a.cacheWriteTokens === b.cacheWriteTokens &&
-    a.totalTokens === b.totalTokens
-  );
-}
-
-function _isWellFormedUsage(usage: unknown): usage is TurnUsage {
-  if (typeof usage !== "object" || usage === null) {
-    return false;
-  }
-  const {
-    turnId,
-    finality,
-    inputTokens,
-    outputTokens,
-    cacheReadTokens,
-    cacheWriteTokens,
-    totalTokens,
-  } = usage as {
-    turnId?: unknown;
-    finality?: unknown;
-    inputTokens?: unknown;
-    outputTokens?: unknown;
-    cacheReadTokens?: unknown;
-    cacheWriteTokens?: unknown;
-    totalTokens?: unknown;
-  };
-  return (
-    typeof turnId === "string" &&
-    turnId !== "" &&
-    typeof finality === "string" &&
-    finality !== "" &&
-    _isCount(inputTokens) &&
-    _isCount(outputTokens) &&
-    _isCount(cacheReadTokens) &&
-    _isCount(cacheWriteTokens) &&
-    _isCount(totalTokens)
-  );
-}

package/src/core/turns-backfill.ts

@@ -1,56 +0,0 @@
-// The thread detail serves the newest window of a conversation's turns
-// (TURNS_PAGE_SIZE in the contract; a full window means earlier turns
-// exist), but the stream replay is the whole conversation — so the ledger
-// must hold every turn or old runs replay with the wrong (or no) user
-// message spliced in front. A full first window triggers a cursor walk
-// back until a short page. Both doors serve the same window shape, so the
-// widget store and the playground hook walk through this one function.
-export const TURNS_WINDOW = 200;
-
-/** The turns page cursor both doors' thread-detail GET accepts. */
-export interface TurnsBackfillCursor {
-  before_created_at: string;
-  before_id: string;
-  limit: number;
-}
-
-/**
- * Walks the turns cursor back from a full newest window until a short
- * page, oldest first. A flaky page degrades instead of blocking: the walk
- * stops and what landed is returned — the oldest splices degrade, the
- * conversation never blocks. `isStale` is re-read after every await; a
- * walk that outlived its adoption (the user opened another thread
- * mid-drain) returns null and the caller adopts nothing.
- */
-export async function backfilledTurnsOf<
-  T extends { id: string; created_at: string },
->(
-  newestWindow: readonly T[],
-  fetchPage: (cursor: TurnsBackfillCursor) => Promise<{ turns: T[] }>,
-  opts: { isStale?: () => boolean } = {},
-): Promise<T[] | null> {
-  const turns = [...newestWindow];
-  let oldest: T | undefined =
-    turns.length >= TURNS_WINDOW ? turns[0] : undefined;
-  while (oldest !== undefined) {
-    let page: { turns: T[] };
-    try {
-      page = await fetchPage({
-        before_created_at: oldest.created_at,
-        before_id: oldest.id,
-        limit: TURNS_WINDOW,
-      });
-    } catch {
-      break;
-    }
-    if (opts.isStale?.()) {
-      return null;
-    }
-    turns.unshift(...page.turns);
-    oldest = page.turns.length < TURNS_WINDOW ? undefined : page.turns[0];
-  }
-  if (opts.isStale?.()) {
-    return null;
-  }
-  return turns;
-}

package/src/core/user-turn-ledger.ts

@@ -1,256 +0,0 @@
-import type { AbstractAgent, AgentSubscriber } from "@ag-ui/client";
-import type { Message } from "@ag-ui/core";
-
-import type {
-  ServingAssistantTurn,
-  TurnAttachment,
-} from "../contract/threads.js";
-
-// The stream carries only the assistant's side of the conversation; turn
-// rows are the display source for user text (the serving contract,
-// "Listing and reading conversations"). The ledger keeps the turns the
-// surface knows about — seeded from the thread detail, extended by every
-// send — so the injector can splice each user message in front of its
-// run's replayed output.
-
-export interface UserTurnRecord {
-  turnId: string;
-  runId: string | null;
-  userMessage: string;
-  // "delivery" means the system started the turn to push settled
-  // subagent results: user_message is "" and the injector
-  // splices no visitor bubble for it.
-  kind: string | null;
-  // The message's attachments, upload order — rendered as chips and
-  // inline media beside the text. Display facts only; the bytes are a
-  // download-url exchange away.
-  attachments: TurnAttachment[];
-  // The turn's server creation stamp (ISO-8601, required on the wire) —
-  // the user bubble's timestamp source: the wire carries no per-message
-  // timestamp, so the turn's created_at is the one honest clock, and never
-  // a client's. Write-once by construction: record()'s early-return branch
-  // updates only the late-arriving runId.
-  createdAt: string;
-}
-
-/** One user message's turn-side display facts, keyed by the injected
- *  message's stable id — the transcript derivation's side table
- *  (attachments and the timestamp never ride the AG-UI Message). */
-export interface UserTurnMeta {
-  attachments: TurnAttachment[];
-  createdAt: string;
-}
-
-/** The ledger surface the injector reads (one injector over
- *  two doors). UserTurnLedger satisfies it structurally; so does the
- *  playground's ledger over the dashboard door. A turn's slice is the
- *  facts the splice needs — its id, whether it is machine-initiated
- *  (kind non-null injects no member message), and the member's text. */
-export interface InjectableTurnLedger {
-  turnForRun(runId: string): {
-    turnId: string;
-    kind: string | null;
-    userMessage: string;
-  } | null;
-  nextUninjectedTurn(
-    messages: readonly { id: string }[],
-  ): ReturnType<InjectableTurnLedger["turnForRun"]>;
-}
-
-type InjectableTurn = NonNullable<
-  ReturnType<InjectableTurnLedger["turnForRun"]>
->;
-
-export function userMessageIdFor(turnId: string): string {
-  // Derived, stable, and disjoint from the stream's opaque ids — the same
-  // turn injects under the same id on every replay, so the splice is
-  // idempotent by construction.
-  return `user:${turnId}`;
-}
-
-export class UserTurnLedger {
-  private readonly turns: UserTurnRecord[] = [];
-  // Bumped on every new record — the store's cheap dirty check for the
-  // derived attachments map, so publishing stays allocation-free when
-  // nothing changed.
-  private _version = 0;
-
-  constructor(turns: ServingAssistantTurn[] = []) {
-    this.merge(turns);
-  }
-
-  get version(): number {
-    return this._version;
-  }
-
-  merge(turns: ServingAssistantTurn[]): void {
-    for (const turn of turns) {
-      this.record(turn);
-    }
-  }
-
-  record(turn: ServingAssistantTurn): void {
-    const existing = this.turns.find((known) => known.turnId === turn.id);
-    if (existing !== undefined) {
-      // A turn's run id can arrive late (the send races the recording).
-      existing.runId = turn.run_id;
-      return;
-    }
-    this.turns.push({
-      turnId: turn.id,
-      runId: turn.run_id,
-      userMessage: turn.user_message,
-      kind: turn.kind,
-      attachments: turn.attachments ?? [],
-      createdAt: turn.created_at,
-    });
-    this._version += 1;
-  }
-
-  /** Every known turn's display facts keyed by the injected user
-   *  message's stable id — one side table for both joins (the
-   *  attachments map widened with the timestamp rather than a second
-   *  map of the same rows being published). */
-  metaByMessageId(): ReadonlyMap<string, UserTurnMeta> {
-    const byMessageId = new Map<string, UserTurnMeta>();
-    for (const turn of this.turns) {
-      byMessageId.set(userMessageIdFor(turn.turnId), {
-        attachments: turn.attachments,
-        createdAt: turn.createdAt,
-      });
-    }
-    return byMessageId;
-  }
-
-  turnForRun(runId: string): UserTurnRecord | null {
-    return this.turns.find((known) => known.runId === runId) ?? null;
-  }
-
-  // The submit-path LAST-RESORT fallback when a run's id capture was
-  // lost: a best-effort guess, not a law — a queued message can sit
-  // newer than the pause, so the newest record may be a queued turn;
-  // the door's own 409 backstops a wrong guess, exactly the lost-capture
-  // stance the backend documents.
-  newestTurn(): UserTurnRecord | null {
-    return this.turns.at(-1) ?? null;
-  }
-
-  // The ordered fallback for runs the ledger cannot name: a turn whose run
-  // id capture was lost still replays in conversation order, so the first
-  // not-yet-injected turn is the one this run answers. Best-effort by
-  // design — it matches the backend's own stance on lost captures.
-  nextUninjectedTurn(
-    messages: readonly { id: string }[],
-  ): UserTurnRecord | null {
-    return (
-      this.turns.find(
-        (known) =>
-          // A machine-initiated turn (kind non-null — the contract's
-          // additive rule: treat unknown kinds like "delivery") injects
-          // nothing, so it is never "uninjected" — matching it here would
-          // hand its empty message to someone else's run forever.
-          known.kind == null &&
-          !messages.some(
-            (message) => message.id === userMessageIdFor(known.turnId),
-          ),
-      ) ?? null
-    );
-  }
-}
-
-export interface UserTurnInjectorCallbacks {
-  // Re-fetches the thread detail into the ledger — the recovery for a run
-  // some other tab started.
-  refreshLedger: () => Promise<void>;
-  // A turn's user message is now in the transcript under its stable id —
-  // the page drops its pending echo.
-  onUserMessageInjected: (messageId: string) => void;
-  // A run reached its terminal (finished or errored) — the surface
-  // re-reads the thread for its settled truth (busy flag, turn statuses).
-  onRunSettled: () => void;
-}
-
-/**
- * Splices each turn's user message in front of its run's replayed output.
- * Every replayed segment opens with RUN_STARTED carrying the run id the
- * turn rows also carry, and the injected id is derived from the turn id,
- * so the splice is idempotent across reconnects and full replays.
- *
- * Attached at connection-epoch construction, strictly before any connect,
- * so every run this agent ever serves carries the spliced user messages.
- */
-export function userTurnInjector(
-  ledger: InjectableTurnLedger,
-  callbacks: UserTurnInjectorCallbacks,
-): AgentSubscriber {
-  const { refreshLedger, onUserMessageInjected, onRunSettled } = callbacks;
-  return {
-    onRunStartedEvent({ event, messages, agent: eventAgent }) {
-      const known =
-        ledger.turnForRun(event.runId) ?? ledger.nextUninjectedTurn(messages);
-      if (known !== null) {
-        if (known.kind != null) {
-          // A machine-initiated turn (delivery today; unknown kinds read
-          // the same by the contract's additive rule) has no visitor
-          // message: its run opens directly with the assistant's output.
-          return;
-        }
-        const messageId = userMessageIdFor(known.turnId);
-        onUserMessageInjected(messageId);
-        if (messages.some((message) => message.id === messageId)) {
-          return;
-        }
-        return { messages: [...messages, _userMessageOf(known)] };
-      }
-      // A run the ledger cannot name — another tab sent it. Fetch the
-      // truth, then splice at the position this run started.
-      const anchorIndex = messages.length;
-      void refreshLedger().then(() => {
-        _spliceLateUserMessage(
-          eventAgent,
-          ledger,
-          event.runId,
-          anchorIndex,
-          onUserMessageInjected,
-        );
-      });
-      return;
-    },
-    onRunFinishedEvent() {
-      onRunSettled();
-    },
-    onRunErrorEvent() {
-      onRunSettled();
-    },
-  };
-}
-
-function _userMessageOf(record: InjectableTurn): Message {
-  return {
-    id: userMessageIdFor(record.turnId),
-    role: "user",
-    content: record.userMessage,
-  };
-}
-
-function _spliceLateUserMessage(
-  agent: AbstractAgent,
-  ledger: InjectableTurnLedger,
-  runId: string,
-  anchorIndex: number,
-  onUserMessageInjected: (messageId: string) => void,
-): void {
-  const late = ledger.turnForRun(runId);
-  if (late === null || late.kind != null) {
-    return;
-  }
-  const messageId = userMessageIdFor(late.turnId);
-  onUserMessageInjected(messageId);
-  const current = agent.messages;
-  if (current.some((message) => message.id === messageId)) {
-    return;
-  }
-  const next = [...current];
-  next.splice(Math.min(anchorIndex, next.length), 0, _userMessageOf(late));
-  agent.setMessages(next);
-}

package/src/core/wire-sentence-cap.ts

@@ -1,6 +0,0 @@
-// The one narrowing cap for every server-derived sentence a marker or
-// tool result carries (a receipt, an error, a refusal): the narrower
-// distrusts the wire by contract, so a runaway sentence is retained
-// capped, never unbounded. One constant so five anchor
-// families cannot drift apart on the number.
-export const WIRE_SENTENCE_MAX_CHARS = 2000;

package/src/generated/models/activityMessage.ts

@@ -1,24 +0,0 @@
-/**
- * Generated by orval 🍺
- * Do not edit manually.
- * teaflask-serving
- * OpenAPI spec version: 1
- */
-import type { ActivityMessageContent } from "./activityMessageContent.js";
-import type { ActivityMessageMetadata } from "./activityMessageMetadata.js";
-
-/**
- * Structured progress that is not conversation content, materialised as a
- * message so it keeps its place in the sequence. Stands alone rather than
- * composing BaseMessage, because its content is an object rather than a
- * string.
- */
-export interface ActivityMessage {
-  subagentRunId?: string | null;
-  id: string;
-  role?: "activity";
-  activityType: string;
-  content: ActivityMessageContent;
-  metadata?: ActivityMessageMetadata;
-  [key: string]: unknown;
-}

package/src/generated/models/activityMessageContent.ts

@@ -1,8 +0,0 @@
-/**
- * Generated by orval 🍺
- * Do not edit manually.
- * teaflask-serving
- * OpenAPI spec version: 1
- */
-
-export type ActivityMessageContent = { [key: string]: unknown };

package/src/generated/models/activityMessageMetadata.ts

@@ -1,8 +0,0 @@
-/**
- * Generated by orval 🍺
- * Do not edit manually.
- * teaflask-serving
- * OpenAPI spec version: 1
- */
-
-export type ActivityMessageMetadata = { [key: string]: unknown } | null;