@llblab/pi-telegram 0.2.10 → 0.3.0

package/lib/status.ts

@@ -3,8 +3,7 @@
  * Builds usage, cost, and context summaries for the interactive Telegram status view
  */
 
-import type { Model } from "@mariozechner/pi-ai";
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+export type TelegramStatusQueueLane = "control" | "priority" | "default";
 
 export interface TelegramUsageStats {
   totalInput: number;
@@ -14,6 +13,417 @@ export interface TelegramUsageStats {
   totalCost: number;
 }
 
+interface TelegramUsageMessage {
+  role: string;
+  usage?: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: { total: number };
+  };
+}
+
+interface TelegramStatusSessionEntry {
+  type: string;
+  message?: TelegramUsageMessage;
+}
+
+interface TelegramContextUsage {
+  contextWindow?: number;
+  percent: number | null;
+}
+
+export interface TelegramStatusActiveModel {
+  contextWindow?: number;
+}
+
+export interface TelegramStatusContext {
+  sessionManager: { getEntries(): TelegramStatusSessionEntry[] };
+  getContextUsage(): TelegramContextUsage | undefined;
+  modelRegistry: {
+    isUsingOAuth(model: TelegramStatusActiveModel): boolean;
+  };
+}
+
+export type TelegramRuntimeEventDetailValue = string | number | boolean | null;
+
+const MAX_RECENT_TELEGRAM_RUNTIME_EVENTS = 10;
+
+export interface TelegramRuntimeEvent {
+  at: number;
+  category: string;
+  message: string;
+  details?: Record<string, TelegramRuntimeEventDetailValue>;
+}
+
+export interface TelegramRuntimeEventInput {
+  category: string;
+  error?: unknown;
+  message?: string;
+  details?: Record<string, unknown>;
+}
+
+export interface TelegramRuntimeEventRecorder {
+  record: (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ) => void;
+  getEvents: () => TelegramRuntimeEvent[];
+  clear: () => void;
+}
+
+export interface TelegramRuntimeEventRecorderOptions {
+  getBotToken: () => string | undefined;
+  maxEvents?: number;
+  now?: () => number;
+}
+
+export interface TelegramBridgeStatusLineState {
+  botUsername?: string;
+  allowedUserId?: number;
+  pollingActive: boolean;
+  lastUpdateId?: number;
+  activeSourceMessageIds?: number[];
+  pendingDispatch: boolean;
+  compactionInProgress: boolean;
+  activeToolExecutions: number;
+  pendingModelSwitch: boolean;
+  queuedItems: Array<{ queueLane: TelegramStatusQueueLane }>;
+  recentRuntimeEvents: TelegramRuntimeEvent[];
+}
+
+export interface TelegramStatusBarTheme {
+  fg: (
+    token: "accent" | "error" | "muted" | "warning" | "success",
+    text: string,
+  ) => string;
+}
+
+export interface TelegramStatusBarState {
+  hasBotToken: boolean;
+  pollingActive: boolean;
+  paired: boolean;
+  compactionInProgress: boolean;
+  processing: boolean;
+  queuedStatus: string;
+  error?: string;
+}
+
+export interface TelegramStatusRuntimeContext {
+  ui: {
+    theme: TelegramStatusBarTheme;
+    setStatus: (key: string, text: string) => void;
+  };
+}
+
+export interface TelegramStatusRuntimeDeps<
+  TContext extends TelegramStatusRuntimeContext,
+> {
+  statusKey?: string;
+  getStatusBarState: (ctx: TContext, error?: string) => TelegramStatusBarState;
+  getBridgeStatusLineState: () => TelegramBridgeStatusLineState;
+}
+
+export interface TelegramBridgeStatusConfig {
+  botToken?: string;
+  botUsername?: string;
+  allowedUserId?: number;
+  lastUpdateId?: number;
+}
+
+export interface TelegramBridgeStatusRuntimeDeps<
+  TQueueItem extends { queueLane: TelegramStatusQueueLane },
+> {
+  statusKey?: string;
+  getConfig: () => TelegramBridgeStatusConfig;
+  isPollingActive: () => boolean;
+  getActiveSourceMessageIds: () => number[] | undefined;
+  hasActiveTurn: () => boolean;
+  hasDispatchPending: () => boolean;
+  isCompactionInProgress: () => boolean;
+  getActiveToolExecutions: () => number;
+  hasPendingModelSwitch: () => boolean;
+  getQueuedItems: () => TQueueItem[];
+  formatQueuedStatus: (items: TQueueItem[]) => string;
+  getRecentRuntimeEvents: () => TelegramRuntimeEvent[];
+}
+
+export interface TelegramStatusRuntime<
+  TContext extends TelegramStatusRuntimeContext,
+> {
+  updateStatus: (ctx: TContext, error?: string) => void;
+  getStatusLines: () => string[];
+}
+
+export function redactTelegramRuntimeMessage(
+  message: string,
+  botToken: string | undefined,
+): string {
+  if (!botToken) return message;
+  return message.split(botToken).join("<redacted-token>");
+}
+
+function normalizeTelegramRuntimeEventDetails(
+  details: Record<string, unknown> | undefined,
+  botToken: string | undefined,
+): Record<string, TelegramRuntimeEventDetailValue> | undefined {
+  if (!details) return undefined;
+  const normalized: Record<string, TelegramRuntimeEventDetailValue> = {};
+  for (const [key, value] of Object.entries(details)) {
+    if (value === undefined) continue;
+    if (typeof value === "string") {
+      normalized[key] = redactTelegramRuntimeMessage(value, botToken);
+      continue;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      normalized[key] = value;
+      continue;
+    }
+    if (value === null) {
+      normalized[key] = null;
+      continue;
+    }
+    normalized[key] = redactTelegramRuntimeMessage(String(value), botToken);
+  }
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+function getTelegramRuntimeEventMessage(
+  input: TelegramRuntimeEventInput,
+): string {
+  if (input.message !== undefined) return input.message;
+  if (input.error instanceof Error) return input.error.message;
+  return String(input.error);
+}
+
+export function recordStructuredTelegramRuntimeEvent(
+  events: TelegramRuntimeEvent[],
+  input: TelegramRuntimeEventInput,
+  options: { botToken?: string; maxEvents: number; now?: number },
+): void {
+  const details = normalizeTelegramRuntimeEventDetails(
+    input.details,
+    options.botToken,
+  );
+  events.push({
+    at: options.now ?? Date.now(),
+    category: input.category,
+    message: redactTelegramRuntimeMessage(
+      getTelegramRuntimeEventMessage(input),
+      options.botToken,
+    ),
+    ...(details ? { details } : {}),
+  });
+  while (events.length > options.maxEvents) {
+    events.shift();
+  }
+}
+
+export function recordTelegramRuntimeEvent(
+  events: TelegramRuntimeEvent[],
+  category: string,
+  error: unknown,
+  options: { botToken?: string; maxEvents: number; now?: number },
+): void {
+  recordStructuredTelegramRuntimeEvent(events, { category, error }, options);
+}
+
+export function createTelegramRuntimeEventRecorder(
+  options: TelegramRuntimeEventRecorderOptions,
+): TelegramRuntimeEventRecorder {
+  const events: TelegramRuntimeEvent[] = [];
+  return {
+    record: (category, error, details) => {
+      recordStructuredTelegramRuntimeEvent(
+        events,
+        { category, error, details },
+        {
+          botToken: options.getBotToken(),
+          maxEvents: options.maxEvents ?? MAX_RECENT_TELEGRAM_RUNTIME_EVENTS,
+          now: options.now?.(),
+        },
+      );
+    },
+    getEvents: () => events,
+    clear: () => {
+      events.length = 0;
+    },
+  };
+}
+
+function formatTelegramRuntimeEventCategory(
+  event: TelegramRuntimeEvent,
+): string {
+  const method = event.details?.method;
+  return typeof method === "string"
+    ? `${event.category}:${method}`
+    : event.category;
+}
+
+function formatTelegramRuntimeEventDetails(
+  event: TelegramRuntimeEvent,
+): string {
+  if (!event.details) return "";
+  const details = Object.entries(event.details)
+    .filter(([key]) => key !== "method")
+    .map(([key, value]) => `${key}=${JSON.stringify(value)}`);
+  return details.length > 0 ? ` (${details.join(", ")})` : "";
+}
+
+function formatTelegramRuntimeEventSummary(
+  event: TelegramRuntimeEvent,
+): string {
+  return `${formatTelegramRuntimeEventCategory(event)}: ${event.message}${formatTelegramRuntimeEventDetails(event)}`;
+}
+
+function formatTelegramRuntimeEvent(event: TelegramRuntimeEvent): string {
+  return `${new Date(event.at).toISOString()} ${formatTelegramRuntimeEventSummary(event)}`;
+}
+
+export function buildTelegramRuntimeEventLines(
+  events: TelegramRuntimeEvent[],
+): string[] {
+  if (events.length === 0) return ["recent runtime events: none"];
+  return [
+    "recent runtime events:",
+    ...events
+      .slice()
+      .reverse()
+      .map((event) => `- ${formatTelegramRuntimeEvent(event)}`),
+  ];
+}
+
+export function createTelegramStatusHtmlBuilder<TContext>(deps: {
+  getActiveModel: (ctx: TContext) => TelegramStatusActiveModel | undefined;
+}): (ctx: TContext & TelegramStatusContext) => string {
+  return (ctx) => buildStatusHtml(ctx, deps.getActiveModel(ctx));
+}
+
+export function createTelegramStatusRuntime<
+  TContext extends TelegramStatusRuntimeContext,
+>(deps: TelegramStatusRuntimeDeps<TContext>): TelegramStatusRuntime<TContext> {
+  const statusKey = deps.statusKey ?? "telegram";
+  return {
+    updateStatus: (ctx, error) => {
+      ctx.ui.setStatus(
+        statusKey,
+        buildTelegramStatusBarText(
+          ctx.ui.theme,
+          deps.getStatusBarState(ctx, error),
+        ),
+      );
+    },
+    getStatusLines: () =>
+      buildTelegramBridgeStatusLines(deps.getBridgeStatusLineState()),
+  };
+}
+
+export function createTelegramBridgeStatusRuntime<
+  TContext extends TelegramStatusRuntimeContext,
+  TQueueItem extends { queueLane: TelegramStatusQueueLane },
+>(
+  deps: TelegramBridgeStatusRuntimeDeps<TQueueItem>,
+): TelegramStatusRuntime<TContext> {
+  return createTelegramStatusRuntime({
+    statusKey: deps.statusKey,
+    getStatusBarState: (_ctx, error) => {
+      const config = deps.getConfig();
+      const queuedItems = deps.getQueuedItems();
+      const compactionInProgress = deps.isCompactionInProgress();
+      return {
+        hasBotToken: !!config.botToken,
+        pollingActive: deps.isPollingActive(),
+        paired: !!config.allowedUserId,
+        compactionInProgress,
+        processing:
+          deps.hasActiveTurn() ||
+          deps.hasDispatchPending() ||
+          queuedItems.length > 0,
+        queuedStatus: deps.formatQueuedStatus(queuedItems),
+        error,
+      };
+    },
+    getBridgeStatusLineState: () => {
+      const config = deps.getConfig();
+      return {
+        botUsername: config.botUsername,
+        allowedUserId: config.allowedUserId,
+        pollingActive: deps.isPollingActive(),
+        lastUpdateId: config.lastUpdateId,
+        activeSourceMessageIds: deps.getActiveSourceMessageIds(),
+        pendingDispatch: deps.hasDispatchPending(),
+        compactionInProgress: deps.isCompactionInProgress(),
+        activeToolExecutions: deps.getActiveToolExecutions(),
+        pendingModelSwitch: deps.hasPendingModelSwitch(),
+        queuedItems: deps.getQueuedItems(),
+        recentRuntimeEvents: deps.getRecentRuntimeEvents(),
+      };
+    },
+  });
+}
+
+export function buildTelegramStatusBarText(
+  theme: TelegramStatusBarTheme,
+  state: TelegramStatusBarState,
+): string {
+  const label = theme.fg("accent", "telegram");
+  if (state.error) {
+    return `${label} ${theme.fg("error", "error")} ${theme.fg("muted", state.error)}`;
+  }
+  if (!state.hasBotToken)
+    return `${label} ${theme.fg("muted", "not configured")}`;
+  if (!state.pollingActive)
+    return `${label} ${theme.fg("muted", "disconnected")}`;
+  if (!state.paired)
+    return `${label} ${theme.fg("warning", "awaiting pairing")}`;
+  const queued = theme.fg("muted", state.queuedStatus);
+  if (state.compactionInProgress) {
+    return `${label} ${theme.fg("accent", "compacting")}${queued}`;
+  }
+  if (state.processing) {
+    return `${label} ${theme.fg("accent", "processing")}${queued}`;
+  }
+  return `${label} ${theme.fg("success", "connected")}`;
+}
+
+export function buildTelegramBridgeStatusLines(
+  state: TelegramBridgeStatusLineState,
+): string[] {
+  const controlQueueCount = state.queuedItems.filter(
+    (item) => item.queueLane === "control",
+  ).length;
+  const priorityQueueCount = state.queuedItems.filter(
+    (item) => item.queueLane === "priority",
+  ).length;
+  const defaultQueueCount = state.queuedItems.filter(
+    (item) => item.queueLane === "default",
+  ).length;
+  return [
+    "connection:",
+    `- bot: ${state.botUsername ? `@${state.botUsername}` : "not configured"}`,
+    `- allowed user: ${state.allowedUserId ?? "not paired"}`,
+    "",
+    "polling:",
+    `- state: ${state.pollingActive ? "running" : "stopped"}`,
+    `- last update id: ${state.lastUpdateId ?? "none"}`,
+    "",
+    "execution:",
+    `- active turn: ${state.activeSourceMessageIds?.join(",") || "no"}`,
+    `- pending dispatch: ${state.pendingDispatch ? "yes" : "no"}`,
+    `- compaction: ${state.compactionInProgress ? "running" : "idle"}`,
+    `- active tools: ${state.activeToolExecutions}`,
+    `- pending model switch: ${state.pendingModelSwitch ? "yes" : "no"}`,
+    "",
+    "queue:",
+    `- queued turns: ${state.queuedItems.length}`,
+    `- lanes: control=${controlQueueCount}, priority=${priorityQueueCount}, default=${defaultQueueCount}`,
+    "",
+    ...buildTelegramRuntimeEventLines(state.recentRuntimeEvents),
+  ];
+}
+
 function escapeHtml(text: string): string {
   return text
     .replace(/&/g, "&amp;")
@@ -29,7 +439,7 @@ function formatTokens(count: number): string {
   return `${Math.round(count / 1000000)}M`;
 }
 
-export function collectUsageStats(ctx: ExtensionContext): TelegramUsageStats {
+function collectUsageStats(ctx: TelegramStatusContext): TelegramUsageStats {
   const stats: TelegramUsageStats = {
     totalInput: 0,
     totalOutput: 0,
@@ -38,14 +448,19 @@ export function collectUsageStats(ctx: ExtensionContext): TelegramUsageStats {
     totalCost: 0,
   };
   for (const entry of ctx.sessionManager.getEntries()) {
-    if (entry.type !== "message" || entry.message.role !== "assistant") {
+    const usage = entry.message?.usage;
+    if (
+      entry.type !== "message" ||
+      entry.message?.role !== "assistant" ||
+      !usage
+    ) {
       continue;
     }
-    stats.totalInput += entry.message.usage.input;
-    stats.totalOutput += entry.message.usage.output;
-    stats.totalCacheRead += entry.message.usage.cacheRead;
-    stats.totalCacheWrite += entry.message.usage.cacheWrite;
-    stats.totalCost += entry.message.usage.cost.total;
+    stats.totalInput += usage.input;
+    stats.totalOutput += usage.output;
+    stats.totalCacheRead += usage.cacheRead;
+    stats.totalCacheWrite += usage.cacheWrite;
+    stats.totalCost += usage.cost.total;
   }
   return stats;
 }
@@ -74,8 +489,8 @@ function buildCostSummary(
 }
 
 function buildContextSummary(
-  ctx: ExtensionContext,
-  activeModel: Model<any> | undefined,
+  ctx: TelegramStatusContext,
+  activeModel: TelegramStatusActiveModel | undefined,
 ): string {
   const usage = ctx.getContextUsage();
   if (!usage) return "unknown";
@@ -85,8 +500,8 @@ function buildContextSummary(
 }
 
 export function buildStatusHtml(
-  ctx: ExtensionContext,
-  activeModel: Model<any> | undefined,
+  ctx: TelegramStatusContext,
+  activeModel: TelegramStatusActiveModel | undefined,
 ): string {
   const stats = collectUsageStats(ctx);
   const usesSubscription = activeModel

package/lib/turns.ts

@@ -3,27 +3,34 @@
  * Owns prompt-turn summary and content construction so queued Telegram turns are assembled consistently
  */
 
+import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
 
-import type { ImageContent, TextContent } from "@mariozechner/pi-ai";
-
 import {
   collectTelegramMessageIds,
+  type DownloadedTelegramMessageFile,
+  type DownloadTelegramMessageFilesDeps,
+  downloadTelegramMessageFiles,
+  extractTelegramMessagesText,
   formatTelegramHistoryText,
+  guessMediaType,
+  type TelegramMediaMessage,
 } from "./media.ts";
-import type { PendingTelegramTurn } from "./queue.ts";
+import type {
+  PendingTelegramTurn,
+  TelegramPromptContent,
+  TelegramQueueItem,
+  TelegramQueueStore,
+} from "./queue.ts";
+
+export const TELEGRAM_PREFIX = "[telegram]";
 
-export interface TelegramTurnMessageLike {
+export interface TelegramTurnMessage {
   message_id: number;
   chat: { id: number };
 }
 
-export interface DownloadedTelegramTurnFileLike {
-  path: string;
-  fileName: string;
-  isImage: boolean;
-  mimeType?: string;
-}
+export type DownloadedTelegramTurnFile = DownloadedTelegramMessageFile;
 
 export function truncateTelegramQueueSummary(
   text: string,
@@ -45,7 +52,7 @@ export function truncateTelegramQueueSummary(
 
 export function formatTelegramTurnStatusSummary(
   rawText: string,
-  files: DownloadedTelegramTurnFileLike[],
+  files: DownloadedTelegramTurnFile[],
 ): string {
   const textSummary = truncateTelegramQueueSummary(rawText);
   if (textSummary) return textSummary;
@@ -62,7 +69,7 @@ export function formatTelegramTurnStatusSummary(
 export function buildTelegramTurnPrompt(options: {
   telegramPrefix: string;
   rawText: string;
-  files: DownloadedTelegramTurnFileLike[];
+  files: DownloadedTelegramTurnFile[];
   historyTurns?: Pick<PendingTelegramTurn, "historyText">[];
 }): string {
   let prompt = options.telegramPrefix;
@@ -92,7 +99,7 @@ export function buildTelegramTurnPrompt(options: {
 function splitTelegramPromptAttachmentSuffix(prompt: string): {
   promptWithoutAttachments: string;
   attachmentSuffix: string;
-  attachmentFiles: DownloadedTelegramTurnFileLike[];
+  attachmentFiles: DownloadedTelegramTurnFile[];
 } {
   const marker = "\n\nTelegram attachments were saved locally:";
   const markerIndex = prompt.indexOf(marker);
@@ -117,13 +124,12 @@ function buildEditedTelegramPromptText(options: {
   existingPrompt: string;
   telegramPrefix: string;
   rawText: string;
-}): { text: string; attachmentFiles: DownloadedTelegramTurnFileLike[] } {
+}): { text: string; attachmentFiles: DownloadedTelegramTurnFile[] } {
   const { promptWithoutAttachments, attachmentSuffix, attachmentFiles } =
     splitTelegramPromptAttachmentSuffix(options.existingPrompt);
   const currentMessageMarker = "Current Telegram message:";
-  const currentMessageIndex = promptWithoutAttachments.lastIndexOf(
-    currentMessageMarker,
-  );
+  const currentMessageIndex =
+    promptWithoutAttachments.lastIndexOf(currentMessageMarker);
   if (currentMessageIndex !== -1) {
     const prefix = promptWithoutAttachments.slice(
       0,
@@ -150,7 +156,7 @@ export function updateTelegramPromptTurnText(options: {
   telegramPrefix: string;
   rawText: string;
 }): PendingTelegramTurn {
-  let attachmentFiles: DownloadedTelegramTurnFileLike[] = [];
+  let attachmentFiles: DownloadedTelegramTurnFile[] = [];
   const nextContent = options.turn.content.map((block, index) => {
     if (index !== 0 || block.type !== "text") return block;
     const updated = buildEditedTelegramPromptText({
@@ -175,21 +181,110 @@ export function updateTelegramPromptTurnText(options: {
   };
 }
 
-export async function buildTelegramPromptTurn(options: {
+export function updateQueuedTelegramPromptTurnText<
+  TContext = unknown,
+>(options: {
+  items: TelegramQueueItem<TContext>[];
+  sourceMessageId: number | undefined;
+  telegramPrefix: string;
+  rawText: string;
+}): { items: TelegramQueueItem<TContext>[]; changed: boolean } {
+  if (options.sourceMessageId === undefined) {
+    return { items: options.items, changed: false };
+  }
+  let changed = false;
+  const items = options.items.map((item) => {
+    if (
+      item.kind !== "prompt" ||
+      !item.sourceMessageIds.includes(options.sourceMessageId as number)
+    ) {
+      return item;
+    }
+    changed = true;
+    return updateTelegramPromptTurnText({
+      turn: item,
+      telegramPrefix: options.telegramPrefix,
+      rawText: options.rawText,
+    });
+  });
+  return { items, changed };
+}
+
+export interface TelegramQueuedPromptEditRuntimeDeps<
+  TContext = unknown,
+> extends TelegramQueueStore<TContext> {
+  updateStatus: (ctx: TContext) => void;
+}
+
+export function createTelegramQueuedPromptEditRuntime<
+  TMessage extends TelegramMediaMessage,
+  TContext = unknown,
+>(deps: TelegramQueuedPromptEditRuntimeDeps<TContext>) {
+  return {
+    updateFromEditedMessage: (message: TMessage, ctx: TContext): boolean => {
+      const { changed, items } = updateQueuedTelegramPromptTurnText({
+        items: deps.getQueuedItems(),
+        sourceMessageId: message.message_id,
+        telegramPrefix: TELEGRAM_PREFIX,
+        rawText: extractTelegramMessagesText([message]),
+      });
+      deps.setQueuedItems(items);
+      if (changed) deps.updateStatus(ctx);
+      return changed;
+    },
+  };
+}
+
+export interface BuildTelegramPromptTurnOptions {
   telegramPrefix: string;
-  messages: TelegramTurnMessageLike[];
+  messages: TelegramTurnMessage[];
   historyTurns?: PendingTelegramTurn[];
   queueOrder: number;
   rawText: string;
-  files: DownloadedTelegramTurnFileLike[];
+  files: DownloadedTelegramTurnFile[];
   readBinaryFile: (path: string) => Promise<Uint8Array>;
   inferImageMimeType: (path: string) => string | undefined;
-}): Promise<PendingTelegramTurn> {
+}
+
+export type BuildTelegramPromptTurnRuntimeOptions = Omit<
+  BuildTelegramPromptTurnOptions,
+  "readBinaryFile"
+>;
+
+export interface TelegramPromptTurnRuntimeBuilderDeps extends DownloadTelegramMessageFilesDeps {
+  allocateQueueOrder: () => number;
+}
+
+export function createTelegramPromptTurnRuntimeBuilder<
+  TMessage extends TelegramTurnMessage & TelegramMediaMessage,
+>(
+  deps: TelegramPromptTurnRuntimeBuilderDeps,
+): (
+  messages: TMessage[],
+  historyTurns?: PendingTelegramTurn[],
+) => Promise<PendingTelegramTurn> {
+  return async (messages, historyTurns = []) =>
+    buildTelegramPromptTurnRuntime({
+      telegramPrefix: TELEGRAM_PREFIX,
+      messages,
+      historyTurns,
+      queueOrder: deps.allocateQueueOrder(),
+      rawText: extractTelegramMessagesText(messages),
+      files: await downloadTelegramMessageFiles(messages, {
+        downloadFile: deps.downloadFile,
+      }),
+      inferImageMimeType: guessMediaType,
+    });
+}
+
+export async function buildTelegramPromptTurn(
+  options: BuildTelegramPromptTurnOptions,
+): Promise<PendingTelegramTurn> {
   const firstMessage = options.messages[0];
   if (!firstMessage) {
     throw new Error("Missing Telegram message for turn creation");
   }
-  const content: Array<TextContent | ImageContent> = [
+  const content: TelegramPromptContent[] = [
     {
       type: "text",
       text: buildTelegramTurnPrompt({
@@ -228,3 +323,12 @@ export async function buildTelegramPromptTurn(options: {
     ),
   };
 }
+
+export async function buildTelegramPromptTurnRuntime(
+  options: BuildTelegramPromptTurnRuntimeOptions,
+): Promise<PendingTelegramTurn> {
+  return buildTelegramPromptTurn({
+    ...options,
+    readBinaryFile: readFile,
+  });
+}