openclaw-multi-auto 1.3.6 → 1.3.8

package/ui/src/ui/chat/message-normalizer.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  normalizeMessage,
+  normalizeRoleForGrouping,
+  isToolResultMessage,
+} from "./message-normalizer.ts";
+
+describe("message-normalizer", () => {
+  describe("normalizeMessage", () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date("2024-01-01T00:00:00Z"));
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it("normalizes message with string content", () => {
+      const result = normalizeMessage({
+        role: "user",
+        content: "Hello world",
+        timestamp: 1000,
+        id: "msg-1",
+      });
+
+      expect(result).toEqual({
+        role: "user",
+        content: [{ type: "text", text: "Hello world" }],
+        timestamp: 1000,
+        id: "msg-1",
+      });
+    });
+
+    it("normalizes message with array content", () => {
+      const result = normalizeMessage({
+        role: "assistant",
+        content: [
+          { type: "text", text: "Here is the result" },
+          { type: "tool_use", name: "bash", args: { command: "ls" } },
+        ],
+        timestamp: 2000,
+      });
+
+      expect(result.role).toBe("assistant");
+      expect(result.content).toHaveLength(2);
+      expect(result.content[0]).toEqual({
+        type: "text",
+        text: "Here is the result",
+        name: undefined,
+        args: undefined,
+      });
+      expect(result.content[1]).toEqual({
+        type: "tool_use",
+        text: undefined,
+        name: "bash",
+        args: { command: "ls" },
+      });
+    });
+
+    it("normalizes message with text field (alternative format)", () => {
+      const result = normalizeMessage({
+        role: "user",
+        text: "Alternative format",
+      });
+
+      expect(result.content).toEqual([{ type: "text", text: "Alternative format" }]);
+    });
+
+    it("detects tool result by toolCallId", () => {
+      const result = normalizeMessage({
+        role: "assistant",
+        toolCallId: "call-123",
+        content: "Tool output",
+      });
+
+      expect(result.role).toBe("toolResult");
+    });
+
+    it("detects tool result by tool_call_id (snake_case)", () => {
+      const result = normalizeMessage({
+        role: "assistant",
+        tool_call_id: "call-456",
+        content: "Tool output",
+      });
+
+      expect(result.role).toBe("toolResult");
+    });
+
+    it("handles missing role", () => {
+      const result = normalizeMessage({ content: "No role" });
+      expect(result.role).toBe("unknown");
+    });
+
+    it("handles missing content", () => {
+      const result = normalizeMessage({ role: "user" });
+      expect(result.content).toEqual([]);
+    });
+
+    it("uses current timestamp when not provided", () => {
+      const result = normalizeMessage({ role: "user", content: "Test" });
+      expect(result.timestamp).toBe(Date.now());
+    });
+
+    it("handles arguments field (alternative to args)", () => {
+      const result = normalizeMessage({
+        role: "assistant",
+        content: [{ type: "tool_use", name: "test", arguments: { foo: "bar" } }],
+      });
+
+      expect(result.content[0].args).toEqual({ foo: "bar" });
+    });
+  });
+
+  describe("normalizeRoleForGrouping", () => {
+    it("returns tool for toolresult", () => {
+      expect(normalizeRoleForGrouping("toolresult")).toBe("tool");
+      expect(normalizeRoleForGrouping("toolResult")).toBe("tool");
+      expect(normalizeRoleForGrouping("TOOLRESULT")).toBe("tool");
+    });
+
+    it("returns tool for tool_result", () => {
+      expect(normalizeRoleForGrouping("tool_result")).toBe("tool");
+      expect(normalizeRoleForGrouping("TOOL_RESULT")).toBe("tool");
+    });
+
+    it("returns tool for tool", () => {
+      expect(normalizeRoleForGrouping("tool")).toBe("tool");
+      expect(normalizeRoleForGrouping("Tool")).toBe("tool");
+    });
+
+    it("returns tool for function", () => {
+      expect(normalizeRoleForGrouping("function")).toBe("tool");
+      expect(normalizeRoleForGrouping("Function")).toBe("tool");
+    });
+
+    it("preserves user role", () => {
+      expect(normalizeRoleForGrouping("user")).toBe("user");
+      expect(normalizeRoleForGrouping("User")).toBe("User");
+    });
+
+    it("preserves assistant role", () => {
+      expect(normalizeRoleForGrouping("assistant")).toBe("assistant");
+    });
+
+    it("preserves system role", () => {
+      expect(normalizeRoleForGrouping("system")).toBe("system");
+    });
+  });
+
+  describe("isToolResultMessage", () => {
+    it("returns true for toolresult role", () => {
+      expect(isToolResultMessage({ role: "toolresult" })).toBe(true);
+      expect(isToolResultMessage({ role: "toolResult" })).toBe(true);
+      expect(isToolResultMessage({ role: "TOOLRESULT" })).toBe(true);
+    });
+
+    it("returns true for tool_result role", () => {
+      expect(isToolResultMessage({ role: "tool_result" })).toBe(true);
+      expect(isToolResultMessage({ role: "TOOL_RESULT" })).toBe(true);
+    });
+
+    it("returns false for other roles", () => {
+      expect(isToolResultMessage({ role: "user" })).toBe(false);
+      expect(isToolResultMessage({ role: "assistant" })).toBe(false);
+      expect(isToolResultMessage({ role: "tool" })).toBe(false);
+    });
+
+    it("returns false for missing role", () => {
+      expect(isToolResultMessage({})).toBe(false);
+      expect(isToolResultMessage({ content: "test" })).toBe(false);
+    });
+
+    it("returns false for non-string role", () => {
+      expect(isToolResultMessage({ role: 123 })).toBe(false);
+      expect(isToolResultMessage({ role: null })).toBe(false);
+    });
+  });
+});

