@teaflask/assistant 0.0.0 → 0.3.0

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

@@ -0,0 +1,44 @@
+// 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

@@ -0,0 +1,57 @@
+// 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

@@ -0,0 +1,216 @@
+// 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

@@ -0,0 +1,56 @@
+// 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

@@ -0,0 +1,256 @@
+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

@@ -0,0 +1,6 @@
+// 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

@@ -0,0 +1,24 @@
+/**
+ * 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

@@ -0,0 +1,8 @@
+/**
+ * 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

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