🤖 fix: truncate status_set messages at 60 chars instead of failing (#487)

The `status_set` tool previously validated message length at 40
characters via Zod schema, causing tool failures when agents provided
longer messages. This changes the behavior to gracefully truncate at 60
characters with an ellipsis.

**Changes:**
- Added `STATUS_MESSAGE_MAX_LENGTH` constant (60 chars) to
`toolLimits.ts`
- Removed `.max(40)` Zod validation from schema
- Added `truncateMessage()` helper that truncates to 59 chars + "…"
- Updated tests to verify truncation behavior

**Behavior:**
- Messages ≤ 60 characters: unchanged
- Messages > 60 characters: truncated to 59 chars + ellipsis

This eliminates validation errors for long status messages while
maintaining a reasonable display limit.

_Generated with `cmux`_

Author: ammar-agent

src/constants/toolLimits.ts

@@ -15,3 +15,5 @@ export const BASH_TRUNCATE_MAX_FILE_BYTES = 1024 * 1024; // 1MB file limit (same
 export const BASH_MAX_LINE_BYTES = 1024; // 1KB per line for AI agent
 
 export const MAX_TODOS = 7; // Maximum number of TODO items in a list
+
+export const STATUS_MESSAGE_MAX_LENGTH = 60; // Maximum length for status messages (auto-truncated)

src/services/tools/status_set.test.ts

@@ -3,6 +3,7 @@ import { createStatusSetTool } from "./status_set";
 import type { ToolConfiguration } from "@/utils/tools/tools";
 import { createRuntime } from "@/runtime/runtimeFactory";
 import type { ToolCallOptions } from "ai";
+import { STATUS_MESSAGE_MAX_LENGTH } from "@/constants/toolLimits";
 
 describe("status_set tool validation", () => {
   const mockConfig: ToolConfiguration = {
@@ -140,14 +141,15 @@ describe("status_set tool validation", () => {
   });
 
   describe("message validation", () => {
-    it("should accept messages up to 40 characters", async () => {
+    it(`should accept messages up to ${STATUS_MESSAGE_MAX_LENGTH} characters`, async () => {
       const tool = createStatusSetTool(mockConfig);
 
       const result1 = (await tool.execute!(
-        { emoji: "✅", message: "a".repeat(40) },
+        { emoji: "✅", message: "a".repeat(STATUS_MESSAGE_MAX_LENGTH) },
         mockToolCallOptions
-      )) as { success: boolean };
+      )) as { success: boolean; message: string };
       expect(result1.success).toBe(true);
+      expect(result1.message).toBe("a".repeat(STATUS_MESSAGE_MAX_LENGTH));
 
       const result2 = (await tool.execute!(
         { emoji: "✅", message: "Analyzing code structure" },
@@ -156,6 +158,30 @@ describe("status_set tool validation", () => {
       expect(result2.success).toBe(true);
     });
 
+    it(`should truncate messages longer than ${STATUS_MESSAGE_MAX_LENGTH} characters with ellipsis`, async () => {
+      const tool = createStatusSetTool(mockConfig);
+
+      // Test with MAX_LENGTH + 1 characters
+      const result1 = (await tool.execute!(
+        { emoji: "✅", message: "a".repeat(STATUS_MESSAGE_MAX_LENGTH + 1) },
+        mockToolCallOptions
+      )) as { success: boolean; message: string };
+      expect(result1.success).toBe(true);
+      expect(result1.message).toBe("a".repeat(STATUS_MESSAGE_MAX_LENGTH - 1) + "…");
+      expect(result1.message.length).toBe(STATUS_MESSAGE_MAX_LENGTH);
+
+      // Test with longer message
+      const longMessage =
+        "This is a very long message that exceeds the 60 character limit and should be truncated";
+      const result2 = (await tool.execute!(
+        { emoji: "✅", message: longMessage },
+        mockToolCallOptions
+      )) as { success: boolean; message: string };
+      expect(result2.success).toBe(true);
+      expect(result2.message).toBe(longMessage.slice(0, STATUS_MESSAGE_MAX_LENGTH - 1) + "…");
+      expect(result2.message.length).toBe(STATUS_MESSAGE_MAX_LENGTH);
+    });
+
     it("should accept empty message", async () => {
       const tool = createStatusSetTool(mockConfig);
 

src/services/tools/status_set.ts

@@ -1,6 +1,7 @@
 import { tool } from "ai";
 import type { ToolFactory } from "@/utils/tools/tools";
 import { TOOL_DEFINITIONS } from "@/utils/tools/toolDefinitions";
+import { STATUS_MESSAGE_MAX_LENGTH } from "@/constants/toolLimits";
 
 /**
  * Result type for status_set tool
@@ -38,6 +39,17 @@ function isValidEmoji(str: string): boolean {
   return emojiRegex.test(segments[0].segment);
 }
 
+/**
+ * Truncates a message to a maximum length, adding an ellipsis if truncated
+ */
+function truncateMessage(message: string, maxLength: number): string {
+  if (message.length <= maxLength) {
+    return message;
+  }
+  // Truncate to maxLength-1 and add ellipsis (total = maxLength)
+  return message.slice(0, maxLength - 1) + "…";
+}
+
 /**
  * Status set tool factory for AI assistant
  * Creates a tool that allows the AI to set status indicator showing current activity
@@ -62,12 +74,15 @@ export const createStatusSetTool: ToolFactory = () => {
         });
       }
 
+      // Truncate message if necessary
+      const truncatedMessage = truncateMessage(message, STATUS_MESSAGE_MAX_LENGTH);
+
       // Tool execution is a no-op on the backend
       // The status is tracked by StreamingMessageAggregator and displayed in the frontend
       return Promise.resolve({
         success: true,
         emoji,
-        message,
+        message: truncatedMessage,
       });
     },
   });

src/utils/messages/StreamingMessageAggregator.status.test.ts

@@ -494,4 +494,49 @@ describe("StreamingMessageAggregator - Agent Status", () => {
     // Status should remain undefined (failed validation)
     expect(aggregator.getAgentStatus()).toBeUndefined();
   });
+
+  it("should use truncated message from output, not original input", () => {
+    const aggregator = new StreamingMessageAggregator(new Date().toISOString());
+
+    const messageId = "msg1";
+    const toolCallId = "tool1";
+
+    // Start stream
+    aggregator.handleStreamStart({
+      type: "stream-start",
+      workspaceId: "workspace1",
+      messageId,
+      model: "test-model",
+      historySequence: 1,
+    });
+
+    // Status_set with long message (would be truncated by backend)
+    const longMessage = "a".repeat(100); // 100 chars, exceeds 60 char limit
+    const truncatedMessage = "a".repeat(59) + "…"; // What backend returns
+
+    aggregator.handleToolCallStart({
+      type: "tool-call-start",
+      workspaceId: "workspace1",
+      messageId,
+      toolCallId,
+      toolName: "status_set",
+      args: { emoji: "✅", message: longMessage },
+      tokens: 10,
+      timestamp: Date.now(),
+    });
+
+    aggregator.handleToolCallEnd({
+      type: "tool-call-end",
+      workspaceId: "workspace1",
+      messageId,
+      toolCallId,
+      toolName: "status_set",
+      result: { success: true, emoji: "✅", message: truncatedMessage },
+    });
+
+    // Should use truncated message from output, not the original input
+    const status = aggregator.getAgentStatus();
+    expect(status).toEqual({ emoji: "✅", message: truncatedMessage });
+    expect(status?.message.length).toBe(60);
+  });
 });

src/utils/messages/StreamingMessageAggregator.ts

@@ -520,9 +520,10 @@ export class StreamingMessageAggregator {
     }
 
     // Update agent status if this was a successful status_set
+    // Use output instead of input to get the truncated message
     if (toolName === "status_set" && hasSuccessResult(output)) {
-      const args = input as { emoji: string; message: string };
-      this.agentStatus = { emoji: args.emoji, message: args.message };
+      const result = output as { success: true; emoji: string; message: string };
+      this.agentStatus = { emoji: result.emoji, message: result.message };
     }
   }
 

src/utils/tools/toolDefinitions.ts

@@ -11,6 +11,7 @@ import {
   BASH_HARD_MAX_LINES,
   BASH_MAX_LINE_BYTES,
   BASH_MAX_TOTAL_BYTES,
+  STATUS_MESSAGE_MAX_LENGTH,
 } from "@/constants/toolLimits";
 
 import { zodToJsonSchema } from "zod-to-json-schema";
@@ -193,8 +194,9 @@ export const TOOL_DEFINITIONS = {
         emoji: z.string().describe("A single emoji character representing the current activity"),
         message: z
           .string()
-          .max(40)
-          .describe("A brief description of the current activity (max 40 characters)"),
+          .describe(
+            `A brief description of the current activity (auto-truncated to ${STATUS_MESSAGE_MAX_LENGTH} chars with ellipsis if needed)`
+          ),
       })
       .strict(),
   },