package/ui/src/ui/chat/message-normalizer.ts

@@ -0,0 +1,101 @@
+/**
+ * Message normalization utilities for chat rendering.
+ */
+
+import { stripInboundMetadata } from "../../../../src/auto-reply/reply/strip-inbound-meta.js";
+import type { NormalizedMessage, MessageContentItem } from "../types/chat-types.ts";
+
+/**
+ * Normalize a raw message object into a consistent structure.
+ */
+export function normalizeMessage(message: unknown): NormalizedMessage {
+  const m = message as Record<string, unknown>;
+  let role = typeof m.role === "string" ? m.role : "unknown";
+
+  // Detect tool messages by common gateway shapes.
+  // Some tool events come through as assistant role with tool_* items in the content array.
+  const hasToolId = typeof m.toolCallId === "string" || typeof m.tool_call_id === "string";
+
+  const contentRaw = m.content;
+  const contentItems = Array.isArray(contentRaw) ? contentRaw : null;
+  const hasToolContent =
+    Array.isArray(contentItems) &&
+    contentItems.some((item) => {
+      const x = item as Record<string, unknown>;
+      const t = (typeof x.type === "string" ? x.type : "").toLowerCase();
+      return t === "toolresult" || t === "tool_result";
+    });
+
+  const hasToolName = typeof m.toolName === "string" || typeof m.tool_name === "string";
+
+  if (hasToolId || hasToolContent || hasToolName) {
+    role = "toolResult";
+  }
+
+  // Extract content
+  let content: MessageContentItem[] = [];
+
+  if (typeof m.content === "string") {
+    content = [{ type: "text", text: m.content }];
+  } else if (Array.isArray(m.content)) {
+    content = m.content.map((item: Record<string, unknown>) => ({
+      type: (item.type as MessageContentItem["type"]) || "text",
+      text: item.text as string | undefined,
+      name: item.name as string | undefined,
+      args: item.args || item.arguments,
+    }));
+  } else if (typeof m.text === "string") {
+    content = [{ type: "text", text: m.text }];
+  }
+
+  const timestamp = typeof m.timestamp === "number" ? m.timestamp : Date.now();
+  const id = typeof m.id === "string" ? m.id : undefined;
+
+  // Strip AI-injected metadata prefix blocks from user messages before display.
+  if (role === "user" || role === "User") {
+    content = content.map((item) => {
+      if (item.type === "text" && typeof item.text === "string") {
+        return { ...item, text: stripInboundMetadata(item.text) };
+      }
+      return item;
+    });
+  }
+
+  return { role, content, timestamp, id };
+}
+
+/**
+ * Normalize role for grouping purposes.
+ */
+export function normalizeRoleForGrouping(role: string): string {
+  const lower = role.toLowerCase();
+  // Preserve original casing when it's already a core role.
+  if (role === "user" || role === "User") {
+    return role;
+  }
+  if (role === "assistant") {
+    return "assistant";
+  }
+  if (role === "system") {
+    return "system";
+  }
+  // Keep tool-related roles distinct so the UI can style/toggle them.
+  if (
+    lower === "toolresult" ||
+    lower === "tool_result" ||
+    lower === "tool" ||
+    lower === "function"
+  ) {
+    return "tool";
+  }
+  return role;
+}
+
+/**
+ * Check if a message is a tool result message based on its role.
+ */
+export function isToolResultMessage(message: unknown): boolean {
+  const m = message as Record<string, unknown>;
+  const role = typeof m.role === "string" ? m.role.toLowerCase() : "";
+  return role === "toolresult" || role === "tool_result";
+}

