Merge pull request #109 from odefun/feat/chunk-long-result-messages-366539

fix: split oversized final results into indexed chunks

Author: LIU9293

packages/core/runtime.ts

@@ -25,6 +25,7 @@ import { recoverPendingRequests as recoverPendingRequestsInternal } from "@/core
 import { prepareRuntimeSession } from "@/core/runtime/session-bootstrap";
 import { runOpenRequest } from "@/core/runtime/open-request";
 import { buildMessageOptions } from "@/core/runtime/message-options";
+import { splitResultMessage } from "@/core/runtime/result-message";
 import type { OpenCodeOptions } from "@/agents";
 
 type RuntimeDeps = {
@@ -160,19 +161,34 @@ export function createCoreRuntime(deps: RuntimeDeps) {
     text: string;
   }): Promise<void> {
     const { channelId, threadId, statusTs, text } = params;
-    if (resolveStatusMessageFormat() === "aggressive") {
-      await deps.im.sendMessage(channelId, threadId, text, true);
+    const statusFormat = resolveStatusMessageFormat();
+    const finalChunks = splitResultMessage(text);
+    const singleChunk = finalChunks[0] ?? text;
+
+    if (finalChunks.length > 1) {
+      if (statusFormat !== "aggressive") {
+        await deps.im.updateMessage(channelId, statusTs, "Final result posted below in multiple messages.", false);
+      }
+
+      for (const chunk of finalChunks) {
+        await deps.im.sendMessage(channelId, threadId, chunk, true);
+      }
+      return;
+    }
+
+    if (statusFormat === "aggressive") {
+      await deps.im.sendMessage(channelId, threadId, singleChunk, true);
       return;
     }
 
     const maxEditableMessageChars = deps.im.maxEditableMessageChars;
     if (typeof maxEditableMessageChars === "number" && text.length > maxEditableMessageChars) {
-      await deps.im.updateMessage(channelId, statusTs, "_Final result posted below._", false);
-      await deps.im.sendMessage(channelId, threadId, text, true);
+      await deps.im.updateMessage(channelId, statusTs, "Final result posted below.", false);
+      await deps.im.sendMessage(channelId, threadId, singleChunk, true);
       return;
     }
 
-    await deps.im.updateMessage(channelId, statusTs, text, true);
+    await deps.im.updateMessage(channelId, statusTs, singleChunk, true);
   }
 
   async function handleUserMessageInternal(context: CoreMessageContext, text: string): Promise<void> {

packages/core/runtime/result-message.ts

@@ -0,0 +1,59 @@
+const DEFAULT_RESULT_MESSAGE_LIMIT = 3_000;
+
+function splitTextByLimit(text: string, maxChars: number): string[] {
+  const chunks: string[] = [];
+  let cursor = 0;
+
+  while (cursor < text.length) {
+    const remaining = text.length - cursor;
+    if (remaining <= maxChars) {
+      chunks.push(text.slice(cursor));
+      break;
+    }
+
+    const slice = text.slice(cursor, cursor + maxChars);
+    let splitAt = slice.lastIndexOf("\n");
+    if (splitAt <= 0) {
+      splitAt = slice.lastIndexOf(" ");
+    }
+    if (splitAt <= 0) {
+      splitAt = maxChars;
+    }
+
+    const nextChunk = text.slice(cursor, cursor + splitAt);
+    if (nextChunk.length > 0) {
+      chunks.push(nextChunk);
+    }
+
+    cursor += splitAt;
+    while (cursor < text.length && /\s/.test(text[cursor] || "")) {
+      cursor += 1;
+    }
+  }
+
+  return chunks.length > 0 ? chunks : [text];
+}
+
+export function splitResultMessage(text: string, maxChars = DEFAULT_RESULT_MESSAGE_LIMIT): string[] {
+  if (text.length <= maxChars) {
+    return [text];
+  }
+
+  let estimatedCount = 1;
+  let contentChunks: string[] = [];
+
+  while (true) {
+    const prefixLength = `(${estimatedCount}/${estimatedCount}) `.length;
+    const payloadLimit = Math.max(1, maxChars - prefixLength);
+    contentChunks = splitTextByLimit(text, payloadLimit);
+
+    if (contentChunks.length === estimatedCount) {
+      break;
+    }
+
+    estimatedCount = contentChunks.length;
+  }
+
+  const total = contentChunks.length;
+  return contentChunks.map((chunk, index) => `(${index + 1}/${total}) ${chunk}`);
+}

packages/core/test/result-message.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "bun:test";
+import { splitResultMessage } from "../runtime/result-message";
+
+describe("splitResultMessage", () => {
+  it("keeps short messages as one chunk", () => {
+    const chunks = splitResultMessage("hello", 3000);
+    expect(chunks).toEqual(["hello"]);
+  });
+
+  it("splits long messages with indexed prefixes", () => {
+    const text = "a".repeat(6200);
+    const chunks = splitResultMessage(text, 3000);
+
+    expect(chunks.length).toBeGreaterThan(1);
+    expect(chunks[0]?.startsWith("(1/")).toBe(true);
+    expect(chunks[chunks.length - 1]?.startsWith(`(${chunks.length}/${chunks.length}) `)).toBe(true);
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeLessThanOrEqual(3000);
+    }
+  });
+
+  it("prefers newline boundaries when available", () => {
+    const text = `${"a".repeat(2990)}\n${"b".repeat(2990)}`;
+    const chunks = splitResultMessage(text, 3000);
+
+    expect(chunks.length).toBe(2);
+    expect(chunks[0]?.includes("\n")).toBe(false);
+  });
+});