arisa 5.1.68 → 5.2.7

package/src/transport/telegram/bot.js

@@ -1,15 +1,14 @@
 import { Bot } from "grammy";
 import { authorizeChat } from "./auth.js";
-import { captureIncomingArtifact } from "./media.js";
 import { renderTelegramHtml } from "./text-format.js";
 import { buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue } from "../../core/agent/auth-flow.js";
 import { createTelegramAuthController } from "./telegram-auth-controller.js";
-import { resolveChatSpeed } from "../../core/agent/model-selection.js";
 import { SessionSeedStore } from "../../core/conversation/session-seed-store.js";
 import { formatDoctorReport } from "../../runtime/doctor.js";
 import { ToolResourceNoteStore } from "../../core/tools/tool-resource-note-store.js";
 import { formatUpdateReport } from "../../runtime/update-manager.js";
 import { cancelRestartReceipt, deliverRestartReceipt, prepareRestartReceipt } from "../../runtime/restart-receipt.js";
+import { consumeWorkerRecoveryReport, loadWorkerRecoveryReport } from "../../runtime/worker-recovery-report.js";
 import { buildUpdatePicker, createTelegramUpdateCallbackHandler } from "./update-command.js";
 import { createTelegramModelControls } from "./model-controls.js";
 import { createTelegramModelCallbackHandler } from "./model-callback.js";
@@ -18,36 +17,10 @@ import { createTelegramSessionBridgeController } from "./telegram-session-bridge
 import { createTelegramToolsCommandHandler } from "./telegram-tools-command.js";
 import { createTelegramWorkspaceController } from "./telegram-workspace-controller.js";
 import { resolveTelegramWorkspaceRoute } from "./workspace-group.js";
-import {
-  appendGeneralReplyRoutingInstruction,
-  isGeneralWorkspaceRoute,
-  routeGeneralWorkspaceReply
-} from "./reply-topic-routing.js";
 import { migrateLegacyReplyTopics, WorkspaceTopicStore } from "./workspace-topic-store.js";
-import {
-  buildNewSessionPrompt,
-  buildPrompt,
-  buildReactionPrompt,
-  buildSessionHandoffPrompt,
-  buildStartupMessage,
-  collectText,
-  getIncomingMessageText,
-  isScheduledTaskPrompt,
-  isSilentReply,
-  normalizeIncomingArtifact,
-  sanitizeSessionHandoff,
-  scheduledPromptSpeedOptions,
-  shouldIncludeArtifactReference,
-  withPromptSpeed
-} from "./prompt-builders.js";
-import {
-  createChatStateStore,
-  createPromptExecutionReceipt,
-  drainChatPromptQueue,
-  queueChatPrompt,
-  resolveTelegramBusyMessageMode,
-  routeBusyPrompt
-} from "./chat-queue.js";
+import { buildReactionPrompt, buildStartupMessage } from "./prompt-builders.js";
+import { createChatStateStore, resolveTelegramBusyMessageMode } from "./chat-queue.js";
+import { createTelegramPromptController } from "./telegram-prompt-controller.js";
 export {
   createChatStateStore,
   drainChatPromptQueue,
@@ -268,30 +241,6 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     logger?.log("telegram", `inherited model ${inherited.model} for workspace topic session ${route.sessionId}`);
   }
 
-  async function buildIncomingPrompt(ctx, route = contextRoute(ctx)) {
-    logger?.log("telegram", `message ${ctx.msg.message_id} in chat ${route.transportChatId} session ${route.sessionId}`);
-    const chatArtifactStore = artifactStore.forChat(route.scopeChatId);
-    const artifact = await captureIncomingArtifact(ctx, artifactStore, { storageChatId: route.scopeChatId });
-    if (artifact) logger?.log("telegram", `captured artifact ${artifact.kind}${artifact.id ? ` ${artifact.id}` : ""}`);
-    const { transcript, toolResult, normalizationRequired } = await normalizeIncomingArtifact({
-      artifact,
-      toolRegistry,
-      chatArtifactStore,
-      chatId: route.scopeChatId
-    });
-    if (transcript) logger?.log("telegram", `media transcribed to artifact ${transcript.id}`);
-    if (normalizationRequired && !transcript) {
-      logger?.log("telegram", `media normalization unavailable for chat ${route.transportChatId}: ${toolResult?.error || toolResult?.missingConfig?.join(", ") || "unknown error"}`);
-    }
-    const prompt = buildPrompt({ ctx, artifact, transcript, toolResult });
-    if (!isGeneralWorkspaceRoute(route)) return prompt;
-    const [topics, recentProposals] = await Promise.all([
-      workspaceTopics.listTopics(route.ownerChatId, route.transportChatId),
-      workspaceTopics.listRecentProposals(route.ownerChatId, route.transportChatId)
-    ]);
-    return appendGeneralReplyRoutingInstruction(prompt, topics, recentProposals);
-  }
-
   const {
     createSessionBridge: createTelegramSessionBridge,
     createWorkspaceAccessGuard,
@@ -310,200 +259,30 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   });
   installArtifactDeliveryHandler();
 