package/ui/src/ui/chat/tool-cards.ts

@@ -0,0 +1,156 @@
+import { html, nothing } from "lit";
+import { icons } from "../icons.ts";
+import { formatToolDetail, resolveToolDisplay } from "../tool-display.ts";
+import type { ToolCard } from "../types/chat-types.ts";
+import { TOOL_INLINE_THRESHOLD } from "./constants.ts";
+import { extractTextCached } from "./message-extract.ts";
+import { isToolResultMessage } from "./message-normalizer.ts";
+import { formatToolOutputForSidebar, getTruncatedPreview } from "./tool-helpers.ts";
+
+export function extractToolCards(message: unknown): ToolCard[] {
+  const m = message as Record<string, unknown>;
+  const content = normalizeContent(m.content);
+  const cards: ToolCard[] = [];
+
+  for (const item of content) {
+    const kind = (typeof item.type === "string" ? item.type : "").toLowerCase();
+    const isToolCall =
+      ["toolcall", "tool_call", "tooluse", "tool_use"].includes(kind) ||
+      (typeof item.name === "string" && item.arguments != null);
+    if (isToolCall) {
+      cards.push({
+        kind: "call",
+        name: (item.name as string) ?? "tool",
+        args: coerceArgs(item.arguments ?? item.args),
+      });
+    }
+  }
+
+  for (const item of content) {
+    const kind = (typeof item.type === "string" ? item.type : "").toLowerCase();
+    if (kind !== "toolresult" && kind !== "tool_result") {
+      continue;
+    }
+    const text = extractToolText(item);
+    const name = typeof item.name === "string" ? item.name : "tool";
+    cards.push({ kind: "result", name, text });
+  }
+
+  if (isToolResultMessage(message) && !cards.some((card) => card.kind === "result")) {
+    const name =
+      (typeof m.toolName === "string" && m.toolName) ||
+      (typeof m.tool_name === "string" && m.tool_name) ||
+      "tool";
+    const text = extractTextCached(message) ?? undefined;
+    cards.push({ kind: "result", name, text });
+  }
+
+  return cards;
+}
+
+export function renderToolCardSidebar(card: ToolCard, onOpenSidebar?: (content: string) => void) {
+  const display = resolveToolDisplay({ name: card.name, args: card.args });
+  const detail = formatToolDetail(display);
+  const hasText = Boolean(card.text?.trim());
+
+  const canClick = Boolean(onOpenSidebar);
+  const handleClick = canClick
+    ? () => {
+        if (hasText) {
+          onOpenSidebar!(formatToolOutputForSidebar(card.text!));
+          return;
+        }
+        const info = `## ${display.label}\n\n${
+          detail ? `**Command:** \`${detail}\`\n\n` : ""
+        }*No output — tool completed successfully.*`;
+        onOpenSidebar!(info);
+      }
+    : undefined;
+
+  const isShort = hasText && (card.text?.length ?? 0) <= TOOL_INLINE_THRESHOLD;
+  const showCollapsed = hasText && !isShort;
+  const showInline = hasText && isShort;
+  const isEmpty = !hasText;
+
+  return html`
+    <div
+      class="chat-tool-card ${canClick ? "chat-tool-card--clickable" : ""}"
+      @click=${handleClick}
+      role=${canClick ? "button" : nothing}
+      tabindex=${canClick ? "0" : nothing}
+      @keydown=${
+        canClick
+          ? (e: KeyboardEvent) => {
+              if (e.key !== "Enter" && e.key !== " ") {
+                return;
+              }
+              e.preventDefault();
+              handleClick?.();
+            }
+          : nothing
+      }
+    >
+      <div class="chat-tool-card__header">
+        <div class="chat-tool-card__title">
+          <span class="chat-tool-card__icon">${icons[display.icon]}</span>
+          <span>${display.label}</span>
+        </div>
+        ${
+          canClick
+            ? html`<span class="chat-tool-card__action">${hasText ? "View" : ""} ${icons.check}</span>`
+            : nothing
+        }
+        ${isEmpty && !canClick ? html`<span class="chat-tool-card__status">${icons.check}</span>` : nothing}
+      </div>
+      ${detail ? html`<div class="chat-tool-card__detail">${detail}</div>` : nothing}
+      ${
+        isEmpty
+          ? html`
+              <div class="chat-tool-card__status-text muted">Completed</div>
+            `
+          : nothing
+      }
+      ${
+        showCollapsed
+          ? html`<div class="chat-tool-card__preview mono">${getTruncatedPreview(card.text!)}</div>`
+          : nothing
+      }
+      ${showInline ? html`<div class="chat-tool-card__inline mono">${card.text}</div>` : nothing}
+    </div>
+  `;
+}
+
+function normalizeContent(content: unknown): Array<Record<string, unknown>> {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.filter(Boolean) as Array<Record<string, unknown>>;
+}
+
+function coerceArgs(value: unknown): unknown {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return value;
+  }
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    return value;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+
+function extractToolText(item: Record<string, unknown>): string | undefined {
+  if (typeof item.text === "string") {
+    return item.text;
+  }
+  if (typeof item.content === "string") {
+    return item.content;
+  }
+  return undefined;
+}

package/ui/src/ui/chat/tool-helpers.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect } from "vitest";
+import { formatToolOutputForSidebar, getTruncatedPreview } from "./tool-helpers.ts";
+
+describe("tool-helpers", () => {
+  describe("formatToolOutputForSidebar", () => {
+    it("formats valid JSON object as code block", () => {
+      const input = '{"name":"test","value":123}';
+      const result = formatToolOutputForSidebar(input);
+
+      expect(result).toBe(`\`\`\`json
+{
+  "name": "test",
+  "value": 123
+}
+\`\`\``);
+    });
+
+    it("formats valid JSON array as code block", () => {
+      const input = "[1, 2, 3]";
+      const result = formatToolOutputForSidebar(input);
+
+      expect(result).toBe(`\`\`\`json
+[
+  1,
+  2,
+  3
+]
+\`\`\``);
+    });
+
+    it("handles nested JSON objects", () => {
+      const input = '{"outer":{"inner":"value"}}';
+      const result = formatToolOutputForSidebar(input);
+
+      expect(result).toContain("```json");
+      expect(result).toContain('"outer"');
+      expect(result).toContain('"inner"');
+    });
+
+    it("returns plain text for non-JSON content", () => {
+      const input = "This is plain text output";
+      const result = formatToolOutputForSidebar(input);
+
+      expect(result).toBe("This is plain text output");
+    });
+
+    it("returns as-is for invalid JSON starting with {", () => {
+      const input = "{not valid json";
+      const result = formatToolOutputForSidebar(input);
+
+      expect(result).toBe("{not valid json");
+    });
+
+    it("returns as-is for invalid JSON starting with [", () => {
+      const input = "[not valid json";
+      const result = formatToolOutputForSidebar(input);
+
+      expect(result).toBe("[not valid json");
+    });
+
+    it("trims whitespace before detecting JSON", () => {
+      const input = '   {"trimmed": true}   ';
+      const result = formatToolOutputForSidebar(input);
+
+      expect(result).toContain("```json");
+      expect(result).toContain('"trimmed"');
+    });
+
+    it("handles empty string", () => {
+      const result = formatToolOutputForSidebar("");
+      expect(result).toBe("");
+    });
+
+    it("handles whitespace-only string", () => {
+      const result = formatToolOutputForSidebar("   ");
+      expect(result).toBe("   ");
+    });
+  });
+
+  describe("getTruncatedPreview", () => {
+    it("returns short text unchanged", () => {
+      const input = "Short text";
+      const result = getTruncatedPreview(input);
+
+      expect(result).toBe("Short text");
+    });
+
+    it("truncates text longer than max chars", () => {
+      const input = "a".repeat(150);
+      const result = getTruncatedPreview(input);
+
+      expect(result.length).toBe(101); // 100 chars + ellipsis
+      expect(result.endsWith("…")).toBe(true);
+    });
+
+    it("truncates to max lines", () => {
+      const input = "Line 1\nLine 2\nLine 3\nLine 4\nLine 5";
+      const result = getTruncatedPreview(input);
+
+      // Should only show first 2 lines (PREVIEW_MAX_LINES = 2)
+      expect(result).toBe("Line 1\nLine 2…");
+    });
+
+    it("adds ellipsis when lines are truncated", () => {
+      const input = "Line 1\nLine 2\nLine 3";
+      const result = getTruncatedPreview(input);
+
+      expect(result.endsWith("…")).toBe(true);
+    });
+
+    it("does not add ellipsis when all lines fit", () => {
+      const input = "Line 1\nLine 2";
+      const result = getTruncatedPreview(input);
+
+      expect(result).toBe("Line 1\nLine 2");
+      expect(result.endsWith("…")).toBe(false);
+    });
+
+    it("handles single line within limits", () => {
+      const input = "Single line";
+      const result = getTruncatedPreview(input);
+
+      expect(result).toBe("Single line");
+    });
+
+    it("handles empty string", () => {
+      const result = getTruncatedPreview("");
+      expect(result).toBe("");
+    });
+
+    it("truncates by chars even within line limit", () => {
+      // Two lines but very long content
+      const longLine = "x".repeat(80);
+      const input = `${longLine}\n${longLine}`;
+      const result = getTruncatedPreview(input);
+
+      expect(result.length).toBe(101); // 100 + ellipsis
+      expect(result.endsWith("…")).toBe(true);
+    });
+  });
+});

