@copilotkit/react-core 1.57.0 → 1.57.1

package/src/v2/hooks/__tests__/use-agent-throttle.test.tsx

@@ -2,7 +2,7 @@ import React from "react";
 import { render, act, screen } from "@testing-library/react";
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { useAgent, UseAgentUpdate } from "../use-agent";
-import { useCopilotKit } from "../../providers/CopilotKitProvider";
+import { useCopilotKit } from "../../context";
 import { MockStepwiseAgent } from "../../__tests__/utils/test-helpers";
 import {
   CopilotKitCore,
@@ -11,7 +11,7 @@ import {
 import type { Message } from "@ag-ui/core";
 import type { RunAgentInput } from "@ag-ui/client";
 
-vi.mock("../../providers/CopilotKitProvider", () => ({
+vi.mock("../../context", () => ({
   useCopilotKit: vi.fn(),
 }));
 
@@ -173,13 +173,13 @@ describe("useAgent throttleMs", () => {
     vi.restoreAllMocks();
   });
 
-  it("without throttleMs, component reflects latest messages after notification", () => {
+  it("without throttleMs, component reflects latest messages after notification", async () => {
     const TestComponent = createTestComponent();
 
     render(<TestComponent />);
     expect(screen.getByTestId("count").textContent).toBe("0");
 
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello")];
       notifyMessagesChanged(mockAgent);
     });
@@ -187,13 +187,13 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
   });
 
-  it("with throttleMs: 0 (explicit), behaves identically to omitting throttleMs", () => {
+  it("with throttleMs: 0 (explicit), behaves identically to omitting throttleMs", async () => {
     const TestComponent = createTestComponent({ throttleMs: 0 });
 
     render(<TestComponent />);
     expect(screen.getByTestId("count").textContent).toBe("0");
 
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello")];
       notifyMessagesChanged(mockAgent);
     });
@@ -201,7 +201,7 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Second notification also fires immediately (no throttle)
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
       notifyMessagesChanged(mockAgent);
     });
@@ -209,13 +209,13 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("2");
   });
 
-  it("with throttleMs, first notification fires immediately (leading edge)", () => {
+  it("with throttleMs, first notification fires immediately (leading edge)", async () => {
     const TestComponent = createTestComponent({ throttleMs: 100 });
 
     render(<TestComponent />);
     expect(screen.getByTestId("count").textContent).toBe("0");
 
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello")];
       notifyMessagesChanged(mockAgent);
     });
@@ -223,20 +223,20 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
   });
 
-  it("with throttleMs, second notification within window is deferred until trailing edge", () => {
+  it("with throttleMs, second notification within window is deferred until trailing edge", async () => {
     const TestComponent = createTestComponent({ throttleMs: 100 });
 
     render(<TestComponent />);
 
     // First notification — leading edge, fires immediately
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Second notification 10ms later — within throttle window
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(10);
       mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
       notifyMessagesChanged(mockAgent);
@@ -246,13 +246,13 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Advance past the throttle window — trailing edge fires
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(100);
     });
     expect(screen.getByTestId("count").textContent).toBe("2");
   });
 
-  it("with throttleMs, rapid burst of many notifications results in exactly 2 renders (leading + trailing)", () => {
+  it("with throttleMs, rapid burst of many notifications results in exactly 2 renders (leading + trailing)", async () => {
     const renderCount = { current: 0 };
     const TestComponent = createTestComponent({ throttleMs: 100, renderCount });
 
@@ -260,7 +260,7 @@ describe("useAgent throttleMs", () => {
     const rendersAfterMount = renderCount.current;
 
     // Leading edge — fires immediately
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "tok1")];
       notifyMessagesChanged(mockAgent);
     });
@@ -268,7 +268,7 @@ describe("useAgent throttleMs", () => {
 
     // Fire 10 rapid notifications within the throttle window (1ms apart)
     for (let i = 2; i <= 11; i++) {
-      act(() => {
+      await act(async () => {
         vi.advanceTimersByTime(1);
         mockAgent.messages = createMessages(i);
         notifyMessagesChanged(mockAgent);
@@ -280,40 +280,40 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Advance past the throttle window — trailing edge fires once
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(100);
     });
     expect(renderCount.current).toBe(rendersAfterMount + 2);
     expect(screen.getByTestId("count").textContent).toBe("11");
   });
 
-  it("with throttleMs, new notification after trailing edge fires immediately (new cycle)", () => {
+  it("with throttleMs, new notification after trailing edge fires immediately (new cycle)", async () => {
     const TestComponent = createTestComponent({ throttleMs: 100 });
 
     render(<TestComponent />);
 
     // Leading edge
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Second notification — deferred
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(10);
       mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
       notifyMessagesChanged(mockAgent);
     });
 
     // Trailing edge fires
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(100);
     });
     expect(screen.getByTestId("count").textContent).toBe("2");
 
     // New notification well after the window — should fire immediately as a new leading edge
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(200);
       mockAgent.messages = [
         userMsg("1", "a"),
@@ -337,14 +337,14 @@ describe("useAgent throttleMs", () => {
     render(<TestComponent />);
 
     // Fire onMessagesChanged to start the throttle window (leading edge)
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Fire onStateChanged 10ms later — should be deferred (within throttle window)
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(10);
       mockAgent.state = { count: 42 };
       notifyStateChanged(mockAgent);
@@ -362,20 +362,20 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("state").textContent).toBe('{"count":42}');
   });
 
-  it("with throttleMs, pending trailing timer does not fire after unmount", () => {
+  it("with throttleMs, pending trailing timer does not fire after unmount", async () => {
     const renderCount = { current: 0 };
     const TestComponent = createTestComponent({ throttleMs: 100, renderCount });
 
     const { unmount } = render(<TestComponent />);
 
     // Leading edge — fires immediately
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
 
     // Second notification — schedules trailing timer
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(10);
       mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
       notifyMessagesChanged(mockAgent);
@@ -387,7 +387,7 @@ describe("useAgent throttleMs", () => {
     unmount();
 
     // Advancing past the window should NOT cause additional renders
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(100);
     });
 
@@ -428,7 +428,7 @@ describe("useAgent throttleMs", () => {
     { label: "-Infinity", value: -Infinity },
   ])(
     "with invalid throttleMs ($label), falls back to unthrottled and warns",
-    ({ value }) => {
+    async ({ value }) => {
       const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
       const TestComponent = createTestComponent({ throttleMs: value });
 
@@ -443,13 +443,13 @@ describe("useAgent throttleMs", () => {
       );
 
       // Should behave as unthrottled — every notification fires immediately
-      act(() => {
+      await act(async () => {
         mockAgent.messages = [userMsg("1", "a")];
         notifyMessagesChanged(mockAgent);
       });
       expect(screen.getByTestId("count").textContent).toBe("1");
 
-      act(() => {
+      await act(async () => {
         mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
         notifyMessagesChanged(mockAgent);
       });
@@ -457,25 +457,25 @@ describe("useAgent throttleMs", () => {
     },
   );
 
-  it("trailing-edge render reflects the latest messages, not stale data", () => {
+  it("trailing-edge render reflects the latest messages, not stale data", async () => {
     const TestComponent = createTestComponent({ throttleMs: 100 });
     render(<TestComponent />);
 
     // Leading edge
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "A")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Multiple deferred notifications with increasing messages
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(20);
       mockAgent.messages = [userMsg("1", "A"), assistantMsg("2", "B")];
       notifyMessagesChanged(mockAgent);
     });
 
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(20);
       mockAgent.messages = [
         userMsg("1", "A"),
@@ -489,25 +489,25 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Trailing edge fires — must show all 3 messages (latest state)
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(100);
     });
     expect(screen.getByTestId("count").textContent).toBe("3");
   });
 
-  it("trailing edge fires at exactly throttleMs after the leading edge", () => {
+  it("trailing edge fires at exactly throttleMs after the leading edge", async () => {
     const TestComponent = createTestComponent({ throttleMs: 100 });
     render(<TestComponent />);
 
     // Leading edge at T=0
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Deferred notification at T=40
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(40);
       mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
       notifyMessagesChanged(mockAgent);
@@ -515,19 +515,19 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // At T=99, trailing has NOT fired yet
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(59);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // At T=100, trailing fires
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(1);
     });
     expect(screen.getByTestId("count").textContent).toBe("2");
   });
 
-  it("changing throttleMs cleans up pending timers from the previous configuration", () => {
+  it("changing throttleMs cleans up pending timers from the previous configuration", async () => {
     function DynamicThrottleComponent({ throttleMs }: { throttleMs: number }) {
       const { agent } = useAgent({
         agentId: "test-agent",
@@ -540,14 +540,14 @@ describe("useAgent throttleMs", () => {
     const { rerender } = render(<DynamicThrottleComponent throttleMs={200} />);
 
     // Leading edge
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Deferred notification — pending timer set for 200ms
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(50);
       mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
       notifyMessagesChanged(mockAgent);
@@ -558,7 +558,7 @@ describe("useAgent throttleMs", () => {
     rerender(<DynamicThrottleComponent throttleMs={50} />);
 
     // New notification fires as leading edge under the new 50ms throttle
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [
         userMsg("1", "a"),
         assistantMsg("2", "b"),
@@ -570,13 +570,13 @@ describe("useAgent throttleMs", () => {
 
     // Advance past what would have been the old 200ms trailing edge —
     // no ghost render should occur from the old timer
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(200);
     });
     expect(screen.getByTestId("count").textContent).toBe("3");
   });
 
-  it("notification immediately after trailing edge is throttled (trailing restarts the window)", () => {
+  it("notification immediately after trailing edge is throttled (trailing restarts the window)", async () => {
     const renderCount = { current: 0 };
     const TestComponent = createTestComponent({ throttleMs: 100, renderCount });
 
@@ -584,7 +584,7 @@ describe("useAgent throttleMs", () => {
     const rendersAfterMount = renderCount.current;
 
     // T=0: Leading edge fires immediately
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
@@ -592,21 +592,21 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // T=10: Deferred notification — schedules trailing
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(10);
       mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
       notifyMessagesChanged(mockAgent);
     });
 
     // T=100: Trailing fires (render #2) and restarts window
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(90);
     });
     expect(renderCount.current).toBe(rendersAfterMount + 2);
     expect(screen.getByTestId("count").textContent).toBe("2");
 
     // T=101: Notification 1ms after trailing — should be DEFERRED (within new window), not immediate
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(1);
       mockAgent.messages = [
         userMsg("1", "a"),
@@ -620,7 +620,7 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("2");
 
     // T=200: New trailing fires (render #3)
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(99);
     });
     expect(renderCount.current).toBe(rendersAfterMount + 3);
@@ -648,7 +648,7 @@ describe("useAgent throttleMs", () => {
     expect(mockAgent.subscribers.length).toBe(subscriberCountBefore);
   });
 
-  it("single notification within window does not trigger a trailing re-render", () => {
+  it("single notification within window does not trigger a trailing re-render", async () => {
     const renderCount = { current: 0 };
     const TestComponent = createTestComponent({ throttleMs: 100, renderCount });
 
@@ -656,14 +656,14 @@ describe("useAgent throttleMs", () => {
     const rendersAfterMount = renderCount.current;
 
     // Leading edge — fires immediately
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
     expect(renderCount.current).toBe(rendersAfterMount + 1);
 
     // Advance well past the throttle window — no trailing should fire
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(200);
     });
 
@@ -686,7 +686,7 @@ describe("useAgent throttleMs", () => {
     const rendersAfterMount = renderCount.current;
 
     // Fire onMessagesChanged to start the throttle window
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
@@ -702,7 +702,7 @@ describe("useAgent throttleMs", () => {
     expect(renderCount.current).toBe(rendersAfterMount + 2);
   });
 
-  it("changing throttleMs from positive to 0 disables throttling immediately", () => {
+  it("changing throttleMs from positive to 0 disables throttling immediately", async () => {
     function DynamicThrottleComponent({ throttleMs }: { throttleMs: number }) {
       const { agent } = useAgent({
         agentId: "test-agent",
@@ -715,14 +715,14 @@ describe("useAgent throttleMs", () => {
     const { rerender } = render(<DynamicThrottleComponent throttleMs={200} />);
 
     // Leading edge with throttle active
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "a")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Deferred notification — within throttle window
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(50);
       mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
       notifyMessagesChanged(mockAgent);
@@ -733,7 +733,7 @@ describe("useAgent throttleMs", () => {
     rerender(<DynamicThrottleComponent throttleMs={0} />);
 
     // Both notifications should fire immediately now
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [
         userMsg("1", "a"),
         assistantMsg("2", "b"),
@@ -744,7 +744,7 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("3");
 
     // Second immediate notification also fires (no coalescing)
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [
         userMsg("1", "a"),
         assistantMsg("2", "b"),
@@ -771,7 +771,7 @@ describe("useAgent defaultThrottleMs from provider", () => {
     vi.restoreAllMocks();
   });
 
-  it("uses provider defaultThrottleMs when no explicit throttleMs is passed", () => {
+  it("uses provider defaultThrottleMs when no explicit throttleMs is passed", async () => {
     mockUseCopilotKit.mockReturnValue(
       createMockContext(mockAgent, { defaultThrottleMs: 100 }),
     );
@@ -781,14 +781,14 @@ describe("useAgent defaultThrottleMs from provider", () => {
     render(<TestComponent />);
 
     // Leading edge — fires immediately
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Second notification within 100ms window — should be deferred (throttled)
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(10);
       mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
       notifyMessagesChanged(mockAgent);
@@ -796,13 +796,13 @@ describe("useAgent defaultThrottleMs from provider", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Trailing edge fires after 100ms
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(100);
     });
     expect(screen.getByTestId("count").textContent).toBe("2");
   });
 
-  it("explicit throttleMs overrides provider defaultThrottleMs", () => {
+  it("explicit throttleMs overrides provider defaultThrottleMs", async () => {
     mockUseCopilotKit.mockReturnValue(
       createMockContext(mockAgent, { defaultThrottleMs: 5000 }),
     );
@@ -813,14 +813,14 @@ describe("useAgent defaultThrottleMs from provider", () => {
     render(<TestComponent />);
 
     // Leading edge
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Deferred within 100ms window
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(10);
       mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
       notifyMessagesChanged(mockAgent);
@@ -828,34 +828,34 @@ describe("useAgent defaultThrottleMs from provider", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // At 100ms trailing fires (not waiting for provider's 5000ms)
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(100);
     });
     expect(screen.getByTestId("count").textContent).toBe("2");
   });
 
-  it("without provider defaultThrottleMs or explicit throttleMs, behaves unthrottled", () => {
+  it("without provider defaultThrottleMs or explicit throttleMs, behaves unthrottled", async () => {
     mockUseCopilotKit.mockReturnValue(createMockContext(mockAgent));
 
     const TestComponent = createTestComponent({});
 
     render(<TestComponent />);
 
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Immediately fires — no throttle
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("2");
   });
 
-  it("explicit throttleMs: 0 overrides non-zero provider defaultThrottleMs (opt-out)", () => {
+  it("explicit throttleMs: 0 overrides non-zero provider defaultThrottleMs (opt-out)", async () => {
     mockUseCopilotKit.mockReturnValue(
       createMockContext(mockAgent, { defaultThrottleMs: 500 }),
     );
@@ -865,13 +865,13 @@ describe("useAgent defaultThrottleMs from provider", () => {
     render(<TestComponent />);
 
     // Both notifications fire immediately — throttleMs: 0 means no throttle
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
       notifyMessagesChanged(mockAgent);
     });
@@ -885,7 +885,7 @@ describe("useAgent defaultThrottleMs from provider", () => {
     { label: "-Infinity", value: -Infinity },
   ])(
     "with invalid provider defaultThrottleMs ($label), falls back to unthrottled and warns",
-    ({ value }) => {
+    async ({ value }) => {
       const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
 
       mockUseCopilotKit.mockReturnValue(
@@ -903,13 +903,13 @@ describe("useAgent defaultThrottleMs from provider", () => {
       );
 
       // Should behave as unthrottled (setter rejected the value)
-      act(() => {
+      await act(async () => {
         mockAgent.messages = [userMsg("1", "a")];
         notifyMessagesChanged(mockAgent);
       });
       expect(screen.getByTestId("count").textContent).toBe("1");
 
-      act(() => {
+      await act(async () => {
         mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
         notifyMessagesChanged(mockAgent);
       });
@@ -917,7 +917,7 @@ describe("useAgent defaultThrottleMs from provider", () => {
     },
   );
 
-  it("dynamically changing provider defaultThrottleMs updates throttle behavior", () => {
+  it("dynamically changing provider defaultThrottleMs updates throttle behavior", async () => {
     // Start with 200ms throttle from provider
     mockUseCopilotKit.mockReturnValue(
       createMockContext(mockAgent, { defaultThrottleMs: 200 }),
@@ -927,14 +927,14 @@ describe("useAgent defaultThrottleMs from provider", () => {
     const { rerender } = render(<TestComponent />);
 
     // Leading edge fires immediately
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [userMsg("1", "hello")];
       notifyMessagesChanged(mockAgent);
     });
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Deferred within 200ms window
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(10);
       mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
       notifyMessagesChanged(mockAgent);
@@ -942,7 +942,7 @@ describe("useAgent defaultThrottleMs from provider", () => {
     expect(screen.getByTestId("count").textContent).toBe("1");
 
     // Flush trailing edge
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(200);
     });
     expect(screen.getByTestId("count").textContent).toBe("2");
@@ -954,7 +954,7 @@ describe("useAgent defaultThrottleMs from provider", () => {
     rerender(<TestComponent />);
 
     // Leading edge fires immediately
-    act(() => {
+    await act(async () => {
       mockAgent.messages = [
         userMsg("1", "hello"),
         assistantMsg("2", "world"),
@@ -965,7 +965,7 @@ describe("useAgent defaultThrottleMs from provider", () => {
     expect(screen.getByTestId("count").textContent).toBe("3");
 
     // Deferred within 50ms window
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(10);
       mockAgent.messages = [
         userMsg("1", "hello"),
@@ -978,7 +978,7 @@ describe("useAgent defaultThrottleMs from provider", () => {
     expect(screen.getByTestId("count").textContent).toBe("3");
 
     // Trailing fires after only 50ms (not 200ms)
-    act(() => {
+    await act(async () => {
       vi.advanceTimersByTime(50);
     });
     expect(screen.getByTestId("count").textContent).toBe("4");