talon-agent 4.3.1 → 4.3.2

package/src/frontend/teams/poll.ts

@@ -0,0 +1,101 @@
+/**
+ * Teams poll loop — Graph API chat polling is the whole receive side (no
+ * Bot Framework, no inbound endpoint). Each tick fetches the newest
+ * messages, cuts at the last one seen, and hands the rest — oldest first —
+ * to the slash-command router or a model turn.
+ */
+
+import { log, logError } from "../../util/log.js";
+import { handleSlashCommand } from "./commands.js";
+import type { ChatMessage } from "./graph.js";
+import type { TeamsRuntime } from "./runtime.js";
+import { runTurn } from "./turn.js";
+
+/**
+ * Messages arrive newest first; everything before `lastSeenId` is new. IDs
+ * are opaque strings, so this is a cut at the seen id, not a comparison.
+ */
+export function selectNewMessages(
+  messages: ChatMessage[],
+  lastSeenId: string | null,
+): ChatMessage[] {
+  const fresh: ChatMessage[] = [];
+  for (const msg of messages) {
+    if (lastSeenId && msg.id === lastSeenId) break;
+    fresh.push(msg);
+  }
+  return fresh;
+}
+
+// Skip bot/workflow messages by display name (echo loop prevention).
+// We do NOT filter by user ID — the authenticated user also sends
+// real messages that Talon should respond to.
+function isBotEcho(runtime: TeamsRuntime, msg: ChatMessage): boolean {
+  return (
+    !!runtime.botDisplayName &&
+    msg.senderName.toLowerCase() === runtime.botDisplayName.toLowerCase()
+  );
+}
+
+async function handleMessage(
+  runtime: TeamsRuntime,
+  msg: ChatMessage,
+): Promise<void> {
+  const talonChatId = `teams_chat_${msg.chatId}`;
+  if (await handleSlashCommand(runtime, msg, talonChatId)) return;
+
+  log(
+    "teams",
+    `[${msg.senderName}]: ${msg.text.slice(0, 80)}${msg.text.length > 80 ? "..." : ""}`,
+  );
+  runTurn(runtime, msg, talonChatId);
+}
+
+async function poll(runtime: TeamsRuntime, chatId: string): Promise<void> {
+  if (runtime.polling) return;
+  runtime.polling = true;
+
+  try {
+    if (!runtime.graphClient) return;
+    const messages = await runtime.graphClient.getChatMessages(chatId, 20);
+    const newMessages = selectNewMessages(messages, runtime.lastSeenMessageId);
+
+    if (newMessages.length > 0) {
+      runtime.lastSeenMessageId = newMessages[0].id;
+    }
+
+    // Process in chronological order (oldest first)
+    for (const msg of newMessages.reverse()) {
+      if (!msg.text.trim()) continue;
+      if (msg.edited) continue;
+      if (isBotEcho(runtime, msg)) continue;
+      await handleMessage(runtime, msg);
+    }
+  } catch (err) {
+    logError(
+      "teams",
+      `Poll error: ${err instanceof Error ? err.message : err}`,
+    );
+  } finally {
+    runtime.polling = false;
+  }
+}
+
+/** Initial poll, then the interval; the timer lives on the runtime so stop can clear it. */
+export async function startPolling(
+  runtime: TeamsRuntime,
+  chatId: string,
+): Promise<void> {
+  await poll(runtime, chatId);
+  runtime.pollTimer = setInterval(
+    () => void poll(runtime, chatId),
+    runtime.pollIntervalMs,
+  );
+}
+
+export function stopPolling(runtime: TeamsRuntime): void {
+  if (runtime.pollTimer) {
+    clearInterval(runtime.pollTimer);
+    runtime.pollTimer = null;
+  }
+}

package/src/frontend/teams/runtime.ts

