Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

Cut a long Composio result or failure between characters, not through an emoji (#568)

kevin775a9e5d5b89
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9c3541db..06ba5053 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,15 @@ Newest first. `Unreleased` is what is on `main` and not yet tagged.
## Unreleased
+### A long Composio result or failure is cut between characters, not through an emoji
+
+A Composio action's answer over 20,000 characters, and a failure sentence as long, were cut by UTF-16
+code unit. When the cut landed inside an emoji or any other character outside the Basic Multilingual
+Plane, the text handed to the model ended on half of it: a lone surrogate that JSON carries as a bare
+`\ud83d` and UTF-8 turns into a replacement character. The cut now stops one unit short in that case,
+the way the MCP and built-in transports' cuts already do. Anything that fits is untouched, and the
+note saying the answer was cut reads as before.
+
## 0.0.12
### A deployment can broker its Bots into a few hundred apps through Composio
diff --git a/server/src/plugins/composio.ts b/server/src/plugins/composio.ts
index 4e40a10c..240a926f 100644
--- a/server/src/plugins/composio.ts
+++ b/server/src/plugins/composio.ts
@@ -1,3 +1,4 @@
+import { cutAtCodeUnits } from "../channels/text";
import { brokerSentence, flagOf } from "./broker";
import { type ListedTool, MAX_RESULT_CHARS, type McpCallResult } from "./mcp";
@@ -1320,7 +1321,7 @@ function listingSentence(toolkit: string, error: unknown): string {
function cap(text: string): { text: string; truncated: boolean } {
if (text.length <= MAX_RESULT_CHARS) return { text, truncated: false };
return {
- text: `${text.slice(0, MAX_RESULT_CHARS)}\n\n[truncated]`,
+ text: `${cutAtCodeUnits(text, MAX_RESULT_CHARS)}\n\n[truncated]`,
truncated: true,
};
}
diff --git a/server/tests/composio-transport.test.ts b/server/tests/composio-transport.test.ts
index 8fcbd694..9c1086a5 100644
--- a/server/tests/composio-transport.test.ts
+++ b/server/tests/composio-transport.test.ts
@@ -2377,6 +2377,59 @@ describe("calling one action", () => {
expect(result.text.length).toBe(CAPPED_LENGTH);
});
+ test("a result or a failure over the cap is cut between characters, not through an emoji", async () => {
+ /*
+ * `slice` counts UTF-16 code units and an emoji is two of them. When the cap lands between the
+ * halves, the last unit a model reads is a lone high surrogate: JSON carries it as a bare
+ * `\ud83d` and UTF-8 as U+FFFD, a broken character that was never in what Composio sent. A
+ * result and a failure go through the same cap, so both are driven to the same boundary.
+ */
+ const straddling = (lead: number) =>
+ `${"x".repeat(lead)}😀${"x".repeat(100)}`;
+ // `JSON.stringify(data, null, 2)` writes `{\n "body": "` before the string, so this puts the
+ // emoji's high surrogate on the cap's last unit.
+ const opening = '{\n "body": "'.length;
+ const answers = [
+ {
+ name: "result",
+ execute: async () =>
+ answered({ body: straddling(RESULT_CAP - opening - 1) }),
+ },
+ {
+ name: "failure",
+ execute: async () => {
+ throw new Error(straddling(RESULT_CAP - 1));
+ },
+ },
+ ];
+
+ const seen: string[] = [];
+ for (const { name, execute } of answers) {
+ useComposioClient(recording({ execute }).client);
+
+ const result = await callTool(
+ { url: "composio://gmail", actorId: "user_asker" },
+ "GMAIL_FETCH_EMAILS",
+ { __version: "20260903_00" },
+ );
+
+ const kept = result.text.endsWith(TRUNCATION_MARKER)
+ ? result.text.slice(0, -TRUNCATION_MARKER.length)
+ : result.text;
+ const last = kept.charCodeAt(kept.length - 1);
+ const lone = last >= 0xd800 && last <= 0xdbff;
+ seen.push(
+ `${name}: truncated ${result.truncated}, marked ${kept !== result.text}, kept ${kept.length}, ends on a lone surrogate ${lone}`,
+ );
+ }
+
+ // The orphan is dropped rather than completed, so the cap is never exceeded.
+ expect(seen).toEqual([
+ `result: truncated true, marked true, kept ${RESULT_CAP - 1}, ends on a lone surrogate false`,
+ `failure: truncated true, marked true, kept ${RESULT_CAP - 1}, ends on a lone surrogate false`,
+ ]);
+ });
+
test("an empty answer says so in words rather than being empty", async () => {
useComposioClient(recording({ execute: async () => answered({}) }).client);