@copilotkit/react-core 1.57.3 → 1.58.0-canary.thread-id-propagation

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

@@ -1,1029 +0,0 @@
-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 "../../context";
-import { MockStepwiseAgent } from "../../__tests__/utils/test-helpers";
-import {
-  CopilotKitCore,
-  CopilotKitCoreRuntimeConnectionStatus,
-} from "@copilotkit/core";
-import type { Message } from "@ag-ui/core";
-import type { RunAgentInput } from "@ag-ui/client";
-
-vi.mock("../../context", () => ({
-  useCopilotKit: vi.fn(),
-}));
-
-vi.mock("../../providers/CopilotChatConfigurationProvider", () => ({
-  useCopilotChatConfiguration: vi.fn(() => undefined),
-}));
-
-const mockUseCopilotKit = useCopilotKit as ReturnType<typeof vi.fn>;
-
-// ---------------------------------------------------------------------------
-// Message factories — eliminates `as any` on every message literal
-// ---------------------------------------------------------------------------
-
-function userMsg(id: string, content = `msg-${id}`): Message {
-  return { id, role: "user" as const, content };
-}
-
-function assistantMsg(id: string, content = `msg-${id}`): Message {
-  return { id, role: "assistant" as const, content };
-}
-
-/** Create N alternating user/assistant messages (ids "1" … "N") */
-function createMessages(count: number): Message[] {
-  return Array.from({ length: count }, (_, i) =>
-    i % 2 === 0
-      ? userMsg(String(i + 1), `tok${i + 1}`)
-      : assistantMsg(String(i + 1), `tok${i + 1}`),
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Subscriber notification helpers
-// ---------------------------------------------------------------------------
-
-/** Helper: fire onMessagesChanged on all agent subscribers */
-function notifyMessagesChanged(agent: MockStepwiseAgent) {
-  agent.subscribers.forEach((s) =>
-    s.onMessagesChanged?.({
-      messages: agent.messages,
-      state: agent.state,
-      agent,
-    }),
-  );
-}
-
-/** Helper: fire onStateChanged on all agent subscribers */
-function notifyStateChanged(agent: MockStepwiseAgent) {
-  agent.subscribers.forEach((s) =>
-    s.onStateChanged?.({
-      state: agent.state,
-      messages: agent.messages,
-      agent,
-    }),
-  );
-}
-
-function createMockRunAgentInput(
-  overrides?: Partial<RunAgentInput>,
-): RunAgentInput {
-  return {
-    threadId: "t-1",
-    runId: "r-1",
-    state: {},
-    messages: [],
-    tools: [],
-    context: [],
-    forwardedProps: {},
-    ...overrides,
-  };
-}
-
-/** Helper: fire onRunInitialized on all agent subscribers */
-function notifyRunInitialized(agent: MockStepwiseAgent) {
-  agent.subscribers.forEach((s) =>
-    s.onRunInitialized?.({
-      messages: agent.messages,
-      state: agent.state,
-      agent,
-      input: createMockRunAgentInput(),
-    }),
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Test component factory
-// ---------------------------------------------------------------------------
-
-/** Helper: create a test component that tracks render count */
-function createTestComponent(
-  options: {
-    updates?: UseAgentUpdate[];
-    throttleMs?: number;
-    renderCount?: { current: number };
-  } = {},
-) {
-  const {
-    updates = [UseAgentUpdate.OnMessagesChanged],
-    throttleMs,
-    renderCount,
-  } = options;
-
-  return function TestComponent() {
-    if (renderCount) renderCount.current++;
-    const { agent } = useAgent({
-      agentId: "test-agent",
-      updates,
-      throttleMs,
-    });
-    return (
-      <>
-        <div data-testid="count">{agent.messages.length}</div>
-        <div data-testid="state">{JSON.stringify(agent.state)}</div>
-      </>
-    );
-  };
-}
-
-/** Factory for the mock return value of useCopilotKit.
- *  Uses a real CopilotKitCore instance so subscribeToAgentWithOptions (with its throttle
- *  logic) is exercised end-to-end rather than mocked. */
-function createMockContext(
-  agent: MockStepwiseAgent,
-  overrides: { defaultThrottleMs?: number } = {},
-) {
-  const core = new CopilotKitCore({
-    runtimeUrl: "http://localhost:3000/api/copilot",
-  });
-  if (overrides.defaultThrottleMs !== undefined) {
-    core.setDefaultThrottleMs(overrides.defaultThrottleMs);
-  }
-  return {
-    copilotkit: {
-      getAgent: () => agent,
-      runtimeUrl: "http://localhost:3000/api/copilot",
-      runtimeConnectionStatus: CopilotKitCoreRuntimeConnectionStatus.Connected,
-      runtimeTransport: "rest",
-      headers: {},
-      agents: { [String(agent.agentId)]: agent },
-      defaultThrottleMs: core.defaultThrottleMs,
-      subscribeToAgentWithOptions: core.subscribeToAgentWithOptions.bind(core),
-    },
-    executingToolCallIds: new Set(),
-  };
-}
-
-describe("useAgent throttleMs", () => {
-  let mockAgent: MockStepwiseAgent;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    mockAgent = new MockStepwiseAgent();
-    mockAgent.agentId = "test-agent";
-
-    mockUseCopilotKit.mockReturnValue(createMockContext(mockAgent));
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  });
-
-  it("without throttleMs, component reflects latest messages after notification", async () => {
-    const TestComponent = createTestComponent();
-
-    render(<TestComponent />);
-    expect(screen.getByTestId("count").textContent).toBe("0");
-
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "hello")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    expect(screen.getByTestId("count").textContent).toBe("1");
-  });
-
-  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");
-
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "hello")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Second notification also fires immediately (no throttle)
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    expect(screen.getByTestId("count").textContent).toBe("2");
-  });
-
-  it("with throttleMs, first notification fires immediately (leading edge)", async () => {
-    const TestComponent = createTestComponent({ throttleMs: 100 });
-
-    render(<TestComponent />);
-    expect(screen.getByTestId("count").textContent).toBe("0");
-
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "hello")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    expect(screen.getByTestId("count").textContent).toBe("1");
-  });
-
-  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
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "a")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Second notification 10ms later — within throttle window
-    await act(async () => {
-      vi.advanceTimersByTime(10);
-      mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    // The throttle should have deferred this — component still shows 1
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Advance past the throttle window — trailing edge fires
-    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)", async () => {
-    const renderCount = { current: 0 };
-    const TestComponent = createTestComponent({ throttleMs: 100, renderCount });
-
-    render(<TestComponent />);
-    const rendersAfterMount = renderCount.current;
-
-    // Leading edge — fires immediately
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "tok1")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(renderCount.current).toBe(rendersAfterMount + 1);
-
-    // Fire 10 rapid notifications within the throttle window (1ms apart)
-    for (let i = 2; i <= 11; i++) {
-      await act(async () => {
-        vi.advanceTimersByTime(1);
-        mockAgent.messages = createMessages(i);
-        notifyMessagesChanged(mockAgent);
-      });
-    }
-
-    // Should still be at leading-edge render count (burst was coalesced)
-    expect(renderCount.current).toBe(rendersAfterMount + 1);
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Advance past the throttle window — trailing edge fires once
-    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)", async () => {
-    const TestComponent = createTestComponent({ throttleMs: 100 });
-
-    render(<TestComponent />);
-
-    // Leading edge
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "a")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Second notification — deferred
-    await act(async () => {
-      vi.advanceTimersByTime(10);
-      mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    // Trailing edge fires
-    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
-    await act(async () => {
-      vi.advanceTimersByTime(200);
-      mockAgent.messages = [
-        userMsg("1", "a"),
-        assistantMsg("2", "b"),
-        userMsg("3", "c"),
-      ];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("3");
-  });
-
-  it("with throttleMs, onStateChanged is also throttled (shared window)", async () => {
-    const TestComponent = createTestComponent({
-      updates: [
-        UseAgentUpdate.OnMessagesChanged,
-        UseAgentUpdate.OnStateChanged,
-      ],
-      throttleMs: 100,
-    });
-
-    render(<TestComponent />);
-
-    // Fire onMessagesChanged to start the throttle window (leading edge)
-    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)
-    await act(async () => {
-      vi.advanceTimersByTime(10);
-      mockAgent.state = { count: 42 };
-      notifyStateChanged(mockAgent);
-    });
-
-    // State update is pending, not yet rendered
-    expect(screen.getByTestId("state").textContent).toBe("{}");
-
-    // Trailing edge fires after the window — await so microtask from
-    // batchedForceUpdate flushes and triggers the React re-render.
-    await act(async () => {
-      vi.advanceTimersByTime(100);
-    });
-
-    expect(screen.getByTestId("state").textContent).toBe('{"count":42}');
-  });
-
-  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
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "a")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    // Second notification — schedules trailing timer
-    await act(async () => {
-      vi.advanceTimersByTime(10);
-      mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    const countBeforeUnmount = renderCount.current;
-
-    // Unmount before trailing fires
-    unmount();
-
-    // Advancing past the window should NOT cause additional renders
-    await act(async () => {
-      vi.advanceTimersByTime(100);
-    });
-
-    expect(renderCount.current).toBe(countBeforeUnmount);
-  });
-
-  it("with throttleMs and only OnStateChanged subscribed, first state fires on leading edge", async () => {
-    const TestComponent = createTestComponent({
-      updates: [UseAgentUpdate.OnStateChanged],
-      throttleMs: 100,
-    });
-
-    render(<TestComponent />);
-
-    // First onStateChanged fires immediately (leading edge) — await so
-    // microtask from batchedForceUpdate flushes.
-    await act(async () => {
-      mockAgent.state = { value: "test" };
-      notifyStateChanged(mockAgent);
-    });
-
-    expect(screen.getByTestId("state").textContent).toBe('{"value":"test"}');
-
-    // No onMessagesChanged subscription should exist — messages notification
-    // does nothing because the handler was never registered.
-    act(() => {
-      mockAgent.messages = [userMsg("1", "a")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    expect(screen.getByTestId("state").textContent).toBe('{"value":"test"}');
-  });
-
-  it.each([
-    { label: "NaN", value: NaN },
-    { label: "Infinity", value: Infinity },
-    { label: "-1", value: -1 },
-    { label: "-Infinity", value: -Infinity },
-  ])(
-    "with invalid throttleMs ($label), falls back to unthrottled and warns",
-    async ({ value }) => {
-      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      const TestComponent = createTestComponent({ throttleMs: value });
-
-      render(<TestComponent />);
-
-      // Should warn about the invalid value
-      expect(errorSpy).toHaveBeenCalledWith(
-        expect.stringContaining(
-          "throttleMs must be a non-negative finite number",
-        ),
-        expect.any(Error),
-      );
-
-      // Should behave as unthrottled — every notification fires immediately
-      await act(async () => {
-        mockAgent.messages = [userMsg("1", "a")];
-        notifyMessagesChanged(mockAgent);
-      });
-      expect(screen.getByTestId("count").textContent).toBe("1");
-
-      await act(async () => {
-        mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
-        notifyMessagesChanged(mockAgent);
-      });
-      expect(screen.getByTestId("count").textContent).toBe("2");
-    },
-  );
-
-  it("trailing-edge render reflects the latest messages, not stale data", async () => {
-    const TestComponent = createTestComponent({ throttleMs: 100 });
-    render(<TestComponent />);
-
-    // Leading edge
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "A")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Multiple deferred notifications with increasing messages
-    await act(async () => {
-      vi.advanceTimersByTime(20);
-      mockAgent.messages = [userMsg("1", "A"), assistantMsg("2", "B")];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    await act(async () => {
-      vi.advanceTimersByTime(20);
-      mockAgent.messages = [
-        userMsg("1", "A"),
-        assistantMsg("2", "B"),
-        assistantMsg("3", "C"),
-      ];
-      notifyMessagesChanged(mockAgent);
-    });
-
-    // Still deferred
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Trailing edge fires — must show all 3 messages (latest state)
-    await act(async () => {
-      vi.advanceTimersByTime(100);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("3");
-  });
-
-  it("trailing edge fires at exactly throttleMs after the leading edge", async () => {
-    const TestComponent = createTestComponent({ throttleMs: 100 });
-    render(<TestComponent />);
-
-    // Leading edge at T=0
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "a")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Deferred notification at T=40
-    await act(async () => {
-      vi.advanceTimersByTime(40);
-      mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // At T=99, trailing has NOT fired yet
-    await act(async () => {
-      vi.advanceTimersByTime(59);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // At T=100, trailing fires
-    await act(async () => {
-      vi.advanceTimersByTime(1);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("2");
-  });
-
-  it("changing throttleMs cleans up pending timers from the previous configuration", async () => {
-    function DynamicThrottleComponent({ throttleMs }: { throttleMs: number }) {
-      const { agent } = useAgent({
-        agentId: "test-agent",
-        updates: [UseAgentUpdate.OnMessagesChanged],
-        throttleMs,
-      });
-      return <div data-testid="count">{agent.messages.length}</div>;
-    }
-
-    const { rerender } = render(<DynamicThrottleComponent throttleMs={200} />);
-
-    // Leading edge
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "a")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Deferred notification — pending timer set for 200ms
-    await act(async () => {
-      vi.advanceTimersByTime(50);
-      mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Change throttleMs — effect re-runs, old 200ms timer should be cleaned up
-    rerender(<DynamicThrottleComponent throttleMs={50} />);
-
-    // New notification fires as leading edge under the new 50ms throttle
-    await act(async () => {
-      mockAgent.messages = [
-        userMsg("1", "a"),
-        assistantMsg("2", "b"),
-        userMsg("3", "c"),
-      ];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("3");
-
-    // Advance past what would have been the old 200ms trailing edge —
-    // no ghost render should occur from the old timer
-    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)", async () => {
-    const renderCount = { current: 0 };
-    const TestComponent = createTestComponent({ throttleMs: 100, renderCount });
-
-    render(<TestComponent />);
-    const rendersAfterMount = renderCount.current;
-
-    // T=0: Leading edge fires immediately
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "a")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(renderCount.current).toBe(rendersAfterMount + 1);
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // T=10: Deferred notification — schedules trailing
-    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
-    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
-    await act(async () => {
-      vi.advanceTimersByTime(1);
-      mockAgent.messages = [
-        userMsg("1", "a"),
-        assistantMsg("2", "b"),
-        userMsg("3", "c"),
-      ];
-      notifyMessagesChanged(mockAgent);
-    });
-    // Still 2 — the notification was deferred, not a new leading edge
-    expect(renderCount.current).toBe(rendersAfterMount + 2);
-    expect(screen.getByTestId("count").textContent).toBe("2");
-
-    // T=200: New trailing fires (render #3)
-    await act(async () => {
-      vi.advanceTimersByTime(99);
-    });
-    expect(renderCount.current).toBe(rendersAfterMount + 3);
-    expect(screen.getByTestId("count").textContent).toBe("3");
-  });
-
-  it("cleans up all subscriptions after unmount", () => {
-    const TestComponent = createTestComponent({
-      updates: [
-        UseAgentUpdate.OnMessagesChanged,
-        UseAgentUpdate.OnStateChanged,
-      ],
-      throttleMs: 100,
-    });
-
-    const subscriberCountBefore = mockAgent.subscribers.length;
-    const { unmount } = render(<TestComponent />);
-
-    // Should have added subscriber(s)
-    expect(mockAgent.subscribers.length).toBeGreaterThan(subscriberCountBefore);
-
-    unmount();
-
-    // All subscriptions should be cleaned up
-    expect(mockAgent.subscribers.length).toBe(subscriberCountBefore);
-  });
-
-  it("single notification within window does not trigger a trailing re-render", async () => {
-    const renderCount = { current: 0 };
-    const TestComponent = createTestComponent({ throttleMs: 100, renderCount });
-
-    render(<TestComponent />);
-    const rendersAfterMount = renderCount.current;
-
-    // Leading edge — fires immediately
-    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
-    await act(async () => {
-      vi.advanceTimersByTime(200);
-    });
-
-    // No additional render since there was no second notification
-    expect(renderCount.current).toBe(rendersAfterMount + 1);
-  });
-
-  it("with throttleMs, onRunInitialized still fires immediately during throttle window", async () => {
-    const renderCount = { current: 0 };
-    const TestComponent = createTestComponent({
-      updates: [
-        UseAgentUpdate.OnMessagesChanged,
-        UseAgentUpdate.OnRunStatusChanged,
-      ],
-      throttleMs: 100,
-      renderCount,
-    });
-
-    render(<TestComponent />);
-    const rendersAfterMount = renderCount.current;
-
-    // Fire onMessagesChanged to start the throttle window
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "a")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(renderCount.current).toBe(rendersAfterMount + 1);
-
-    // Fire onRunInitialized 10ms later — fires via microtask batch
-    await act(async () => {
-      vi.advanceTimersByTime(10);
-      notifyRunInitialized(mockAgent);
-    });
-
-    // Run status notification fires via microtask batch
-    expect(renderCount.current).toBe(rendersAfterMount + 2);
-  });
-
-  it("changing throttleMs from positive to 0 disables throttling immediately", async () => {
-    function DynamicThrottleComponent({ throttleMs }: { throttleMs: number }) {
-      const { agent } = useAgent({
-        agentId: "test-agent",
-        updates: [UseAgentUpdate.OnMessagesChanged],
-        throttleMs,
-      });
-      return <div data-testid="count">{agent.messages.length}</div>;
-    }
-
-    const { rerender } = render(<DynamicThrottleComponent throttleMs={200} />);
-
-    // Leading edge with throttle active
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "a")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Deferred notification — within throttle window
-    await act(async () => {
-      vi.advanceTimersByTime(50);
-      mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Switch to unthrottled
-    rerender(<DynamicThrottleComponent throttleMs={0} />);
-
-    // Both notifications should fire immediately now
-    await act(async () => {
-      mockAgent.messages = [
-        userMsg("1", "a"),
-        assistantMsg("2", "b"),
-        userMsg("3", "c"),
-      ];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("3");
-
-    // Second immediate notification also fires (no coalescing)
-    await act(async () => {
-      mockAgent.messages = [
-        userMsg("1", "a"),
-        assistantMsg("2", "b"),
-        userMsg("3", "c"),
-        assistantMsg("4", "d"),
-      ];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("4");
-  });
-});
-
-describe("useAgent defaultThrottleMs from provider", () => {
-  let mockAgent: MockStepwiseAgent;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    mockAgent = new MockStepwiseAgent();
-    mockAgent.agentId = "test-agent";
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  });
-
-  it("uses provider defaultThrottleMs when no explicit throttleMs is passed", async () => {
-    mockUseCopilotKit.mockReturnValue(
-      createMockContext(mockAgent, { defaultThrottleMs: 100 }),
-    );
-
-    const TestComponent = createTestComponent({ throttleMs: undefined });
-
-    render(<TestComponent />);
-
-    // Leading edge — fires immediately
-    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)
-    await act(async () => {
-      vi.advanceTimersByTime(10);
-      mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Trailing edge fires after 100ms
-    await act(async () => {
-      vi.advanceTimersByTime(100);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("2");
-  });
-
-  it("explicit throttleMs overrides provider defaultThrottleMs", async () => {
-    mockUseCopilotKit.mockReturnValue(
-      createMockContext(mockAgent, { defaultThrottleMs: 5000 }),
-    );
-
-    // Explicit throttleMs=100 should override provider's 5000
-    const TestComponent = createTestComponent({ throttleMs: 100 });
-
-    render(<TestComponent />);
-
-    // Leading edge
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "hello")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Deferred within 100ms window
-    await act(async () => {
-      vi.advanceTimersByTime(10);
-      mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // At 100ms trailing fires (not waiting for provider's 5000ms)
-    await act(async () => {
-      vi.advanceTimersByTime(100);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("2");
-  });
-
-  it("without provider defaultThrottleMs or explicit throttleMs, behaves unthrottled", async () => {
-    mockUseCopilotKit.mockReturnValue(createMockContext(mockAgent));
-
-    const TestComponent = createTestComponent({});
-
-    render(<TestComponent />);
-
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "hello")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Immediately fires — no throttle
-    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)", async () => {
-    mockUseCopilotKit.mockReturnValue(
-      createMockContext(mockAgent, { defaultThrottleMs: 500 }),
-    );
-
-    const TestComponent = createTestComponent({ throttleMs: 0 });
-
-    render(<TestComponent />);
-
-    // Both notifications fire immediately — throttleMs: 0 means no throttle
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "hello")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("2");
-  });
-
-  it.each([
-    { label: "NaN", value: NaN },
-    { label: "Infinity", value: Infinity },
-    { label: "-1", value: -1 },
-    { label: "-Infinity", value: -Infinity },
-  ])(
-    "with invalid provider defaultThrottleMs ($label), falls back to unthrottled and warns",
-    async ({ value }) => {
-      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-      mockUseCopilotKit.mockReturnValue(
-        createMockContext(mockAgent, { defaultThrottleMs: value }),
-      );
-
-      const TestComponent = createTestComponent({ throttleMs: undefined });
-
-      render(<TestComponent />);
-
-      // The core setter rejects invalid values and logs an error
-      expect(errorSpy).toHaveBeenCalledWith(
-        expect.stringContaining("must be a non-negative finite number"),
-        expect.any(Error),
-      );
-
-      // Should behave as unthrottled (setter rejected the value)
-      await act(async () => {
-        mockAgent.messages = [userMsg("1", "a")];
-        notifyMessagesChanged(mockAgent);
-      });
-      expect(screen.getByTestId("count").textContent).toBe("1");
-
-      await act(async () => {
-        mockAgent.messages = [userMsg("1", "a"), assistantMsg("2", "b")];
-        notifyMessagesChanged(mockAgent);
-      });
-      expect(screen.getByTestId("count").textContent).toBe("2");
-    },
-  );
-
-  it("dynamically changing provider defaultThrottleMs updates throttle behavior", async () => {
-    // Start with 200ms throttle from provider
-    mockUseCopilotKit.mockReturnValue(
-      createMockContext(mockAgent, { defaultThrottleMs: 200 }),
-    );
-
-    const TestComponent = createTestComponent({ throttleMs: undefined });
-    const { rerender } = render(<TestComponent />);
-
-    // Leading edge fires immediately
-    await act(async () => {
-      mockAgent.messages = [userMsg("1", "hello")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Deferred within 200ms window
-    await act(async () => {
-      vi.advanceTimersByTime(10);
-      mockAgent.messages = [userMsg("1", "hello"), assistantMsg("2", "world")];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("1");
-
-    // Flush trailing edge
-    await act(async () => {
-      vi.advanceTimersByTime(200);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("2");
-
-    // Change provider default to 50ms
-    mockUseCopilotKit.mockReturnValue(
-      createMockContext(mockAgent, { defaultThrottleMs: 50 }),
-    );
-    rerender(<TestComponent />);
-
-    // Leading edge fires immediately
-    await act(async () => {
-      mockAgent.messages = [
-        userMsg("1", "hello"),
-        assistantMsg("2", "world"),
-        userMsg("3", "new"),
-      ];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("3");
-
-    // Deferred within 50ms window
-    await act(async () => {
-      vi.advanceTimersByTime(10);
-      mockAgent.messages = [
-        userMsg("1", "hello"),
-        assistantMsg("2", "world"),
-        userMsg("3", "new"),
-        assistantMsg("4", "reply"),
-      ];
-      notifyMessagesChanged(mockAgent);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("3");
-
-    // Trailing fires after only 50ms (not 200ms)
-    await act(async () => {
-      vi.advanceTimersByTime(50);
-    });
-    expect(screen.getByTestId("count").textContent).toBe("4");
-  });
-});
-
-describe("CopilotKitCore.setDefaultThrottleMs", () => {
-  it("stores valid values", () => {
-    const core = new CopilotKitCore({});
-    core.setDefaultThrottleMs(100);
-    expect(core.defaultThrottleMs).toBe(100);
-  });
-
-  it("stores 0", () => {
-    const core = new CopilotKitCore({});
-    core.setDefaultThrottleMs(100);
-    core.setDefaultThrottleMs(0);
-    expect(core.defaultThrottleMs).toBe(0);
-  });
-
-  it("stores undefined", () => {
-    const core = new CopilotKitCore({});
-    core.setDefaultThrottleMs(100);
-    core.setDefaultThrottleMs(undefined);
-    expect(core.defaultThrottleMs).toBeUndefined();
-  });
-
-  it.each([
-    { label: "NaN", value: NaN },
-    { label: "Infinity", value: Infinity },
-    { label: "-1", value: -1 },
-    { label: "-Infinity", value: -Infinity },
-  ])(
-    "rejects invalid value ($label) and preserves previous value",
-    ({ value }) => {
-      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      const core = new CopilotKitCore({});
-      core.setDefaultThrottleMs(200);
-      core.setDefaultThrottleMs(value);
-      expect(core.defaultThrottleMs).toBe(200);
-      expect(errorSpy).toHaveBeenCalledWith(
-        expect.stringContaining("must be a non-negative finite number"),
-        expect.any(Error),
-      );
-      errorSpy.mockRestore();
-    },
-  );
-});