@@ -0,0 +1,51 @@
+/**
+ * Teams frontend runtime — the state every module shares.
+ *
+ * `createTeamsFrontend` used to hold all of this as closure variables, with
+ * the poll loop and the slash commands nested inside `.start`. It is now one
+ * explicit object, constructed once, that each module (chat-discovery,
+ * poll, commands, turn, outbound) takes as its first parameter.
+ */
+
+import type { TalonConfig } from "../../util/config.js";
+import type { Gateway } from "../../core/engine/gateway.js";
+import type { GraphClient } from "./graph.js";
+
+export type TeamsRuntime = {
+  readonly config: TalonConfig;
+  readonly gateway: Gateway;
+  /** Power Automate workflow webhook URL every outbound card is POSTed to. */
+  readonly webhookUrl: string;
+  /** Display name the workflow posts under — its messages are skipped. */
+  readonly botDisplayName: string;
+  readonly pollIntervalMs: number;
+  /** Optional topic substring used to pick the chat on first run. */
+  readonly configChatTopic: string;
+  graphClient: GraphClient | null;
+  pollTimer: ReturnType<typeof setInterval> | null;
+  /** Newest message id already handled — the poll loop cuts at it. */
+  lastSeenMessageId: string | null;
+  myUserId: string | null;
+  /** Re-entrancy guard: a slow poll never overlaps the next tick. */
+  polling: boolean;
+};
+
+export function createTeamsRuntime(
+  config: TalonConfig,
+  gateway: Gateway,
+): TeamsRuntime {
+  const raw = config as Record<string, unknown>;
+  return {
+    config,
+    gateway,
+    webhookUrl: raw.teamsWebhookUrl as string,
+    botDisplayName: (raw.teamsBotDisplayName as string) || "",
+    pollIntervalMs: (raw.teamsGraphPollMs as number) || 10_000,
+    configChatTopic: (raw.teamsChatTopic as string) || "",
+    graphClient: null,
+    pollTimer: null,
+    lastSeenMessageId: null,
+    myUserId: null,
+    polling: false,
+  };
+}

package/src/frontend/teams/turn.ts

