@copilotkit/runtime 1.54.1 → 1.55.0-next.8

package/src/v2/runtime/__tests__/in-process-agent-runner.test.ts

@@ -0,0 +1,1030 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { InMemoryAgentRunner } from "../runner/in-memory";
+import {
+  AbstractAgent,
+  BaseEvent,
+  EventType,
+  RunAgentInput,
+} from "@ag-ui/client";
+import { firstValueFrom } from "rxjs";
+import { toArray } from "rxjs/operators";
+
+const stripTerminalEvents = (events: BaseEvent[]) =>
+  events.filter(
+    (event) =>
+      event.type !== EventType.RUN_FINISHED &&
+      event.type !== EventType.RUN_ERROR,
+  );
+
+// Mock agent implementations for testing
+class MockAgent extends AbstractAgent {
+  private events: BaseEvent[];
+  private delay: number;
+
+  constructor(events: BaseEvent[] = [], delay: number = 0) {
+    super();
+    this.events = events;
+    this.delay = delay;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void },
+  ): Promise<void> {
+    for (const event of this.events) {
+      if (this.delay > 0) {
+        await new Promise((resolve) => setTimeout(resolve, this.delay));
+      }
+      options.onEvent({ event });
+    }
+  }
+
+  clone(): AbstractAgent {
+    return new MockAgent(this.events, this.delay);
+  }
+}
+
+class DelayedEventAgent extends AbstractAgent {
+  private eventCount: number;
+  private eventDelay: number;
+  private prefix: string;
+
+  constructor(
+    eventCount: number = 5,
+    eventDelay: number = 10,
+    prefix: string = "delayed",
+  ) {
+    super();
+    this.eventCount = eventCount;
+    this.eventDelay = eventDelay;
+    this.prefix = prefix;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void },
+  ): Promise<void> {
+    for (let i = 0; i < this.eventCount; i++) {
+      await new Promise((resolve) => setTimeout(resolve, this.eventDelay));
+      options.onEvent({
+        event: {
+          type: "message",
+          id: `${this.prefix}-${i}`,
+          timestamp: new Date().toISOString(),
+          data: { index: i, prefix: this.prefix },
+        } as BaseEvent,
+      });
+    }
+  }
+
+  clone(): AbstractAgent {
+    return new DelayedEventAgent(this.eventCount, this.eventDelay, this.prefix);
+  }
+}
+
+class ErrorThrowingAgent extends AbstractAgent {
+  private throwAfterEvents: number;
+  private errorMessage: string;
+
+  constructor(
+    throwAfterEvents: number = 2,
+    errorMessage: string = "Test error",
+  ) {
+    super();
+    this.throwAfterEvents = throwAfterEvents;
+    this.errorMessage = errorMessage;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void },
+  ): Promise<void> {
+    for (let i = 0; i < this.throwAfterEvents; i++) {
+      options.onEvent({
+        event: {
+          type: "message",
+          id: `error-agent-${i}`,
+          timestamp: new Date().toISOString(),
+          data: { index: i },
+        } as BaseEvent,
+      });
+    }
+    throw new Error(this.errorMessage);
+  }
+
+  clone(): AbstractAgent {
+    return new ErrorThrowingAgent(this.throwAfterEvents, this.errorMessage);
+  }
+}
+
+class StoppableAgent extends AbstractAgent {
+  private shouldStop = false;
+  private eventDelay: number;
+
+  constructor(eventDelay = 5) {
+    super();
+    this.eventDelay = eventDelay;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void },
+  ): Promise<void> {
+    this.shouldStop = false;
+    let counter = 0;
+
+    while (!this.shouldStop && counter < 10_000) {
+      await new Promise((resolve) => setTimeout(resolve, this.eventDelay));
+      const event: BaseEvent = {
+        type: "message",
+        id: `stoppable-${counter}`,
+        timestamp: new Date().toISOString(),
+        data: { counter },
+      } as BaseEvent;
+      options.onEvent({ event });
+      counter += 1;
+    }
+  }
+
+  abortRun(): void {
+    this.shouldStop = true;
+  }
+
+  clone(): AbstractAgent {
+    return new StoppableAgent(this.eventDelay);
+  }
+}
+
+class OpenEventsAgent extends AbstractAgent {
+  private shouldStop = false;
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void },
+  ): Promise<void> {
+    this.shouldStop = false;
+    const messageId = "open-message";
+    const toolCallId = "open-tool";
+
+    options.onEvent({
+      event: {
+        type: EventType.TEXT_MESSAGE_START,
+        messageId,
+        role: "assistant",
+      } as BaseEvent,
+    });
+
+    options.onEvent({
+      event: {
+        type: EventType.TEXT_MESSAGE_CONTENT,
+        messageId,
+        delta: "Partial content",
+      } as BaseEvent,
+    });
+
+    options.onEvent({
+      event: {
+        type: EventType.TOOL_CALL_START,
+        toolCallId,
+        toolCallName: "testTool",
+        parentMessageId: messageId,
+      } as BaseEvent,
+    });
+
+    while (!this.shouldStop) {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+  }
+
+  abortRun(): void {
+    this.shouldStop = true;
+  }
+
+  clone(): AbstractAgent {
+    return new OpenEventsAgent();
+  }
+}
+
+class MultiEventAgent extends AbstractAgent {
+  private runId: string;
+
+  constructor(runId: string) {
+    super();
+    this.runId = runId;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void },
+  ): Promise<void> {
+    // Emit different types of events
+    const eventTypes = ["start", "message", "tool_call", "tool_result", "end"];
+
+    for (const eventType of eventTypes) {
+      options.onEvent({
+        event: {
+          type: eventType,
+          id: `${this.runId}-${eventType}`,
+          timestamp: new Date().toISOString(),
+          data: {
+            runId: this.runId,
+            eventType,
+            metadata: { source: "MultiEventAgent" },
+          },
+        } as BaseEvent,
+      });
+    }
+  }
+
+  clone(): AbstractAgent {
+    return new MultiEventAgent(this.runId);
+  }
+}
+
+describe("InMemoryAgentRunner", () => {
+  let runner: InMemoryAgentRunner;
+
+  beforeEach(() => {
+    runner = new InMemoryAgentRunner();
+  });
+
+  describe("Basic Functionality", () => {
+    it("should run a single agent and collect all events", async () => {
+      const threadId = "test-thread-1";
+      const events: BaseEvent[] = [
+        {
+          type: "start",
+          id: "1",
+          timestamp: new Date().toISOString(),
+          data: {},
+        } as BaseEvent,
+        {
+          type: "message",
+          id: "2",
+          timestamp: new Date().toISOString(),
+          data: { text: "Hello" },
+        } as BaseEvent,
+        {
+          type: "end",
+          id: "3",
+          timestamp: new Date().toISOString(),
+          data: {},
+        } as BaseEvent,
+      ];
+
+      const agent = new MockAgent(events);
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-1",
+      };
+
+      const runObservable = runner.run({ threadId, agent, input });
+      const collectedEvents = await firstValueFrom(
+        runObservable.pipe(toArray()),
+      );
+
+      const agentEvents = stripTerminalEvents(collectedEvents);
+      expect(agentEvents).toEqual(events);
+    });
+
+    it("should allow connecting after run completes and receive all past events", async () => {
+      const threadId = "test-thread-3";
+      const events: BaseEvent[] = [
+        {
+          type: "message",
+          id: "past-1",
+          timestamp: new Date().toISOString(),
+          data: {},
+        } as BaseEvent,
+        {
+          type: "message",
+          id: "past-2",
+          timestamp: new Date().toISOString(),
+          data: {},
+        } as BaseEvent,
+      ];
+
+      const agent = new MockAgent(events);
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-3",
+      };
+
+      // Run and wait for completion
+      const runObservable = runner.run({ threadId, agent, input });
+      await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Connect after completion
+      const connectObservable = runner.connect({ threadId });
+      const collectedEvents = await firstValueFrom(
+        connectObservable.pipe(toArray()),
+      );
+
+      const storedAgentEvents = stripTerminalEvents(collectedEvents);
+      expect(storedAgentEvents).toEqual(events);
+    });
+  });
+
+  describe("Multiple Runs", () => {
+    it("should accumulate events from multiple sequential runs on same thread", async () => {
+      const threadId = "test-thread-multi-1";
+
+      // First run
+      const agent1 = new MultiEventAgent("run-1");
+      const input1: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-1",
+      };
+
+      const run1 = runner.run({ threadId, agent: agent1, input: input1 });
+      await firstValueFrom(run1.pipe(toArray()));
+
+      // Second run
+      const agent2 = new MultiEventAgent("run-2");
+      const input2: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-2",
+      };
+
+      const run2 = runner.run({ threadId, agent: agent2, input: input2 });
+      await firstValueFrom(run2.pipe(toArray()));
+
+      // Third run
+      const agent3 = new MultiEventAgent("run-3");
+      const input3: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-3",
+      };
+
+      const run3 = runner.run({ threadId, agent: agent3, input: input3 });
+      await firstValueFrom(run3.pipe(toArray()));
+
+      // Connect and verify all events
+      const connectObservable = runner.connect({ threadId });
+      const allEvents = await firstValueFrom(connectObservable.pipe(toArray()));
+
+      const agentEvents = stripTerminalEvents(allEvents);
+      expect(agentEvents).toHaveLength(15); // 5 events per run × 3 runs
+
+      // Verify events from all runs are present
+      const run1Events = agentEvents.filter((e) => e.id?.startsWith("run-1"));
+      const run2Events = agentEvents.filter((e) => e.id?.startsWith("run-2"));
+      const run3Events = agentEvents.filter((e) => e.id?.startsWith("run-3"));
+
+      expect(run1Events).toHaveLength(5);
+      expect(run2Events).toHaveLength(5);
+      expect(run3Events).toHaveLength(5);
+
+      // Verify order preservation
+      const runOrder = agentEvents.map(
+        (e) => e.id?.split("-")[0] + "-" + e.id?.split("-")[1],
+      );
+      expect(runOrder.slice(0, 5).every((id) => id?.startsWith("run-1"))).toBe(
+        true,
+      );
+      expect(runOrder.slice(5, 10).every((id) => id?.startsWith("run-2"))).toBe(
+        true,
+      );
+      expect(
+        runOrder.slice(10, 15).every((id) => id?.startsWith("run-3")),
+      ).toBe(true);
+    });
+
+    it("should handle connect during multiple runs", async () => {
+      const threadId = "test-thread-multi-2";
+
+      // Start first run
+      const agent1 = new DelayedEventAgent(5, 20, "first");
+      const input1: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-1",
+      };
+
+      const run1Observable = runner.run({
+        threadId,
+        agent: agent1,
+        input: input1,
+      });
+
+      // Wait a bit to ensure first run is in progress
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      // Connect during first run
+      const connectObservable = runner.connect({ threadId });
+      const eventCollector = firstValueFrom(connectObservable.pipe(toArray()));
+
+      // Wait for first run to complete
+      await firstValueFrom(run1Observable.pipe(toArray()));
+
+      // Collect all events from the connect during first run
+      const allEvents = await eventCollector;
+
+      // Connect only receives events from the first run since it completes
+      const firstRunAgentEvents = stripTerminalEvents(allEvents);
+      expect(firstRunAgentEvents).toHaveLength(5);
+      const firstRunEvents = firstRunAgentEvents.filter((e) =>
+        e.id?.startsWith("first"),
+      );
+
+      expect(firstRunEvents).toHaveLength(5);
+
+      // Start second run
+      const agent2 = new DelayedEventAgent(3, 10, "second");
+      const input2: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-2",
+      };
+
+      const run2Observable = runner.run({
+        threadId,
+        agent: agent2,
+        input: input2,
+      });
+      await firstValueFrom(run2Observable.pipe(toArray()));
+
+      // Connect after both runs to verify all events are accumulated
+      const allEventsAfter = await firstValueFrom(
+        runner.connect({ threadId }).pipe(toArray()),
+      );
+      expect(stripTerminalEvents(allEventsAfter)).toHaveLength(8); // 5 from first + 3 from second
+    });
+
+    it("should preserve event order across different agent types", async () => {
+      const threadId = "test-thread-multi-3";
+
+      // Run different types of agents
+      const agents = [
+        new MockAgent([
+          {
+            type: "mock",
+            id: "mock-1",
+            timestamp: new Date().toISOString(),
+            data: {},
+          } as BaseEvent,
+          {
+            type: "mock",
+            id: "mock-2",
+            timestamp: new Date().toISOString(),
+            data: {},
+          } as BaseEvent,
+        ]),
+        new MultiEventAgent("multi"),
+        new DelayedEventAgent(2, 0, "delayed"),
+      ];
+
+      for (let i = 0; i < agents.length; i++) {
+        const input: RunAgentInput = {
+          messages: [],
+          state: {},
+          threadId,
+          runId: `run-${i}`,
+        };
+
+        const run = runner.run({ threadId, agent: agents[i], input });
+        await firstValueFrom(run.pipe(toArray()));
+      }
+
+      // Verify all events are preserved
+      const connectObservable = runner.connect({ threadId });
+      const allEvents = await firstValueFrom(connectObservable.pipe(toArray()));
+
+      const agentEvents = stripTerminalEvents(allEvents);
+      expect(agentEvents).toHaveLength(9); // 2 + 5 + 2
+
+      // Verify event groups are in order
+      expect(agentEvents[0].id).toBe("mock-1");
+      expect(agentEvents[1].id).toBe("mock-2");
+      expect(agentEvents[2].id).toContain("multi");
+      expect(agentEvents[7].id).toContain("delayed");
+    });
+  });
+
+  describe("Concurrent Subscribers", () => {
+    it("should provide same events to multiple concurrent connect calls", async () => {
+      const threadId = "test-thread-concurrent-1";
+      const agent = new MultiEventAgent("concurrent");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-concurrent",
+      };
+
+      // Run agent
+      const runObservable = runner.run({ threadId, agent, input });
+      await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Multiple concurrent connects
+      const connect1 = runner.connect({ threadId });
+      const connect2 = runner.connect({ threadId });
+      const connect3 = runner.connect({ threadId });
+
+      const [events1, events2, events3] = await Promise.all([
+        firstValueFrom(connect1.pipe(toArray())),
+        firstValueFrom(connect2.pipe(toArray())),
+        firstValueFrom(connect3.pipe(toArray())),
+      ]);
+
+      // All should receive same events including RUN_FINISHED
+      const agentEvents1 = stripTerminalEvents(events1);
+      const agentEvents2 = stripTerminalEvents(events2);
+      const agentEvents3 = stripTerminalEvents(events3);
+      expect(agentEvents1).toHaveLength(5);
+      expect(agentEvents2).toHaveLength(5);
+      expect(agentEvents3).toHaveLength(5);
+      expect(events1).toEqual(events2);
+      expect(events2).toEqual(events3);
+    });
+
+    it("should handle late subscribers during active run", async () => {
+      const threadId = "test-thread-concurrent-2";
+      const agent = new DelayedEventAgent(10, 20, "late-sub");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-late",
+      };
+
+      // Start run
+      runner.run({ threadId, agent, input });
+
+      // Connect at different times during the run
+      await new Promise((resolve) => setTimeout(resolve, 50)); // After ~2 events
+      const connect1 = runner.connect({ threadId });
+
+      await new Promise((resolve) => setTimeout(resolve, 60)); // After ~5 events
+      const connect2 = runner.connect({ threadId });
+
+      await new Promise((resolve) => setTimeout(resolve, 80)); // After ~9 events
+      const connect3 = runner.connect({ threadId });
+
+      const [events1, events2, events3] = await Promise.all([
+        firstValueFrom(connect1.pipe(toArray())),
+        firstValueFrom(connect2.pipe(toArray())),
+        firstValueFrom(connect3.pipe(toArray())),
+      ]);
+
+      // All subscribers should eventually receive all events plus RUN_FINISHED
+      const agentEvents1 = stripTerminalEvents(events1);
+      const agentEvents2 = stripTerminalEvents(events2);
+      const agentEvents3 = stripTerminalEvents(events3);
+      expect(agentEvents1).toHaveLength(10);
+      expect(agentEvents2).toHaveLength(10);
+      expect(agentEvents3).toHaveLength(10);
+
+      // Verify they all have the same events
+      expect(events1.map((e) => e.id)).toEqual(events2.map((e) => e.id));
+      expect(events2.map((e) => e.id)).toEqual(events3.map((e) => e.id));
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should throw error when thread is already running", async () => {
+      const threadId = "test-thread-error-1";
+      const agent = new DelayedEventAgent(5, 50, "blocking");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-1",
+      };
+
+      // Start first run
+      runner.run({ threadId, agent, input });
+
+      // Try to start another run on same thread immediately
+      expect(() => {
+        runner.run({ threadId, agent, input });
+      }).toThrow("Thread already running");
+    });
+
+    it("should handle agent errors gracefully", async () => {
+      const threadId = "test-thread-error-2";
+      const agent = new ErrorThrowingAgent(3, "Agent crashed!");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-error-1",
+      };
+
+      const runObservable = runner.run({ threadId, agent, input });
+      const events = await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Should still receive events emitted before error
+      expect(events.at(-1)?.type).toBe(EventType.RUN_ERROR);
+      const preErrorEvents = events.slice(0, -1);
+      expect(preErrorEvents).toHaveLength(3);
+      expect(preErrorEvents.every((e) => e.id?.startsWith("error-agent"))).toBe(
+        true,
+      );
+
+      // Should be able to run again after error
+      const agent2 = new MockAgent([
+        {
+          type: "recovery",
+          id: "recovery-1",
+          timestamp: new Date().toISOString(),
+          data: {},
+        } as BaseEvent,
+      ]);
+
+      const input2: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-error-2",
+      };
+
+      const run2 = runner.run({ threadId, agent: agent2, input: input2 });
+      const events2 = await firstValueFrom(run2.pipe(toArray()));
+
+      const recoveryEvents = stripTerminalEvents(events2);
+      expect(recoveryEvents).toHaveLength(1); // Only events from current run
+      expect(recoveryEvents[0].id).toBe("recovery-1");
+
+      // Connect should have all events including from errored run
+      const allEvents = await firstValueFrom(
+        runner.connect({ threadId }).pipe(toArray()),
+      );
+      expect(
+        allEvents.filter((event) => event.type === EventType.RUN_ERROR).length,
+      ).toBeGreaterThanOrEqual(1);
+      const storedAgentEvents = stripTerminalEvents(allEvents);
+      expect(storedAgentEvents).toHaveLength(4); // 3 from error run + 1 from recovery
+    });
+
+    it("should properly set isRunning to false after agent error", async () => {
+      const threadId = "test-thread-error-3";
+      const agent = new ErrorThrowingAgent(1, "Quick fail");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-fail",
+      };
+
+      // Run and wait for completion (even with error)
+      const runObservable = runner.run({ threadId, agent, input });
+      await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Verify thread is not running
+      const isRunning = await runner.isRunning({ threadId });
+      expect(isRunning).toBe(false);
+
+      // Should be able to run again
+      const agent2 = new MockAgent([
+        {
+          type: "test",
+          id: "after-error",
+          timestamp: new Date().toISOString(),
+          data: {},
+        } as BaseEvent,
+      ]);
+
+      const input2: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-fail-2",
+      };
+
+      expect(() => {
+        runner.run({ threadId, agent: agent2, input: input2 });
+      }).not.toThrow();
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should return EMPTY observable when connecting to non-existent thread", async () => {
+      const connectObservable = runner.connect({
+        threadId: "non-existent-thread",
+      });
+
+      // EMPTY completes immediately with no values
+      let completed = false;
+      let eventCount = 0;
+
+      await new Promise<void>((resolve) => {
+        connectObservable.subscribe({
+          next: () => eventCount++,
+          complete: () => {
+            completed = true;
+            resolve();
+          },
+        });
+      });
+
+      expect(completed).toBe(true);
+      expect(eventCount).toBe(0);
+    });
+
+    it("should handle very large number of events", async () => {
+      const threadId = "test-thread-large";
+      const eventCount = 1000;
+      const events: BaseEvent[] = [];
+
+      for (let i = 0; i < eventCount; i++) {
+        events.push({
+          type: "bulk",
+          id: `bulk-${i}`,
+          timestamp: new Date().toISOString(),
+          data: { index: i, payload: "x".repeat(100) },
+        } as BaseEvent);
+      }
+
+      const agent = new MockAgent(events);
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-large",
+      };
+
+      // Run with large event set
+      const runObservable = runner.run({ threadId, agent, input });
+      await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Connect and verify all events are preserved
+      const connectObservable = runner.connect({ threadId });
+      const collectedEvents = await firstValueFrom(
+        connectObservable.pipe(toArray()),
+      );
+
+      const bulkEvents = stripTerminalEvents(collectedEvents);
+      expect(bulkEvents).toHaveLength(eventCount);
+      expect(bulkEvents[0].id).toBe("bulk-0");
+      expect(bulkEvents[eventCount - 1].id).toBe(`bulk-${eventCount - 1}`);
+    });
+
+    it("should return false for isRunning on non-existent thread", async () => {
+      const isRunning = await runner.isRunning({ threadId: "non-existent" });
+      expect(isRunning).toBe(false);
+    });
+
+    it("should properly track isRunning state", async () => {
+      const threadId = "test-thread-running";
+      const agent = new DelayedEventAgent(5, 20, "running");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-running",
+      };
+
+      // Check before run
+      expect(await runner.isRunning({ threadId })).toBe(false);
+
+      // Start run
+      const runObservable = runner.run({ threadId, agent, input });
+
+      // Check during run
+      expect(await runner.isRunning({ threadId })).toBe(true);
+
+      // Wait for completion
+      await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Check after run
+      expect(await runner.isRunning({ threadId })).toBe(false);
+    });
+
+    it("should return false when stopping a non-existent thread", async () => {
+      await expect(runner.stop({ threadId: "missing-thread" })).resolves.toBe(
+        false,
+      );
+    });
+
+    it("should stop an active run and complete streams", async () => {
+      const threadId = "test-thread-stop";
+      const agent = new StoppableAgent(2);
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-stop",
+      };
+
+      const run$ = runner.run({ threadId, agent, input });
+      const collected = firstValueFrom(run$.pipe(toArray()));
+
+      // Allow the run loop to start and emit a couple of events
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      expect(await runner.isRunning({ threadId })).toBe(true);
+
+      const stopped = await runner.stop({ threadId });
+      expect(stopped).toBe(true);
+
+      const events = await collected;
+      expect(events.length).toBeGreaterThan(0);
+      expect(events[events.length - 1].type).toBe(EventType.RUN_FINISHED);
+      expect(await runner.isRunning({ threadId })).toBe(false);
+    });
+
+    it("should close open text and tool events when stopping", async () => {
+      const threadId = "test-thread-open-events";
+      const agent = new OpenEventsAgent();
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-open",
+      };
+
+      const run$ = runner.run({ threadId, agent, input });
+      const collected = firstValueFrom(run$.pipe(toArray()));
+
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      await runner.stop({ threadId });
+
+      const events = await collected;
+      const endingTypes = events.slice(-4).map((event) => event.type);
+      expect(endingTypes).toEqual([
+        EventType.TEXT_MESSAGE_END,
+        EventType.TOOL_CALL_END,
+        EventType.TOOL_CALL_RESULT,
+        EventType.RUN_FINISHED,
+      ]);
+    });
+
+    it("should handle thread isolation correctly", async () => {
+      const thread1 = "test-thread-iso-1";
+      const thread2 = "test-thread-iso-2";
+
+      const agent1 = new MockAgent([
+        {
+          type: "thread1",
+          id: "t1-event",
+          timestamp: new Date().toISOString(),
+          data: {},
+        } as BaseEvent,
+      ]);
+      const agent2 = new MockAgent([
+        {
+          type: "thread2",
+          id: "t2-event",
+          timestamp: new Date().toISOString(),
+          data: {},
+        } as BaseEvent,
+      ]);
+
+      // Run on different threads
+      const run1 = runner.run({
+        threadId: thread1,
+        agent: agent1,
+        input: { messages: [], state: {}, threadId: thread1, runId: "run-t1" },
+      });
+      const run2 = runner.run({
+        threadId: thread2,
+        agent: agent2,
+        input: { messages: [], state: {}, threadId: thread2, runId: "run-t2" },
+      });
+
+      await Promise.all([
+        firstValueFrom(run1.pipe(toArray())),
+        firstValueFrom(run2.pipe(toArray())),
+      ]);
+
+      // Connect to each thread
+      const events1 = await firstValueFrom(
+        runner.connect({ threadId: thread1 }).pipe(toArray()),
+      );
+      const events2 = await firstValueFrom(
+        runner.connect({ threadId: thread2 }).pipe(toArray()),
+      );
+
+      // Verify isolation
+      const thread1Events = stripTerminalEvents(events1);
+      const thread2Events = stripTerminalEvents(events2);
+      expect(thread1Events).toHaveLength(1);
+      expect(thread1Events[0].id).toBe("t1-event");
+
+      expect(thread2Events).toHaveLength(1);
+      expect(thread2Events[0].id).toBe("t2-event");
+    });
+  });
+
+  describe("Complex Scenarios", () => {
+    it("should handle rapid sequential runs with mixed event patterns", async () => {
+      const threadId = "test-thread-complex-1";
+      const runs = [
+        {
+          agent: new MockAgent([
+            {
+              type: "instant",
+              id: "instant-1",
+              timestamp: new Date().toISOString(),
+              data: {},
+            } as BaseEvent,
+          ]),
+          runId: "run-1",
+        },
+        { agent: new DelayedEventAgent(3, 5, "delayed"), runId: "run-2" },
+        {
+          agent: new MockAgent([
+            {
+              type: "instant",
+              id: "instant-2",
+              timestamp: new Date().toISOString(),
+              data: {},
+            } as BaseEvent,
+          ]),
+          runId: "run-3",
+        },
+        { agent: new MultiEventAgent("multi"), runId: "run-4" },
+        { agent: new DelayedEventAgent(2, 10, "slow"), runId: "run-5" },
+      ];
+
+      for (const { agent, runId } of runs) {
+        const input: RunAgentInput = {
+          messages: [],
+          state: {},
+          threadId,
+          runId,
+        };
+
+        const run = runner.run({ threadId, agent, input });
+        await firstValueFrom(run.pipe(toArray()));
+      }
+
+      const allEvents = await firstValueFrom(
+        runner.connect({ threadId }).pipe(toArray()),
+      );
+
+      const agentEvents = stripTerminalEvents(allEvents);
+      expect(agentEvents).toHaveLength(12); // 1 + 3 + 1 + 5 + 2
+
+      // Verify event ordering
+      expect(agentEvents[0].id).toBe("instant-1");
+      expect(agentEvents[1].id).toContain("delayed-0");
+      expect(agentEvents[4].id).toBe("instant-2");
+      expect(agentEvents[5].id).toContain("multi-start");
+      expect(agentEvents[10].id).toContain("slow-0");
+    });
+
+    it("should handle subscriber that connects between runs", async () => {
+      const threadId = "test-thread-complex-2";
+
+      // First run
+      const agent1 = new MultiEventAgent("first");
+      const run1 = runner.run({
+        threadId,
+        agent: agent1,
+        input: { messages: [], state: {}, threadId, runId: "run-1" },
+      });
+      await firstValueFrom(run1.pipe(toArray()));
+
+      // Connect after first run - should only get first run events
+      const midConnectObservable = runner.connect({ threadId });
+      const midEvents = await firstValueFrom(
+        midConnectObservable.pipe(toArray()),
+      );
+
+      const midAgentEvents = stripTerminalEvents(midEvents);
+      expect(midAgentEvents).toHaveLength(5); // Only events from first run
+      const firstRunEvents = midAgentEvents.filter((e) =>
+        e.id?.includes("first"),
+      );
+      expect(firstRunEvents).toHaveLength(5);
+
+      // Second run
+      const agent2 = new MultiEventAgent("second");
+      const run2 = runner.run({
+        threadId,
+        agent: agent2,
+        input: { messages: [], state: {}, threadId, runId: "run-2" },
+      });
+      await firstValueFrom(run2.pipe(toArray()));
+
+      // Connect after both runs to verify all events
+      const allEvents = await firstValueFrom(
+        runner.connect({ threadId }).pipe(toArray()),
+      );
+      const allAgentEvents = stripTerminalEvents(allEvents);
+      expect(allAgentEvents).toHaveLength(10); // Events from both runs
+
+      const allFirstRunEvents = allAgentEvents.filter((e) =>
+        e.id?.includes("first"),
+      );
+      const allSecondRunEvents = allAgentEvents.filter((e) =>
+        e.id?.includes("second"),
+      );
+      expect(allFirstRunEvents).toHaveLength(5);
+      expect(allSecondRunEvents).toHaveLength(5);
+    });
+  });
+});