@copilotkit/react-core 1.55.1 → 1.55.2-canary.test-01

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/react-core",
-  "version": "1.55.1",
+  "version": "1.55.2-canary.test-01",
   "private": false,
   "keywords": [
     "ai",
@@ -54,6 +54,11 @@
   "dependencies": {
     "@ag-ui/client": "0.0.52",
     "@ag-ui/core": "0.0.52",
+    "@copilotkit/a2ui-renderer": "1.55.2-canary.test-01",
+    "@copilotkit/core": "1.55.2-canary.test-01",
+    "@copilotkit/runtime-client-gql": "1.55.2-canary.test-01",
+    "@copilotkit/shared": "1.55.2-canary.test-01",
+    "@copilotkit/web-inspector": "1.55.2-canary.test-01",
     "@jetbrains/websandbox": "^1.1.3",
     "@lit-labs/react": "^2.0.2",
     "@radix-ui/react-dropdown-menu": "^2.1.15",
@@ -72,12 +77,7 @@
     "tw-animate-css": "^1.3.5",
     "untruncate-json": "^0.0.1",
     "use-stick-to-bottom": "^1.1.1",
-    "zod-to-json-schema": "^3.24.5",
-    "@copilotkit/core": "1.55.1",
-    "@copilotkit/a2ui-renderer": "1.55.1",
-    "@copilotkit/runtime-client-gql": "1.55.1",
-    "@copilotkit/shared": "1.55.1",
-    "@copilotkit/web-inspector": "1.55.1"
+    "zod-to-json-schema": "^3.24.5"
   },
   "devDependencies": {
     "@tailwindcss/cli": "^4.1.11",

package/src/components/copilot-provider/copilotkit.tsx

@@ -346,7 +346,7 @@ export function CopilotKitInternal(cpkProps: CopilotKitProps) {
     }, {});
 
     return {
-      ...(copilotApiConfig.headers || {}),
+      ...copilotApiConfig.headers,
       ...(copilotApiConfig.publicApiKey
         ? {
             [COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]:
@@ -508,7 +508,7 @@ export function CopilotKitInternal(cpkProps: CopilotKitProps) {
         return {
           ...prev,
           [action.id]: {
-            ...(prev[action.id] ?? {}),
+            ...prev[action.id],
             ...action,
           } as LangGraphInterruptRender,
         };

package/src/hooks/use-agent-nodename.ts

@@ -18,6 +18,9 @@ export function useAgentNodeName(agentName?: string) {
       onRunFinishedEvent: () => {
         nodeNameRef.current = "end";
       },
+      onRunErrorEvent: () => {
+        nodeNameRef.current = "end";
+      },
     };
 
     const subscription = agent.subscribe(subscriber);

package/src/hooks/use-coagent-state-render-bridge.helpers.ts

@@ -246,7 +246,8 @@ export function selectSnapshot({
   caches,
 }: SnapshotSelectionInput): SnapshotSelectionResult {
   const lastAssistantId = agentMessages
-    ? [...agentMessages].reverse().find((msg) => msg.role === "assistant")?.id
+    ? [...agentMessages].toReversed().find((msg) => msg.role === "assistant")
+        ?.id
     : undefined;
   const latestSnapshot =
     stateRenderId !== undefined

package/src/hooks/use-coagent-state-render-registry.ts

@@ -84,7 +84,7 @@ export function useStateRenderRegistry({
         Object.keys(existingClaim.stateSnapshot).length > 0
       ) {
         const snapshotCache = {
-          ...(store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {}),
+          ...store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN],
         };
         const cacheKey = `${existingClaim.stateRenderId}::${existingClaim.runId ?? "pending"}`;
         snapshotCache[cacheKey] = existingClaim.stateSnapshot;
@@ -93,7 +93,7 @@ export function useStateRenderRegistry({
         store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
 
         const messageCache = {
-          ...(store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {}),
+          ...store[LAST_SNAPSHOTS_BY_MESSAGE],
         };
         messageCache[message.id] = {
           snapshot: existingClaim.stateSnapshot,
@@ -189,14 +189,14 @@ export function useStateRenderRegistry({
     if (!claimsRef.current[message.id].locked || snapshotChanged) {
       claimsRef.current[message.id].stateSnapshot = snapshot;
       const snapshotCache = {
-        ...(store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {}),
+        ...store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN],
       };
       const cacheKey = `${stateRenderId}::${effectiveRunId}`;
       snapshotCache[cacheKey] = snapshot;
       snapshotCache[`${stateRenderId}::latest`] = snapshot;
       store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
       const messageCache = {
-        ...(store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {}),
+        ...store[LAST_SNAPSHOTS_BY_MESSAGE],
       };
       messageCache[message.id] = { snapshot, runId: effectiveRunId };
       store[LAST_SNAPSHOTS_BY_MESSAGE] = messageCache;
@@ -209,14 +209,14 @@ export function useStateRenderRegistry({
     if (!existingSnapshot) {
       claimsRef.current[message.id].stateSnapshot = snapshotForClaim;
       const snapshotCache = {
-        ...(store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {}),
+        ...store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN],
       };
       const cacheKey = `${stateRenderId}::${effectiveRunId}`;
       snapshotCache[cacheKey] = snapshotForClaim;
       snapshotCache[`${stateRenderId}::latest`] = snapshotForClaim;
       store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
       const messageCache = {
-        ...(store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {}),
+        ...store[LAST_SNAPSHOTS_BY_MESSAGE],
       };
       messageCache[message.id] = {
         snapshot: snapshotForClaim,

package/src/hooks/use-copilot-chat_internal.ts

@@ -481,7 +481,7 @@ export function useCopilotChatInternal({
         // Work backwards to find the first the closest user message
         const lastUserMessageBeforeRegenerate = messages
           .slice(0, reloadMessageIndex)
-          .reverse()
+          .toReversed()
           .find((msg) => msg.role === "user");
 
         if (!lastUserMessageBeforeRegenerate) {

package/src/lib/copilot-task.ts

@@ -163,7 +163,7 @@ export class CopilotTask<T = any> {
           forwardedParameters: {
             // if forwardedParameters is provided, use it
             toolChoice: "required",
-            ...(this.forwardedParameters ?? {}),
+            ...this.forwardedParameters,
           },
         },
         properties: context.copilotApiConfig.properties,

package/src/utils/utils.ts

@@ -4,5 +4,3 @@ import {
   convertJsonSchemaToZodSchema,
   Parameter,
 } from "@copilotkit/shared";
-
-export {};

package/src/v2/a2ui/A2UIMessageRenderer.tsx

@@ -151,7 +151,7 @@ function ReactSurfaceHost({
 
       try {
         copilotkit.setProperties({
-          ...(copilotkit.properties ?? {}),
+          ...copilotkit.properties,
           a2uiAction: message,
         });
 

package/src/v2/components/MCPAppsActivityRenderer.tsx

@@ -3,6 +3,7 @@
 import React, { useEffect, useRef, useState, useCallback } from "react";
 import { z } from "zod";
 import type { AbstractAgent, RunAgentResult } from "@ag-ui/client";
+import { useCopilotKit } from "../providers/CopilotKitProvider";
 
 // Protocol version supported
 const PROTOCOL_VERSION = "2025-06-18";
@@ -252,6 +253,7 @@ interface MCPAppsActivityRendererProps {
  */
 export const MCPAppsActivityRenderer: React.FC<MCPAppsActivityRendererProps> =
   function MCPAppsActivityRenderer({ content, agent }) {
+    const { copilotkit } = useCopilotKit();
     const containerRef = useRef<HTMLDivElement>(null);
     const iframeRef = useRef<HTMLIFrameElement | null>(null);
     const [iframeReady, setIframeReady] = useState(false);
@@ -522,7 +524,7 @@ export const MCPAppsActivityRenderer: React.FC<MCPAppsActivityRendererProps> =
                 }
 
                 case "ui/message": {
-                  // Add message to CopilotKit chat
+                  // Add message to CopilotKit chat and optionally invoke agent
                   const currentAgent = agentRef.current;
 
                   if (!currentAgent) {
@@ -537,8 +539,12 @@ export const MCPAppsActivityRenderer: React.FC<MCPAppsActivityRendererProps> =
                     const params = msg.params as {
                       role?: string;
                       content?: Array<{ type: string; text?: string }>;
+                      followUp?: boolean;
                     };
 
+                    const role =
+                      (params.role as "user" | "assistant") || "user";
+
                     // Extract text content from the message
                     const textContent =
                       params.content
@@ -549,11 +555,35 @@ export const MCPAppsActivityRenderer: React.FC<MCPAppsActivityRendererProps> =
                     if (textContent) {
                       currentAgent.addMessage({
                         id: crypto.randomUUID(),
-                        role: (params.role as "user" | "assistant") || "user",
+                        role,
                         content: textContent,
                       });
                     }
+
+                    // Acknowledge the message immediately — don't block on agent run
                     sendResponse(msg.id, { isError: false });
+
+                    // Determine whether to invoke the agent after adding message.
+                    // followUp: true  → always invoke agent
+                    // followUp: false → display-only, skip agent
+                    // not specified   → invoke for user messages, skip for assistant
+                    const shouldFollowUp = params.followUp ?? role === "user";
+
+                    if (shouldFollowUp && textContent) {
+                      // Use copilotkit.runAgent to go through RunHandler — provides
+                      // frontend tools, context, tool execution, and abort support.
+                      // Fire-and-forget: errors are handled by RunHandler's error emission.
+                      mcpAppsRequestQueue
+                        .enqueue(currentAgent, () =>
+                          copilotkit.runAgent({ agent: currentAgent }),
+                        )
+                        .catch((err) =>
+                          console.error(
+                            "[MCPAppsRenderer] ui/message agent run failed:",
+                            err,
+                          ),
+                        );
+                    }
                   } catch (err) {
                     console.error("[MCPAppsRenderer] ui/message error:", err);
                     sendResponse(msg.id, { isError: true });

package/src/v2/components/chat/CopilotChatMessageView.tsx

@@ -305,6 +305,45 @@ const MemoizedCustomMessage = React.memo(
   },
 );
 
+/**
+ * Deduplicates messages by ID. For assistant messages, merges occurrences:
+ * recovers non-empty content from any earlier occurrence if the latest wiped it
+ * (empty string means the streaming update cleared the field, not blank text),
+ * and similarly recovers toolCalls from earlier occurrences if the latest is
+ * undefined (an empty array [] is treated as intentional and kept as-is).
+ * For all other roles, keeps the last entry.
+ *
+ * @internal Exported for unit testing only — not part of the public API.
+ */
+export function deduplicateMessages(messages: Message[]): Message[] {
+  const acc = new Map<string, Message>();
+  for (const message of messages) {
+    const existing = acc.get(message.id);
+    if (
+      existing &&
+      message.role === "assistant" &&
+      existing.role === "assistant"
+    ) {
+      // Empty string means the streaming update cleared the field — fall back to
+      // any non-empty content seen earlier. Use { ...existing, ...message } so
+      // fields present only in an earlier occurrence are not silently dropped.
+      const content = message.content || existing.content;
+      // undefined toolCalls means this chunk had no tool call activity — recover
+      // from earlier occurrences. An explicit [] means all tool calls completed.
+      const toolCalls = message.toolCalls ?? existing.toolCalls;
+      acc.set(message.id, {
+        ...existing,
+        ...message,
+        content,
+        toolCalls,
+      } as AssistantMessage);
+    } else {
+      acc.set(message.id, message);
+    }
+  }
+  return [...acc.values()];
+}
+
 export type CopilotChatMessageViewProps = Omit<
   WithSlots<
     {
@@ -399,11 +438,8 @@ export function CopilotChatMessageView({
     );
   };
 
-  // Deduplicate messages by id, keeping the last occurrence of each.
-  // During streaming, AbstractAgent.addMessage() can push duplicate messages
-  // (same id) which causes React "duplicate key" warnings and rendering glitches.
   const deduplicatedMessages = useMemo(
-    () => [...new Map(messages.map((m) => [m.id, m])).values()],
+    () => deduplicateMessages(messages),
     [messages],
   );
 
@@ -412,7 +448,7 @@ export function CopilotChatMessageView({
     deduplicatedMessages.length < messages.length
   ) {
     console.warn(
-      `CopilotChatMessageView: Deduplicated ${messages.length - deduplicatedMessages.length} message(s) with duplicate IDs.`,
+      `CopilotChatMessageView: Merged ${messages.length - deduplicatedMessages.length} message(s) with duplicate IDs.`,
     );
   }
 

package/src/v2/components/chat/__tests__/CopilotChatMessageView.test.tsx

@@ -4,43 +4,81 @@ import { z } from "zod";
 import { vi } from "vitest";
 import { CopilotKitProvider } from "../../../providers/CopilotKitProvider";
 import { CopilotChatConfigurationProvider } from "../../../providers/CopilotChatConfigurationProvider";
-import CopilotChatMessageView from "../CopilotChatMessageView";
-import {
+import CopilotChatMessageView, {
+  deduplicateMessages,
+} from "../CopilotChatMessageView";
+import type {
   ActivityMessage,
   AssistantMessage,
   Message,
+  ToolCall,
   UserMessage,
 } from "@ag-ui/core";
-import { ReactActivityMessageRenderer } from "../../../types";
+import type { ReactActivityMessageRenderer } from "../../../types";
 
-describe("CopilotChatMessageView activity rendering", () => {
-  const agentId = "default";
-  const threadId = "thread-test";
-
-  function renderMessageView({
-    messages,
-    renderActivityMessages,
-  }: {
-    messages: Message[];
-    renderActivityMessages?: ReactActivityMessageRenderer<any>[];
-  }) {
-    return render(
-      <CopilotKitProvider renderActivityMessages={renderActivityMessages}>
-        <CopilotChatConfigurationProvider agentId={agentId} threadId={threadId}>
-          <CopilotChatMessageView messages={messages} />
-        </CopilotChatConfigurationProvider>
-      </CopilotKitProvider>,
-    );
-  }
+// ---------------------------------------------------------------------------
+// Shared constants & helpers
+// ---------------------------------------------------------------------------
+
+const AGENT_ID = "default";
+const THREAD_ID = "thread-test";
+
+/** Typed factory — avoids `as UserMessage` casts everywhere. */
+function userMsg(id: string, content: string) {
+  return { id, role: "user" as const, content };
+}
+
+/** Typed factory — avoids `as AssistantMessage` casts everywhere. */
+function assistantMsg(id: string, content?: string, toolCalls?: ToolCall[]) {
+  return { id, role: "assistant" as const, content, toolCalls };
+}
+
+/** Typed factory — avoids `as ActivityMessage` casts everywhere. */
+function activityMsg(
+  id: string,
+  activityType: string,
+  content: ActivityMessage["content"],
+) {
+  return { id, role: "activity" as const, activityType, content };
+}
+
+/** Typed factory — avoids `as any` casts on tool call objects. */
+function toolCall(id: string, name: string, args = "{}") {
+  return {
+    id,
+    type: "function" as const,
+    function: { name, arguments: args },
+  };
+}
+
+/**
+ * Renders CopilotChatMessageView wrapped in the required providers.
+ * Unified helper used by all describe blocks in this file.
+ */
+function renderMessageView({
+  messages,
+  renderActivityMessages,
+}: {
+  messages: Message[];
+  renderActivityMessages?: ReactActivityMessageRenderer<{ percent: number }>[];
+}) {
+  return render(
+    <CopilotKitProvider renderActivityMessages={renderActivityMessages}>
+      <CopilotChatConfigurationProvider agentId={AGENT_ID} threadId={THREAD_ID}>
+        <CopilotChatMessageView messages={messages} />
+      </CopilotChatConfigurationProvider>
+    </CopilotKitProvider>,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
 
+describe("CopilotChatMessageView activity rendering", () => {
   it("renders activity messages via matching custom renderer", () => {
     const messages: Message[] = [
-      {
-        id: "act-1",
-        role: "activity",
-        activityType: "search-progress",
-        content: { percent: 42 },
-      } as ActivityMessage,
+      activityMsg("act-1", "search-progress", { percent: 42 }),
     ];
 
     const renderers: ReactActivityMessageRenderer<{ percent: number }>[] = [
@@ -62,12 +100,7 @@ describe("CopilotChatMessageView activity rendering", () => {
 
   it("skips rendering when no activity renderer matches", () => {
     const messages: Message[] = [
-      {
-        id: "act-2",
-        role: "activity",
-        activityType: "unknown-type",
-        content: { message: "should not render" },
-      } as ActivityMessage,
+      activityMsg("act-2", "unknown-type", { message: "should not render" }),
     ];
 
     renderMessageView({ messages, renderActivityMessages: [] });
@@ -77,36 +110,34 @@ describe("CopilotChatMessageView activity rendering", () => {
 });
 
 describe("CopilotChatMessageView duplicate message deduplication", () => {
-  const agentId = "default";
-  const threadId = "thread-test";
-
-  function renderMessageView({ messages }: { messages: Message[] }) {
-    return render(
-      <CopilotKitProvider>
-        <CopilotChatConfigurationProvider agentId={agentId} threadId={threadId}>
-          <CopilotChatMessageView messages={messages} />
-        </CopilotChatConfigurationProvider>
-      </CopilotKitProvider>,
+  it("preserves assistant text content when later duplicate has empty content (multi-tool-call scenario)", () => {
+    const messages: Message[] = [
+      userMsg("user-1", "Record a headache"),
+      assistantMsg("assistant-1", "Let me record that..."),
+      assistantMsg("assistant-1", "", [toolCall("tc-1", "captureData")]),
+      assistantMsg("assistant-1", "", [
+        toolCall("tc-1", "captureData"),
+        toolCall("tc-2", "updateMemory"),
+      ]),
+    ];
+
+    renderMessageView({ messages });
+
+    // One merged assistant message (not three)
+    const assistantMessages = screen.getAllByTestId(
+      "copilot-assistant-message",
     );
-  }
+    expect(assistantMessages).toHaveLength(1);
 
-  it("deduplicates messages with the same id, keeping the last occurrence", () => {
+    // Original text content must survive despite later empty-content duplicates
+    expect(assistantMessages[0].textContent).toContain("Let me record that...");
+  });
+
+  it("uses latest content when all assistant duplicates have non-empty content", () => {
     const messages: Message[] = [
-      {
-        id: "user-1",
-        role: "user",
-        content: "Hello",
-      } as UserMessage,
-      {
-        id: "assistant-1",
-        role: "assistant",
-        content: "Partial response...",
-      } as AssistantMessage,
-      {
-        id: "assistant-1",
-        role: "assistant",
-        content: "Full response from the assistant.",
-      } as AssistantMessage,
+      userMsg("user-1", "Hello"),
+      assistantMsg("assistant-1", "Partial response..."),
+      assistantMsg("assistant-1", "Full response from the assistant."),
     ];
 
     const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
@@ -118,6 +149,9 @@ describe("CopilotChatMessageView duplicate message deduplication", () => {
       "copilot-assistant-message",
     );
     expect(assistantMessages).toHaveLength(1);
+    expect(assistantMessages[0].textContent).toContain(
+      "Full response from the assistant.",
+    );
 
     // Should render the user message too
     const userMessages = screen.getAllByTestId("copilot-user-message");
@@ -133,28 +167,12 @@ describe("CopilotChatMessageView duplicate message deduplication", () => {
     consoleSpy.mockRestore();
   });
 
-  it("preserves order of unique messages", () => {
+  it("preserves order of unique messages (no duplicates)", () => {
     const messages: Message[] = [
-      {
-        id: "user-1",
-        role: "user",
-        content: "First question",
-      } as UserMessage,
-      {
-        id: "assistant-1",
-        role: "assistant",
-        content: "First answer",
-      } as AssistantMessage,
-      {
-        id: "user-2",
-        role: "user",
-        content: "Second question",
-      } as UserMessage,
-      {
-        id: "assistant-2",
-        role: "assistant",
-        content: "Second answer",
-      } as AssistantMessage,
+      userMsg("user-1", "First question"),
+      assistantMsg("assistant-1", "First answer"),
+      userMsg("user-2", "Second question"),
+      assistantMsg("assistant-2", "Second answer"),
     ];
 
     renderMessageView({ messages });
@@ -167,3 +185,95 @@ describe("CopilotChatMessageView duplicate message deduplication", () => {
     expect(assistantMessages).toHaveLength(2);
   });
 });
+
+describe("deduplicateMessages", () => {
+  it("recovers non-empty content and keeps latest toolCalls when later duplicate clears content", () => {
+    const messages: Message[] = [
+      assistantMsg("assistant-1", "Let me record that..."),
+      assistantMsg("assistant-1", "", [toolCall("tc-1", "captureData")]),
+      assistantMsg("assistant-1", "", [
+        toolCall("tc-1", "captureData"),
+        toolCall("tc-2", "updateMemory"),
+      ]),
+    ];
+
+    const result = deduplicateMessages(messages);
+
+    expect(result).toHaveLength(1);
+    const merged = result[0] as AssistantMessage;
+    // Content recovered from the first occurrence
+    expect(merged.content).toBe("Let me record that...");
+    // toolCalls from the latest occurrence (both tc-1 and tc-2)
+    expect(merged.toolCalls).toHaveLength(2);
+    expect(merged.toolCalls?.map((tc) => tc.id)).toEqual(["tc-1", "tc-2"]);
+  });
+
+  it("uses content from a later occurrence when early occurrence has empty content", () => {
+    const messages: Message[] = [
+      assistantMsg("assistant-1", ""),
+      assistantMsg("assistant-1", "Here is the result."),
+    ];
+
+    const result = deduplicateMessages(messages);
+
+    expect(result).toHaveLength(1);
+    expect((result[0] as AssistantMessage).content).toBe("Here is the result.");
+  });
+
+  it("recovers toolCalls when a later occurrence has non-empty content but undefined toolCalls", () => {
+    // A later streaming chunk may carry updated content but omit toolCalls entirely.
+    // The earlier accumulated toolCalls must survive rather than be wiped by the spread.
+    const messages: Message[] = [
+      assistantMsg("assistant-1", "", [toolCall("tc-1", "captureData")]),
+      assistantMsg("assistant-1", "Here is the result."),
+    ];
+
+    const result = deduplicateMessages(messages);
+
+    expect(result).toHaveLength(1);
+    const merged = result[0] as AssistantMessage;
+    expect(merged.content).toBe("Here is the result.");
+    expect(merged.toolCalls).toHaveLength(1);
+    expect(merged.toolCalls?.[0]?.id).toBe("tc-1");
+  });
+
+  it("keeps empty toolCalls array from a later chunk (does not fall back to earlier toolCalls)", () => {
+    // [] means all tool calls completed — it is an intentional value, not absence.
+    // ?? must treat it as defined and keep it rather than falling back.
+    const messages: Message[] = [
+      assistantMsg("assistant-1", "", [toolCall("tc-1", "captureData")]),
+      assistantMsg("assistant-1", "Done.", []),
+    ];
+
+    const result = deduplicateMessages(messages);
+
+    expect(result).toHaveLength(1);
+    expect((result[0] as AssistantMessage).toolCalls).toEqual([]);
+  });
+
+  it("handles undefined content on both occurrences without error", () => {
+    // assistantMsg with no content arg produces content: undefined.
+    // undefined || undefined = undefined — should not throw or produce garbage.
+    const messages: Message[] = [
+      assistantMsg("assistant-1"),
+      assistantMsg("assistant-1"),
+    ];
+
+    const result = deduplicateMessages(messages);
+
+    expect(result).toHaveLength(1);
+    expect((result[0] as AssistantMessage).content).toBeUndefined();
+  });
+
+  it("keeps last entry for non-assistant roles", () => {
+    const messages: Message[] = [
+      userMsg("u-1", "Hello"),
+      userMsg("u-1", "Hello (updated)"),
+    ];
+
+    const result = deduplicateMessages(messages);
+
+    expect(result).toHaveLength(1);
+    expect((result[0] as UserMessage).content).toBe("Hello (updated)");
+  });
+});