@@ -0,0 +1,97 @@
+/**
+ * Teams model turn — one inbound chat message becomes one `execute()` call.
+ * Progress is logged; assistant text is delivered through the webhook.
+ */
+
+import { log, logError } from "../../util/log.js";
+import { deriveNumericChatId } from "../../util/chat-id.js";
+import {
+  toolInputToRecord,
+  type AgentEvent,
+} from "../../core/agent-runtime/events.js";
+import { execute } from "../../core/engine/dispatcher.js";
+import { postToTeams } from "./actions.js";
+import type { ChatMessage } from "./graph.js";
+import type { TeamsRuntime } from "./runtime.js";
+
+function logToolCall(event: Extract<AgentEvent, { type: "tool_call" }>): void {
+  const input = toolInputToRecord(event.name, event.input);
+  const detail = (input.description ??
+    input.command ??
+    input.action ??
+    input.query ??
+    input.url ??
+    input.name ??
+    "") as string;
+  log(
+    "teams",
+    `  tool: ${event.name}${detail ? ` — ${String(detail).slice(0, 100)}` : ""}`,
+  );
+}
+
+// Deliver assistant text (progress text before tool calls AND the
+// end-of-turn trailing-text fallback) to the Teams chat. Without this,
+// prose-only assistant turns would be silently dropped — same scratchpad
+// bug Telegram hit.
+async function deliverAssistantText(
+  runtime: TeamsRuntime,
+  numericChatId: number,
+  text: string,
+): Promise<void> {
+  if (!text.trim()) return;
+  try {
+    await postToTeams(runtime.webhookUrl, text);
+    runtime.gateway.incrementMessages(numericChatId);
+  } catch (err) {
+    // Post failures are swallowed (logged, not rethrown) — preserves the old
+    // `onTextBlock` semantics where Teams never propagated delivery errors
+    // back to the backend. Returning normally lets the dispatcher resolve
+    // the ack.
+    logError(
+      "teams",
+      `onEvent postToTeams failed: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}
+
+export function runTurn(
+  runtime: TeamsRuntime,
+  msg: ChatMessage,
+  talonChatId: string,
+): void {
+  const numericChatId = deriveNumericChatId(msg.chatId);
+  execute({
+    chatId: talonChatId,
+    numericChatId,
+    prompt: `[${msg.senderName}]: ${msg.text}`,
+    senderName: msg.senderName,
+    isGroup: true,
+    source: "message",
+    onEvent: async (event) => {
+      switch (event.type) {
+        case "text_delta":
+          log("teams", `  phase: text`);
+          break;
+        case "reasoning":
+          log("teams", `  phase: thinking`);
+          break;
+        case "tool_call":
+          logToolCall(event);
+          break;
+        case "assistant_message":
+          await deliverAssistantText(runtime, numericChatId, event.text);
+          break;
+      }
+    },
+  })
+    // No fallback delivery — turns without end_turn / send_message are
+    // intentional silent ends. Trailing prose without a tool call is
+    // scratchpad and dropped; the SDK handler emits a
+    // `scratchpad.trailing_text_dropped` metric on those.
+    .catch((err) => {
+      logError(
+        "teams",
+        `execute failed: ${err instanceof Error ? err.message : err}`,
+      );
+    });
+}

package/src/frontend/telegram/actions/messaging.ts

@@ -14,7 +14,7 @@ import {
   listScheduledForChat,
   MAX_OVERDUE_MS,
   type ScheduledMessage,
-} from "../../../storage/scheduled-store.js";
+} from "../../../storage/scheduled.js";
 import {
   noteRichMessageFailure,
   richMessagesAvailable,

package/src/frontend/telegram/actions/shared.ts

@@ -39,7 +39,7 @@ export function replyParamsFor(
 }
 
 /** Delivery modifiers shared by every outbound send. */
-export type ExtraSendOpts = {
+export type ExtraSendOptions = {
   message_thread_id?: number;
   disable_notification?: boolean;
   protect_content?: boolean;
@@ -54,7 +54,7 @@ export type ExtraSendOpts = {
 export function sendOpts(
   body: Record<string, unknown>,
   chatId: number,
-): ExtraSendOpts {
+): ExtraSendOptions {
   return {
     message_thread_id: resolveThreadId(body, chatId),
     disable_notification: body.silent === true || undefined,
@@ -126,7 +126,7 @@ export async function sendText(
   replyMarkup?: NonNullable<
     Parameters<Bot["api"]["sendRichMessage"]>[2]
   >["reply_markup"],
-  extra?: ExtraSendOpts,
+  extra?: ExtraSendOptions,
 ): Promise<number> {
   if (text.length > TELEGRAM_MAX_TEXT) {
     throw new Error(
@@ -137,7 +137,7 @@ export async function sendText(
   // Default to the chat's ambient forum topic so every text path — commands,
   // menus, scheduled replays — stays in the topic the conversation is in.
   // An explicit `extra` (from sendOpts) already resolved this.
-  const opts: ExtraSendOpts = extra ?? {
+  const opts: ExtraSendOptions = extra ?? {
     message_thread_id: ambientThreadId(chatId),
   };
 

package/src/frontend/telegram/admin.ts

@@ -17,7 +17,7 @@ import {
   getAllCronJobs,
   describeSchedule,
   nextRunAt,
-} from "../../storage/cron-store.js";
+} from "../../storage/cron.js";
 import { getActiveCount } from "../../core/engine/dispatcher.js";
 import { getPulseStatus } from "../../core/background/pulse.js";
 import { getHealthStatus, getRecentErrors } from "../../util/watchdog.js";

package/src/frontend/telegram/sticker-library.ts

@@ -12,7 +12,7 @@
  *
  * Only the plain Bot API (`getStickerSet`) is needed — no userbot.
  * The read side (pack listing + the prompt index) lives in
- * `storage/sticker-store.ts`, shared with prompt assembly.
+ * `storage/stickers.ts`, shared with prompt assembly.
  */
 
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
@@ -23,7 +23,7 @@ import {
   listSavedPacks,
   type SavedPack,
   type SavedSticker,
-} from "../../storage/sticker-store.js";
+} from "../../storage/stickers.js";
 
 // ── Types ───────────────────────────────────────────────────────────────────
 

package/src/frontend/whatsapp/actions/account.ts

@@ -16,12 +16,9 @@
 
 import { jidNormalizedUser, type WASocket } from "baileys";
 import type { ActionResult } from "../../../core/types.js";
-import {
-  readStatusText,
-  resolveMediaUpload,
-  toUserJid,
-  tryAction,
-} from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { resolveMediaUpload } from "./media-upload.js";
+import { readStatusText, toUserJid } from "./coerce.js";
 import type { WhatsAppActionContext, WhatsAppActionHandlers } from "./types.js";
 
 /** The account's own JID, device suffix stripped. */

package/src/frontend/whatsapp/actions/chat-info.ts

@@ -7,7 +7,8 @@
  * retrieval (get_message_by_id, download_media) lives in history.ts.
  */
 
-import { readStatusText, toUserJid, tryAction } from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { readStatusText, toUserJid } from "./coerce.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 /** Render one participant the way the other frontends render members. */

package/src/frontend/whatsapp/actions/coerce.ts

@@ -0,0 +1,30 @@
+/**
+ * Shape coercion for the member-facing WhatsApp actions: model-supplied user
+ * references → JIDs, and Baileys' several `fetchStatus` result shapes → text.
+ */
+
+/**
+ * Coerce a user reference the model supplied — bare number, JID, or the
+ * numeric id from a member listing — into a WhatsApp user JID.
+ */
+export function toUserJid(value: unknown): string | null {
+  const raw = String(value ?? "").trim();
+  if (!raw) return null;
+  if (raw.includes("@")) return raw;
+  const digits = raw.replace(/[^0-9]/g, "");
+  return digits ? `${digits}@s.whatsapp.net` : null;
+}
+
+/**
+ * Pull the about text out of a `fetchStatus` result. Baileys has
+ * returned both a bare object and a one-element array across versions,
+ * and the payload itself nests `status` either as a string or as
+ * `{ status }` — accept all four shapes rather than guess one.
+ */
+export function readStatusText(result: unknown): string | undefined {
+  const entry = (Array.isArray(result) ? result[0] : result) as
+    { status?: string | { status?: string } } | undefined;
+  return typeof entry?.status === "string"
+    ? entry.status
+    : entry?.status?.status;
+}

package/src/frontend/whatsapp/actions/history.ts

@@ -19,7 +19,7 @@ import {
 } from "../../../storage/history.js";
 import { saveInboundMedia } from "../media-store.js";
 import { lookupMessage, resolveKey } from "../message-store.js";
-import { tryAction } from "./shared.js";
+import { tryAction } from "./try-action.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 function toMsgId(raw: unknown): number {

package/src/frontend/whatsapp/actions/media-upload.ts

@@ -0,0 +1,82 @@
+/**
+ * Media-source resolution for the WhatsApp send actions: workspace path or
+ * public URL → something Baileys can upload, plus the mimetype guess the
+ * document/audio paths need.
+ */
+
+import { existsSync, statSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { expandFsPath } from "../../../util/fs-path.js";
+
+/** WhatsApp's own ceiling for a media upload. */
+const MAX_MEDIA_BYTES = 64 * 1024 * 1024;
+
+/** Baileys accepts a Buffer, a stream, or `{ url }` for local paths and HTTP. */
+export type MediaUpload = { url: string };
+
+/**
+ * Resolve one media input to something Baileys can upload. Two sources:
+ * a public URL (WhatsApp's uploader fetches it) or a workspace file path
+ * (streamed from disk). `file_id` is a Telegram concept with no WhatsApp
+ * equivalent — say so instead of failing obscurely.
+ */
+export function resolveMediaUpload(
+  src: { file_path?: unknown; url?: unknown; file_id?: unknown },
+  label: string,
+): { media: MediaUpload; fileName: string } | { error: string } {
+  if (src.url) {
+    const url = String(src.url);
+    return {
+      media: { url },
+      fileName: basename(new URL(url).pathname) || "file",
+    };
+  }
+  if (src.file_id) {
+    return {
+      error:
+        `${label}: WhatsApp has no file_id — re-send by url (public) or ` +
+        `file_path (workspace file)`,
+    };
+  }
+  if (!src.file_path) {
+    return {
+      error: `${label}: provide file_path (workspace file) or url (public)`,
+    };
+  }
+  const filePath = expandFsPath(String(src.file_path));
+  if (!existsSync(filePath)) {
+    return {
+      error: `File not found: ${filePath} — check the workspace path, or send by url instead`,
+    };
+  }
+  if (statSync(filePath).size > MAX_MEDIA_BYTES) {
+    return { error: `${label}: file exceeds WhatsApp's 64MB limit` };
+  }
+  return { media: { url: filePath }, fileName: basename(filePath) };
+}
+
+/** Extension → mimetype for the document/audio paths that require one. */
+const MIME_BY_EXT: Record<string, string> = {
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".zip": "application/zip",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mp4",
+  ".ogg": "audio/ogg",
+  ".opus": "audio/ogg; codecs=opus",
+  ".wav": "audio/wav",
+};
+
+export function guessMimetype(fileName: string, fallback: string): string {
+  return MIME_BY_EXT[extname(fileName).toLowerCase()] ?? fallback;
+}

package/src/frontend/whatsapp/actions/media.ts

@@ -10,14 +10,9 @@
 
 import type { AnyMessageContent } from "baileys";
 import { toWhatsAppText } from "../formatting.js";
-import {
-  guessMimetype,
-  resolveMediaUpload,
-  resolveQuoted,
-  sendContent,
-  sendText,
-  tryAction,
-} from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { guessMimetype, resolveMediaUpload } from "./media-upload.js";
+import { resolveQuoted, sendContent, sendText } from "./send.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 /** Optional caption, translated to WhatsApp's dialect. */

package/src/frontend/whatsapp/actions/messaging.ts

@@ -13,13 +13,8 @@ import { log } from "../../../util/log.js";
 import { toWhatsAppText } from "../formatting.js";
 import { lookupMessage, resolveKey } from "../message-store.js";
 import { recordPin, listPins, forgetPin } from "../pins.js";
-import {
-  resolveQuoted,
-  sendContent,
-  sendText,
-  tryAction,
-  boundedSend,
-} from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { resolveQuoted, sendContent, sendText, boundedSend } from "./send.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 /** WhatsApp keeps a pin for 24h, 7d, or 30d — no indefinite option. */

package/src/frontend/whatsapp/actions/moderation.ts

@@ -9,7 +9,8 @@
  * rather than retrying something the platform cannot do.
  */
 
-import { toUserJid, tryAction } from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { toUserJid } from "./coerce.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 /** Ops that act on one member. */

package/src/frontend/whatsapp/actions/{shared.ts → send.ts}

@@ -1,111 +1,17 @@
 /**
- * Shared helpers for the WhatsApp action handlers: uniform error
- * capture, media-source resolution, quoted-reply resolution, and the
- * JID coercion the member-facing actions need.
+ * Outbound WhatsApp sends: quoted-reply resolution, the serialized
+ * time-bounded socket queue, and the content/text senders that remember
+ * what went out so later tool calls and history can address it.
  */
 
-import { existsSync, statSync } from "node:fs";
-import { basename, extname } from "node:path";
 import type { AnyMessageContent, WAMessage, WASocket } from "baileys";
-import { expandFsPath } from "../../../util/fs-path.js";
-import { log, logError } from "../../../util/log.js";
+import { log } from "../../../util/log.js";
 import type { ActionResult } from "../../../core/types.js";
 import { toWhatsAppChunks } from "../formatting.js";
 import { lookupMessage, rememberMessage } from "../message-store.js";
 import { pushMessage, type HistoryMessage } from "../../../storage/history.js";
 import type { WhatsAppChatInfo } from "../registry.js";
 
-/** WhatsApp's own ceiling for a media upload. */
-const MAX_MEDIA_BYTES = 64 * 1024 * 1024;
-
-/**
- * Run an action, converting a throw into a structured failure. WhatsApp
- * errors arrive as Boom objects whose message is the useful part; the
- * model gets that text so it can adapt rather than retry blindly.
- */
-export async function tryAction(
-  label: string,
-  fn: () => Promise<ActionResult>,
-): Promise<ActionResult> {
-  try {
-    return await fn();
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logError("whatsapp", `${label} failed: ${msg}`);
-    return { ok: false, error: `${label}: ${msg}` };
-  }
-}
-
-/** Baileys accepts a Buffer, a stream, or `{ url }` for local paths and HTTP. */
-export type MediaUpload = { url: string };
-
-/**
- * Resolve one media input to something Baileys can upload. Two sources:
- * a public URL (WhatsApp's uploader fetches it) or a workspace file path
- * (streamed from disk). `file_id` is a Telegram concept with no WhatsApp
- * equivalent — say so instead of failing obscurely.
- */
-export function resolveMediaUpload(
-  src: { file_path?: unknown; url?: unknown; file_id?: unknown },
-  label: string,
-): { media: MediaUpload; fileName: string } | { error: string } {
-  if (src.url) {
-    const url = String(src.url);
-    return {
-      media: { url },
-      fileName: basename(new URL(url).pathname) || "file",
-    };
-  }
-  if (src.file_id) {
-    return {
-      error:
-        `${label}: WhatsApp has no file_id — re-send by url (public) or ` +
-        `file_path (workspace file)`,
-    };
-  }
-  if (!src.file_path) {
-    return {
-      error: `${label}: provide file_path (workspace file) or url (public)`,
-    };
-  }
-  const filePath = expandFsPath(String(src.file_path));
-  if (!existsSync(filePath)) {
-    return {
-      error: `File not found: ${filePath} — check the workspace path, or send by url instead`,
-    };
-  }
-  if (statSync(filePath).size > MAX_MEDIA_BYTES) {
-    return { error: `${label}: file exceeds WhatsApp's 64MB limit` };
-  }
-  return { media: { url: filePath }, fileName: basename(filePath) };
-}
-
-/** Extension → mimetype for the document/audio paths that require one. */
-const MIME_BY_EXT: Record<string, string> = {
-  ".pdf": "application/pdf",
-  ".txt": "text/plain",
-  ".md": "text/markdown",
-  ".json": "application/json",
-  ".csv": "text/csv",
-  ".zip": "application/zip",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".mp4": "video/mp4",
-  ".mov": "video/quicktime",
-  ".mp3": "audio/mpeg",
-  ".m4a": "audio/mp4",
-  ".ogg": "audio/ogg",
-  ".opus": "audio/ogg; codecs=opus",
-  ".wav": "audio/wav",
-};
-
-export function guessMimetype(fileName: string, fallback: string): string {
-  return MIME_BY_EXT[extname(fileName).toLowerCase()] ?? fallback;
-}
-
 /**
  * Resolve a `reply_to` message id into the quoted message Baileys wants.
  * An unknown id quotes nothing rather than failing the send — the reply
@@ -292,29 +198,3 @@ export async function sendText(
   );
   return first ?? { ok: true };
 }
-
-/**
- * Coerce a user reference the model supplied — bare number, JID, or the
- * numeric id from a member listing — into a WhatsApp user JID.
- */
-export function toUserJid(value: unknown): string | null {
-  const raw = String(value ?? "").trim();
-  if (!raw) return null;
-  if (raw.includes("@")) return raw;
-  const digits = raw.replace(/[^0-9]/g, "");
-  return digits ? `${digits}@s.whatsapp.net` : null;
-}
-
-/**
- * Pull the about text out of a `fetchStatus` result. Baileys has
- * returned both a bare object and a one-element array across versions,
- * and the payload itself nests `status` either as a string or as
- * `{ status }` — accept all four shapes rather than guess one.
- */
-export function readStatusText(result: unknown): string | undefined {
-  const entry = (Array.isArray(result) ? result[0] : result) as
-    { status?: string | { status?: string } } | undefined;
-  return typeof entry?.status === "string"
-    ? entry.status
-    : entry?.status?.status;
-}