refactor(src): split oversized modules

src/agents/pi-embedded-runner/run/payloads.ts

@@ -0,0 +1,147 @@
+import type { AssistantMessage } from "@mariozechner/pi-ai";
+import { parseReplyDirectives } from "../../../auto-reply/reply/reply-directives.js";
+import type {
+  ReasoningLevel,
+  VerboseLevel,
+} from "../../../auto-reply/thinking.js";
+import {
+  isSilentReplyText,
+  SILENT_REPLY_TOKEN,
+} from "../../../auto-reply/tokens.js";
+import { formatToolAggregate } from "../../../auto-reply/tool-meta.js";
+import type { ClawdbotConfig } from "../../../config/config.js";
+import { formatAssistantErrorText } from "../../pi-embedded-helpers.js";
+import {
+  extractAssistantText,
+  extractAssistantThinking,
+  formatReasoningMessage,
+} from "../../pi-embedded-utils.js";
+
+type ToolMetaEntry = { toolName: string; meta?: string };
+
+export function buildEmbeddedRunPayloads(params: {
+  assistantTexts: string[];
+  toolMetas: ToolMetaEntry[];
+  lastAssistant: AssistantMessage | undefined;
+  config?: ClawdbotConfig;
+  sessionKey: string;
+  verboseLevel?: VerboseLevel;
+  reasoningLevel?: ReasoningLevel;
+  inlineToolResultsAllowed: boolean;
+}): Array<{
+  text?: string;
+  mediaUrl?: string;
+  mediaUrls?: string[];
+  replyToId?: string;
+  isError?: boolean;
+  audioAsVoice?: boolean;
+  replyToTag?: boolean;
+  replyToCurrent?: boolean;
+}> {
+  const replyItems: Array<{
+    text: string;
+    media?: string[];
+    isError?: boolean;
+    audioAsVoice?: boolean;
+    replyToId?: string;
+    replyToTag?: boolean;
+    replyToCurrent?: boolean;
+  }> = [];
+
+  const errorText = params.lastAssistant
+    ? formatAssistantErrorText(params.lastAssistant, {
+        cfg: params.config,
+        sessionKey: params.sessionKey,
+      })
+    : undefined;
+  if (errorText) replyItems.push({ text: errorText, isError: true });
+
+  const inlineToolResults =
+    params.inlineToolResultsAllowed &&
+    params.verboseLevel === "on" &&
+    params.toolMetas.length > 0;
+  if (inlineToolResults) {
+    for (const { toolName, meta } of params.toolMetas) {
+      const agg = formatToolAggregate(toolName, meta ? [meta] : []);
+      const {
+        text: cleanedText,
+        mediaUrls,
+        audioAsVoice,
+        replyToId,
+        replyToTag,
+        replyToCurrent,
+      } = parseReplyDirectives(agg);
+      if (cleanedText) {
+        replyItems.push({
+          text: cleanedText,
+          media: mediaUrls,
+          audioAsVoice,
+          replyToId,
+          replyToTag,
+          replyToCurrent,
+        });
+      }
+    }
+  }
+
+  const reasoningText =
+    params.lastAssistant && params.reasoningLevel === "on"
+      ? formatReasoningMessage(extractAssistantThinking(params.lastAssistant))
+      : "";
+  if (reasoningText) replyItems.push({ text: reasoningText });
+
+  const fallbackAnswerText = params.lastAssistant
+    ? extractAssistantText(params.lastAssistant)
+    : "";
+  const answerTexts = params.assistantTexts.length
+    ? params.assistantTexts
+    : fallbackAnswerText
+      ? [fallbackAnswerText]
+      : [];
+
+  for (const text of answerTexts) {
+    const {
+      text: cleanedText,
+      mediaUrls,
+      audioAsVoice,
+      replyToId,
+      replyToTag,
+      replyToCurrent,
+    } = parseReplyDirectives(text);
+    if (
+      !cleanedText &&
+      (!mediaUrls || mediaUrls.length === 0) &&
+      !audioAsVoice
+    ) {
+      continue;
+    }
+    replyItems.push({
+      text: cleanedText,
+      media: mediaUrls,
+      audioAsVoice,
+      replyToId,
+      replyToTag,
+      replyToCurrent,
+    });
+  }
+
+  const hasAudioAsVoiceTag = replyItems.some((item) => item.audioAsVoice);
+  return replyItems
+    .map((item) => ({
+      text: item.text?.trim() ? item.text.trim() : undefined,
+      mediaUrls: item.media?.length ? item.media : undefined,
+      mediaUrl: item.media?.[0],
+      isError: item.isError,
+      replyToId: item.replyToId,
+      replyToTag: item.replyToTag,
+      replyToCurrent: item.replyToCurrent,
+      audioAsVoice:
+        item.audioAsVoice || Boolean(hasAudioAsVoiceTag && item.media?.length),
+    }))
+    .filter((p) => {
+      if (!p.text && !p.mediaUrl && (!p.mediaUrls || p.mediaUrls.length === 0))
+        return false;
+      if (p.text && isSilentReplyText(p.text, SILENT_REPLY_TOKEN)) return false;
+      return true;
+    });
+}