@marimo-team/islands 0.23.15-dev2 → 0.23.15-dev21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.23.15-dev2",
+  "version": "0.23.15-dev21",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/components/chat/__tests__/chat-utils.test.ts

@@ -2,7 +2,11 @@
 
 import type { UIMessage } from "ai";
 import { describe, expect, it } from "vitest";
-import { hasPendingToolCalls } from "../chat-utils";
+import {
+  hasPendingToolCalls,
+  hasUnresolvedToolCalls,
+  shouldFlushQueue,
+} from "../chat-utils";
 
 /**
  * `hasPendingToolCalls` powers `sendAutomaticallyWhen` in `mo.ui.chat`:
@@ -81,6 +85,23 @@ describe("hasPendingToolCalls", () => {
     ).toBe(true);
   });
 
+  it("returns true when the user denied a tool approval", () => {
+    expect(
+      hasPendingToolCalls([
+        userMessage("delete it"),
+        assistantToolMessage([
+          {
+            type: "tool-delete_file",
+            toolCallId: "call-1",
+            state: "output-denied",
+            input: { path: "secrets.env" },
+            approval: { id: "approval-1", approved: false },
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(true);
+  });
+
   it("returns true when a tool reached a terminal output state", () => {
     expect(
       hasPendingToolCalls([
@@ -267,3 +288,225 @@ describe("hasPendingToolCalls", () => {
     ).toBe(true);
   });
 });
+
+describe("hasUnresolvedToolCalls", () => {
+  it("returns false when there are no messages", () => {
+    expect(hasUnresolvedToolCalls([])).toBe(false);
+  });
+
+  it("returns true while approval is still requested", () => {
+    expect(
+      hasUnresolvedToolCalls([
+        userMessage("delete it"),
+        assistantToolMessage([
+          {
+            type: "tool-delete_file",
+            toolCallId: "call-1",
+            state: "approval-requested",
+            input: { path: "secrets.env" },
+            approval: { id: "approval-1" },
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(true);
+  });
+
+  it("returns true while a tool is still running", () => {
+    expect(
+      hasUnresolvedToolCalls([
+        userMessage("run it"),
+        assistantToolMessage([
+          {
+            type: "tool-run_query",
+            toolCallId: "call-1",
+            state: "input-available",
+            input: { sql: "select 1" },
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(true);
+  });
+
+  it("returns false once tools are ready to round-trip", () => {
+    expect(
+      hasUnresolvedToolCalls([
+        userMessage("run it"),
+        assistantToolMessage([
+          {
+            type: "tool-run_query",
+            toolCallId: "call-1",
+            state: "output-available",
+            input: { sql: "select 1" },
+            output: 1,
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(false);
+  });
+
+  it("returns false once the user denied a tool approval", () => {
+    expect(
+      hasUnresolvedToolCalls([
+        userMessage("delete it"),
+        assistantToolMessage([
+          {
+            type: "tool-delete_file",
+            toolCallId: "call-1",
+            state: "output-denied",
+            input: { path: "secrets.env" },
+            approval: { id: "approval-1", approved: false },
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(false);
+  });
+});
+
+describe("shouldFlushQueue", () => {
+  it("flushes when the turn completed without error or pending tools", () => {
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: false,
+      }),
+    ).toBe(true);
+  });
+
+  it("does not flush on error", () => {
+    expect(
+      shouldFlushQueue({
+        isError: true,
+        isAbort: false,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: false,
+      }),
+    ).toBe(false);
+  });
+
+  it("does not flush while a tool round-trip is still pending", () => {
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: true,
+        hasUnresolvedToolCalls: false,
+      }),
+    ).toBe(false);
+  });
+
+  it("does not flush while approval is still requested", () => {
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: true,
+      }),
+    ).toBe(false);
+  });
+
+  it("flushes on abort even when a tool is still streaming", () => {
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: true,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: true,
+      }),
+    ).toBe(true);
+  });
+
+  it("does not flush on abort when the run ended in error", () => {
+    expect(
+      shouldFlushQueue({
+        isError: true,
+        isAbort: true,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: true,
+      }),
+    ).toBe(false);
+  });
+
+  it("flushes once trailing text is present and tools are resolved", () => {
+    const messages = [
+      userMessage("run it"),
+      assistantToolMessage([
+        {
+          type: "tool-run_query",
+          toolCallId: "call-1",
+          state: "output-available",
+          input: {},
+          output: 1,
+        } as unknown as UIMessage["parts"][number],
+        { type: "text", text: "Done." },
+      ]),
+    ];
+
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: hasPendingToolCalls(messages),
+        hasUnresolvedToolCalls: hasUnresolvedToolCalls(messages),
+      }),
+    ).toBe(true);
+  });
+
+  it("blocks flush while text trails a still-running tool, then allows it after resolution", () => {
+    const running = [
+      userMessage("run it"),
+      assistantToolMessage([
+        {
+          type: "tool-run_query",
+          toolCallId: "call-1",
+          state: "input-available",
+          input: {},
+        } as unknown as UIMessage["parts"][number],
+        { type: "text", text: "Running your query..." },
+      ]),
+    ];
+    const resolved = [
+      userMessage("run it"),
+      assistantToolMessage([
+        {
+          type: "tool-run_query",
+          toolCallId: "call-1",
+          state: "output-available",
+          input: {},
+          output: 1,
+        } as unknown as UIMessage["parts"][number],
+        { type: "text", text: "Running your query..." },
+      ]),
+    ];
+
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: hasPendingToolCalls(running),
+        hasUnresolvedToolCalls: hasUnresolvedToolCalls(running),
+      }),
+    ).toBe(false);
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: hasPendingToolCalls(resolved),
+        hasUnresolvedToolCalls: hasUnresolvedToolCalls(resolved),
+      }),
+    ).toBe(true);
+  });
+
+  it("does not flush on error even when tools are also pending", () => {
+    expect(
+      shouldFlushQueue({
+        isError: true,
+        isAbort: false,
+        hasPendingToolCalls: true,
+        hasUnresolvedToolCalls: true,
+      }),
+    ).toBe(false);
+  });
+});

package/src/components/chat/__tests__/message-queue.test.tsx

@@ -0,0 +1,121 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { type ChatMessagePart, useMessageQueue } from "../chat-utils";
+
+function textPart(text: string): ChatMessagePart {
+  return { type: "text", text };
+}
+
+describe("useMessageQueue", () => {
+  it("initializes empty", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    expect(result.current.messages).toEqual([]);
+  });
+
+  it("enqueues messages in order with unique ids", () => {
+    const { result } = renderHook(() => useMessageQueue());
+
+    act(() => result.current.enqueue([textPart("first")]));
+    act(() => result.current.enqueue([textPart("second")]));
+
+    const [a, b] = result.current.messages;
+    expect(a.parts).toEqual([textPart("first")]);
+    expect(b.parts).toEqual([textPart("second")]);
+    expect(a.id).toBeTypeOf("string");
+    expect(a.id).not.toBe(b.id);
+  });
+
+  it("flushNext sends the oldest message's parts and dequeues it", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    act(() => result.current.enqueue([textPart("first")]));
+    act(() => result.current.enqueue([textPart("second")]));
+    act(() => result.current.flushNext(send));
+
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(send).toHaveBeenCalledWith([textPart("first")]);
+    expect(result.current.messages).toEqual([
+      expect.objectContaining({ parts: [textPart("second")] }),
+    ]);
+  });
+
+  it("flushNext sees a message enqueued in the same act (before re-render)", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    // Mirrors enqueue + onFinish in the same tick: the ref must be updated
+    // synchronously inside enqueue, not only on the next render.
+    act(() => {
+      result.current.enqueue([textPart("queued while finishing")]);
+      result.current.flushNext(send);
+    });
+
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(send).toHaveBeenCalledWith([textPart("queued while finishing")]);
+    expect(result.current.messages).toEqual([]);
+  });
+
+  it("drains sequentially, even across synchronous flushNext calls", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    act(() => result.current.enqueue([textPart("first")]));
+    act(() => result.current.enqueue([textPart("second")]));
+
+    // Two flushes in the same act: the ref must stay in sync so the second
+    // flush releases the next message rather than re-sending the first.
+    act(() => {
+      result.current.flushNext(send);
+      result.current.flushNext(send);
+    });
+
+    expect(send).toHaveBeenNthCalledWith(1, [textPart("first")]);
+    expect(send).toHaveBeenNthCalledWith(2, [textPart("second")]);
+    expect(result.current.messages).toEqual([]);
+  });
+
+  it("flushNext on an empty queue is a no-op", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    act(() => result.current.flushNext(send));
+
+    expect(send).not.toHaveBeenCalled();
+    expect(result.current.messages).toEqual([]);
+  });
+
+  it("clear empties the queue", () => {
+    const { result } = renderHook(() => useMessageQueue());
+
+    act(() => result.current.enqueue([textPart("first")]));
+    act(() => result.current.enqueue([textPart("second")]));
+    act(() => result.current.clear());
+
+    expect(result.current.messages).toEqual([]);
+    expect(result.current.hasQueuedRef.current).toBe(false);
+  });
+
+  it("hasQueuedRef stays in sync when enqueue and flush run in the same act", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    act(() => {
+      result.current.enqueue([textPart("first")]);
+      result.current.enqueue([textPart("second")]);
+    });
+    expect(result.current.hasQueuedRef.current).toBe(true);
+
+    act(() => {
+      result.current.flushNext(send);
+    });
+    expect(result.current.hasQueuedRef.current).toBe(true);
+
+    act(() => {
+      result.current.flushNext(send);
+    });
+    expect(result.current.hasQueuedRef.current).toBe(false);
+  });
+});