-  async function processPromptForChat({ chatId, prompt, ctx = null, executionReceipt = null }) {
-    const route = ctx ? contextRoute(ctx) : {
-      workspace: false,
-      sessionId: String(chatId),
-      scopeChatId: chatId,
-      transportChatId: chatId,
-      threadId: null
-    };
-    const sessionId = route.sessionId;
-    const bridge = createTelegramSessionBridge(route);
-    const messageOptions = (extra = {}) => route.workspace && route.threadId
-      ? { ...extra, message_thread_id: route.threadId }
-      : extra;
-    const work = async () => {
-      await ensureWorkspaceTopicModelSelection(route);
-      if (route.workspace && route.threadId) {
-        const handoff = await sessionSeeds.consume(sessionId);
-        if (handoff) {
-          agentManager.resetSession(sessionId, { handoff });
-          await agentManager.waitForSessionClose(sessionId);
-        }
-      }
-      const { session, speedController } = await agentManager.getSessionContext(sessionId, bridge, {
-        scopeChatId: route.scopeChatId,
-        accessGuard: createWorkspaceAccessGuard(route)
-      });
-      let text = "";
-      const chatState = getChatState(sessionId);
-      chatState.activeSession = session;
-      chatState.activeRoute = route;
-      try {
-        text = await withPromptSpeed(scheduledPromptSpeedOptions({
-          prompt,
-          session,
-          speedController,
-          configuredSpeed: resolveChatSpeed(config, sessionId)
-        }), () => collectText(session, prompt, {
-          logger,
-          chatId: sessionId,
-          onSlowPrompt: () => bot.api.sendMessage(
-            route.transportChatId,
-            "This is taking longer than 5 minutes, so I will keep the current session running instead of starting over. Send /new if you want to abandon it and start fresh.",
-            messageOptions()
-          )
-        }));
-      } catch (error) {
-        agentManager.resetSession(sessionId);
-        if (error && typeof error === "object") {
-          error.retryable = false;
-          error.outcomeUncertain = true;
-        }
-        throw error;
-      } finally {
-        if (chatState.activeSession === session) chatState.activeSession = null;
-        chatState.activeRoute = null;
-      }
-      executionReceipt?.resolve({ status: "executed" });
-      if (text) {
-        const topics = route.workspace && route.ownerChatId
-          ? await workspaceTopics.listTopics(route.ownerChatId, route.transportChatId)
-          : [];
-        const routedReply = routeGeneralWorkspaceReply({ route, text, topics });
-        if (routedReply.proposal) {
-          await workspaceTopics.recordProposal(route.ownerChatId, route.transportChatId, routedReply.proposal);
-          logger?.log("telegram", `recorded topic proposal ${routedReply.proposal} for workspace ${route.transportChatId}`);
-        }
-        if (!routedReply.text) return;
-        const deliveryRoute = routedReply.route;
-        const deliveryOptions = (extra = {}) => deliveryRoute.workspace && deliveryRoute.threadId
-          ? { ...extra, message_thread_id: deliveryRoute.threadId }
-          : extra;
-        await createWorkspaceAccessGuard(deliveryRoute)();
-        if (routedReply.topic) {
-          logger?.log("telegram", `routing General reply to topic ${routedReply.topic.threadId} (${routedReply.topic.name})`);
-        }
-        await sendTextReply({
-          sendText: (message, extra) => bot.api.sendMessage(deliveryRoute.transportChatId, message, deliveryOptions(extra)),
-          sendDocument: (file, extra) => bot.api.sendDocument(deliveryRoute.transportChatId, file, deliveryOptions(extra)),
-          chatId: sessionId,
-          artifactChatId: deliveryRoute.scopeChatId,
-          text: routedReply.text
-        });
-      }
-    };
-
-    if (ctx) return withTyping(ctx, work);
-    return work();
-  }
-
-  async function enqueuePrompt({
-    chatId,
-    prompt,
-    label,
-    ctx = null,
-    replaceQueued = false,
-    busyMessageMode = "queue",
-    waitForExecution = false,
-    onExecutionStart = null,
-    coalesceQueued = false
-  }) {
-    const chatState = getChatState(chatId);
-    const receipt = waitForExecution ? createPromptExecutionReceipt(onExecutionStart) : null;
-
-    if (chatState.processing) {
-      const incomingRoute = ctx ? contextRoute(ctx) : null;
-      const activeRoute = chatState.activeRoute;
-      const sameDelivery = !incomingRoute || !activeRoute || (
-        incomingRoute.transportChatId === activeRoute.transportChatId
-        && incomingRoute.threadId === activeRoute.threadId
-      );
-      const routed = await routeBusyPrompt({
-        chatState,
-        prompt,
-        mode: sameDelivery ? busyMessageMode : "queue",
-        replaceQueued,
-        ctx,
-        receipt,
-        coalesceQueued
-      });
-      if (routed.disposition === "steered") {
-        logger?.log("telegram", `chat ${chatId} busy, steering ${label}`);
-      } else if (routed.disposition === "coalesced") {
-        logger?.log("telegram", `chat ${chatId} busy, coalescing ${label} into pending direct turn`);
-      } else {
-        logger?.log("telegram", `chat ${chatId} busy, queueing ${label}`);
-        if (routed.steerError) {
-          logger?.log("telegram", `steer failed for chat ${chatId}, queued instead: ${getErrorMessage(routed.steerError)}`);
-        }
-      }
-      if (replaceQueued) chatState.continueAfterClose = true;
-      return receipt ? receipt.promise : undefined;
-    }
-
-    chatState.processing = true;
-    logger?.log("telegram", `processing ${label} in chat ${chatId}`);
-    const draining = processChatPromptQueue({ chatId, prompt, label, ctx, initialReceipt: receipt });
-    if (!receipt) return draining;
-    draining.catch(() => {});
-    return receipt.promise;
-  }
-
-  function processChatPromptQueue({ chatId, prompt, label, ctx = null, beforeInitialPrompt, initialReceipt = null }) {
-    const chatState = getChatState(chatId);
-    return drainChatPromptQueue({
-      chatState,
-      initialPrompt: prompt,
-      initialCtx: ctx,
-      initialReceipt,
-      beforeInitialPrompt,
-      processPrompt: ({ prompt: currentPrompt, ctx: currentCtx, receipt }) => {
-        logger?.log("telegram", `prompt dispatch for chat ${chatId}`);
-        return processPromptForChat({ chatId, prompt: currentPrompt, ctx: currentCtx, executionReceipt: receipt });
-      },
-      onPromptInterrupted: (error) => {
-        logger?.log("telegram", `${label} interrupted by queued /new for chat ${chatId}: ${getErrorMessage(error)}`);
-      },
-      onPromptFailure: async (error) => {
-        const message = getErrorMessage(error);
-        logger?.error("telegram", `${label} failed for chat ${chatId}: ${message}`);
-        await authController.notifyIssueIfNeeded(chatId, error);
-      }
-    });
-  }
-
-  async function enqueueOrProcess(ctx) {
-    const route = contextRoute(ctx);
-    const chatState = getChatState(route.sessionId);
-
-    if (chatState.processing) {
-      await ensureQueuedTelegramTyping(chatState, ctx);
-      const incomingPrompt = await buildIncomingPrompt(ctx, route);
-      const busyMessageMode = resolveIncomingBusyMessageMode({
-        config,
-        route,
-        message: ctx.message
-      });
-      return enqueuePrompt({
-        chatId: route.sessionId,
-        prompt: incomingPrompt,
-        label: `message ${ctx.msg.message_id}`,
-        busyMessageMode,
-        coalesceQueued: busyMessageMode === "steer" && typeof ctx.message?.text === "string",
-        ctx
-      });
-    }
-
-    const incomingPrompt = await buildIncomingPrompt(ctx, route);
-    return enqueuePrompt({
-      chatId: route.sessionId,
-      prompt: incomingPrompt,
-      label: `message ${ctx.msg.message_id}`,
-      ctx
-    });
-  }
+  const {
+    enqueueOrProcess,
+    enqueuePrompt,
+    handleNewCommand
+  } = createTelegramPromptController({
+    config,
+    api: bot.api,
+    artifactStore,
+    toolRegistry,
+    agentManager,
+    sessionSeeds,
+    workspaceTopics,
+    logger,
+    contextRoute,
+    getChatState,
+    createTelegramSessionBridge,
+    createWorkspaceAccessGuard,
+    sendTextReply,
+    authController,
+    ensureWorkspaceTopicModelSelection,
+    ensureQueuedTyping: ensureQueuedTelegramTyping,
+    withTyping,
+    resolveBusyMessageMode: resolveIncomingBusyMessageMode
+  });
 
   async function migrateConfiguredReplyTopics() {
     const migratedGroups = await migrateLegacyReplyTopics(config, workspaceTopics);
@@ -513,15 +292,28 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   }
 
   async function sendStartupMessages() {
+    let recovery = null;
+    try {
+      recovery = await loadWorkerRecoveryReport();
+    } catch (error) {
+      logger?.log("telegram", `worker recovery report load failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let recoveryDelivered = false;
     for (const chatId of config.telegram.authorizedChatIds || []) {
       try {
         logger?.log("telegram", `sending startup message for chat ${chatId}`);
         const chatMeta = config.telegram.chatMeta[chatId] || {};
-        await bot.api.sendMessage(chatId, buildStartupMessage(chatMeta));
+        await bot.api.sendMessage(chatId, recovery?.text || buildStartupMessage(chatMeta));
+        if (recovery) recoveryDelivered = true;
       } catch (error) {
         logger?.log("telegram", `startup message failed for chat ${chatId}: ${error instanceof Error ? error.message : String(error)}`);
       }
     }
+    if (recovery && recoveryDelivered) {
+      await consumeWorkerRecoveryReport(recovery.report.id).catch((error) => {
+        logger?.log("telegram", `worker recovery report cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    }
     try {
       const result = await deliverRestartReceipt((chatId, text, options) => bot.api.sendMessage(chatId, text, options));
       if (result) logger?.log("telegram", `delivered restart receipt ${result.receipt.id}`);
@@ -600,76 +392,6 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     logger
   });
 
-  async function summarizeSessionBeforeReset(chatId, route = {
-    workspace: false,
-    sessionId: String(chatId),
-    scopeChatId: chatId,
-    transportChatId: chatId,
-    threadId: null
-  }) {
-    try {
-      const context = await agentManager.getSessionContext(chatId, createTelegramSessionBridge(route), {
-        scopeChatId: route.scopeChatId,
-        accessGuard: createWorkspaceAccessGuard(route)
-      });
-      const parentSession = context.session.sessionFile || "";
-      if (!context.session.messages.length) return { handoff: "", parentSession: "" };
-
-      const summary = await collectText(context.session, buildSessionHandoffPrompt(), { logger, chatId });
-      return { handoff: sanitizeSessionHandoff(summary), parentSession };
-    } catch (error) {
-      logger?.log("agent", `session handoff summary failed for chat ${chatId}: ${getErrorMessage(error)}`);
-      return { handoff: "", parentSession: "" };
-    }
-  }
-
-  async function handleNewCommand(ctx) {
-    const route = contextRoute(ctx);
-    const sessionId = route.sessionId;
-    const chatState = getChatState(sessionId);
-    const wasProcessing = chatState.processing;
-    chatState.historyRevision += 1;
-    const commandRevision = chatState.historyRevision;
-    const prompt = buildNewSessionPrompt(ctx);
-
-    if (wasProcessing) {
-      logger?.log("telegram", `chat ${sessionId} busy, queueing new-session command`);
-      queueChatPrompt(chatState, prompt, { replace: true, ctx });
-      chatState.continueAfterClose = true;
-      const reset = (async () => {
-        await sessionSeeds.clear(sessionId);
-        agentManager.resetSession(sessionId);
-      })();
-      chatState.beforeNextPrompt = reset;
-      try {
-        await reset;
-      } finally {
-        if (chatState.beforeNextPrompt === reset) chatState.beforeNextPrompt = null;
-      }
-      return;
-    }
-
-    chatState.processing = true;
-    logger?.log("telegram", `processing new-session command in chat ${sessionId}`);
-    await processChatPromptQueue({
-      chatId: sessionId,
-      prompt,
-      label: "new-session command",
-      ctx,
-      beforeInitialPrompt: async () => {
-        const handoff = await withTyping(ctx, () => summarizeSessionBeforeReset(sessionId, route));
-        if (chatState.historyRevision !== commandRevision) return;
-        if (route.workspace && route.threadId) {
-          await sessionSeeds.set(sessionId, handoff.handoff);
-        } else {
-          await sessionSeeds.clear(sessionId);
-        }
-        if (chatState.historyRevision !== commandRevision) return;
-        agentManager.resetSession(sessionId, handoff);
-      }
-    });
-  }
-
   bot.catch((error) => {
     logger?.error("telegram", `bot error: ${error instanceof Error ? error.message : String(error)}`);
     console.error("Telegram bot error:", error);

package/src/transport/telegram/prompt-builders.js

@@ -4,12 +4,15 @@ import { clampModelSpeed } from "../../core/agent/model-speed.js";
 
 const slowPromptNoticeMs = 300_000;
 
-function quotedMessageSummary(message) {
+function quotedMessageSummary(incomingMessage) {
+  const message = incomingMessage?.reply_to_message;
   if (!message) return [];
 
   const fromName = message.from?.username
     ? `@${message.from.username}`
     : [message.from?.first_name, message.from?.last_name].filter(Boolean).join(" ") || "unknown";
+  const quotedSelection = incomingMessage.quote?.text;
+  const quotedTopicName = message.forum_topic_created?.name;
 
   const parts = [
     `quotedMessageId: ${message.message_id}`,
@@ -18,6 +21,7 @@ function quotedMessageSummary(message) {
 
   if (message.text) parts.push(`quotedText: ${message.text}`);
   if (message.caption) parts.push(`quotedCaption: ${message.caption}`);
+  if (quotedSelection) parts.push(`quotedSelection: ${quotedSelection}`);
   if (message.voice) parts.push(`quotedKind: voice`);
   if (message.audio) parts.push(`quotedKind: audio`);
   if (message.photo?.length) parts.push(`quotedKind: image`);
@@ -25,8 +29,9 @@ function quotedMessageSummary(message) {
   if (message.video) parts.push(`quotedKind: video`);
   if (message.sticker) parts.push(`quotedKind: sticker`);
   if (message.location) parts.push(`quotedKind: location`, `quotedLocation: ${formatLocationText(message)}`);
+  if (message.forum_topic_created) parts.push(`quotedKind: forum_topic_created`, `quotedTopicName: ${quotedTopicName || "unknown"}`);
 
-  if (!message.text && !message.caption) {
+  if (!message.text && !message.caption && !quotedSelection && !quotedTopicName) {
     parts.push(`Important: this message replies to a Telegram message with no textual body available in the update. Use the quoted kind and metadata as context.`);
   }
 
@@ -126,7 +131,7 @@ export function buildPrompt({ ctx, artifact, transcript, toolResult }) {
   const messageText = getIncomingMessageText(ctx.message);
   if (messageText) parts.push(`text: ${messageText}`);
   parts.push(...forwardedMessageSummary(ctx.message));
-  parts.push(...quotedMessageSummary(ctx.message?.reply_to_message));
+  parts.push(...quotedMessageSummary(ctx.message));
   if (shouldIncludeArtifactReference({ artifact, messageText })) {
     if (artifact?.path) parts.push(`artifactPath: ${artifact.path}`);
     if (artifact?.id) parts.push(`artifactId: ${artifact.id}`);