package/ui/src/ui/chat/tool-helpers.ts

@@ -0,0 +1,37 @@
+/**
+ * Helper functions for tool card rendering.
+ */
+
+import { PREVIEW_MAX_CHARS, PREVIEW_MAX_LINES } from "./constants.ts";
+
+/**
+ * Format tool output content for display in the sidebar.
+ * Detects JSON and wraps it in a code block with formatting.
+ */
+export function formatToolOutputForSidebar(text: string): string {
+  const trimmed = text.trim();
+  // Try to detect and format JSON
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return "```json\n" + JSON.stringify(parsed, null, 2) + "\n```";
+    } catch {
+      // Not valid JSON, return as-is
+    }
+  }
+  return text;
+}
+
+/**
+ * Get a truncated preview of tool output text.
+ * Truncates to first N lines or first N characters, whichever is shorter.
+ */
+export function getTruncatedPreview(text: string): string {
+  const allLines = text.split("\n");
+  const lines = allLines.slice(0, PREVIEW_MAX_LINES);
+  const preview = lines.join("\n");
+  if (preview.length > PREVIEW_MAX_CHARS) {
+    return preview.slice(0, PREVIEW_MAX_CHARS) + "…";
+  }
+  return lines.length < allLines.length ? preview + "…" : preview;
+}

package/ui/src/ui/chat-event-reload.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { shouldReloadHistoryForFinalEvent } from "./chat-event-reload.ts";
+
+describe("shouldReloadHistoryForFinalEvent", () => {
+  it("returns false for non-final events", () => {
+    expect(
+      shouldReloadHistoryForFinalEvent({
+        runId: "run-1",
+        sessionKey: "main",
+        state: "delta",
+        message: { role: "assistant", content: [{ type: "text", text: "x" }] },
+      }),
+    ).toBe(false);
+  });
+
+  it("returns true when final event has no message payload", () => {
+    expect(
+      shouldReloadHistoryForFinalEvent({
+        runId: "run-1",
+        sessionKey: "main",
+        state: "final",
+      }),
+    ).toBe(true);
+  });
+
+  it("returns false when final event includes assistant payload", () => {
+    expect(
+      shouldReloadHistoryForFinalEvent({
+        runId: "run-1",
+        sessionKey: "main",
+        state: "final",
+        message: { role: "assistant", content: [{ type: "text", text: "done" }] },
+      }),
+    ).toBe(false);
+  });
+
+  it("returns true when final event message role is non-assistant", () => {
+    expect(
+      shouldReloadHistoryForFinalEvent({
+        runId: "run-1",
+        sessionKey: "main",
+        state: "final",
+        message: { role: "user", content: [{ type: "text", text: "echo" }] },
+      }),
+    ).toBe(true);
+  });
+});

package/ui/src/ui/chat-event-reload.ts

@@ -0,0 +1,16 @@
+import type { ChatEventPayload } from "./controllers/chat.ts";
+
+export function shouldReloadHistoryForFinalEvent(payload?: ChatEventPayload): boolean {
+  if (!payload || payload.state !== "final") {
+    return false;
+  }
+  if (!payload.message || typeof payload.message !== "object") {
+    return true;
+  }
+  const message = payload.message as Record<string, unknown>;
+  const role = typeof message.role === "string" ? message.role.toLowerCase() : "";
+  if (role && role !== "assistant") {
+    return true;
+  }
+  return false;
+}