@copilotkitnext/runtime 0.0.1

package/src/runner/__tests__/enterprise-runner.test.ts

@@ -0,0 +1,992 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Kysely, SqliteDialect } from 'kysely';
+import Database from 'better-sqlite3';
+import IORedisMock from 'ioredis-mock';
+import { EnterpriseAgentRunner } from '../enterprise';
+import { EventType } from '@ag-ui/client';
+import type { AbstractAgent, RunAgentInput, BaseEvent, Message } from '@ag-ui/client';
+import { firstValueFrom, toArray } from 'rxjs';
+
+// Mock agent that takes custom events
+class CustomEventAgent implements AbstractAgent {
+  private events: BaseEvent[];
+
+  constructor(events: BaseEvent[] = []) {
+    this.events = events;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    callbacks: {
+      onEvent: (params: { event: any }) => void | Promise<void>;
+      onNewMessage?: (params: { message: any }) => void | Promise<void>;
+      onRunStartedEvent?: () => void | Promise<void>;
+    }
+  ): Promise<void> {
+    if (callbacks.onRunStartedEvent) {
+      await callbacks.onRunStartedEvent();
+    }
+    
+    for (const event of this.events) {
+      await callbacks.onEvent({ event });
+    }
+  }
+}
+
+// Mock agent for testing
+class MockAgent implements AbstractAgent {
+  async runAgent(
+    input: RunAgentInput,
+    callbacks: {
+      onEvent: (params: { event: any }) => void | Promise<void>;
+      onNewMessage?: (params: { message: any }) => void | Promise<void>;
+      onRunStartedEvent?: () => void | Promise<void>;
+    }
+  ): Promise<void> {
+    // Emit run started
+    if (callbacks.onRunStartedEvent) {
+      await callbacks.onRunStartedEvent();
+    }
+    
+    // Emit some events
+    await callbacks.onEvent({
+      event: {
+        type: EventType.RUN_STARTED,
+        threadId: input.threadId,
+        runId: input.runId,
+      }
+    });
+    
+    // Emit a text message
+    await callbacks.onEvent({
+      event: {
+        type: EventType.TEXT_MESSAGE_START,
+        messageId: 'test-msg-1',
+        role: 'assistant',
+      }
+    });
+    
+    await callbacks.onEvent({
+      event: {
+        type: EventType.TEXT_MESSAGE_CONTENT,
+        messageId: 'test-msg-1',
+        delta: 'Hello from agent',
+      }
+    });
+    
+    await callbacks.onEvent({
+      event: {
+        type: EventType.TEXT_MESSAGE_END,
+        messageId: 'test-msg-1',
+      }
+    });
+    
+    // Emit run finished
+    await callbacks.onEvent({
+      event: {
+        type: EventType.RUN_FINISHED,
+        threadId: input.threadId,
+        runId: input.runId,
+      }
+    });
+  }
+}
+
+// Error agent for testing
+class ErrorAgent implements AbstractAgent {
+  async runAgent(
+    input: RunAgentInput,
+    callbacks: {
+      onEvent: (params: { event: any }) => void | Promise<void>;
+      onNewMessage?: (params: { message: any }) => void | Promise<void>;
+      onRunStartedEvent?: () => void | Promise<void>;
+    }
+  ): Promise<void> {
+    await callbacks.onEvent({
+      event: {
+        type: EventType.RUN_STARTED,
+        threadId: input.threadId,
+        runId: input.runId,
+      }
+    });
+    
+    await callbacks.onEvent({
+      event: {
+        type: EventType.RUN_ERROR,
+        error: 'Test error',
+      }
+    });
+  }
+}
+
+describe('EnterpriseAgentRunner', () => {
+  let db: Kysely<any>;
+  let redis: any;
+  let redisSub: any;
+  let runner: EnterpriseAgentRunner;
+  
+  beforeEach(async () => {
+    // In-memory SQLite for testing
+    db = new Kysely({
+      dialect: new SqliteDialect({
+        database: new Database(':memory:')
+      })
+    });
+    
+    // Mock Redis for unit tests
+    redis = new IORedisMock();
+    redisSub = redis.duplicate();
+    
+    runner = new EnterpriseAgentRunner({
+      kysely: db,
+      redis,
+      redisSub,
+      streamRetentionMs: 60000,  // 1 minute for tests
+      streamActiveTTLMs: 10000,   // 10 seconds for tests
+      lockTTLMs: 30000            // 30 seconds for tests
+    });
+    
+    // Allow schema to initialize
+    await new Promise(resolve => setTimeout(resolve, 100));
+  });
+  
+  afterEach(async () => {
+    await runner.close();
+  });
+  
+  it('should prevent concurrent runs on same thread', async () => {
+    // Create a slow agent that takes time to complete
+    const slowAgent: AbstractAgent = {
+      async runAgent(input, callbacks) {
+        if (callbacks.onRunStartedEvent) {
+          await callbacks.onRunStartedEvent();
+        }
+        
+        await callbacks.onEvent({
+          event: {
+            type: EventType.RUN_STARTED,
+            threadId: input.threadId,
+            runId: input.runId,
+          }
+        });
+        
+        // Simulate long running task
+        await new Promise(resolve => setTimeout(resolve, 500));
+        
+        await callbacks.onEvent({
+          event: {
+            type: EventType.RUN_FINISHED,
+            threadId: input.threadId,
+            runId: input.runId,
+          }
+        });
+      }
+    };
+    
+    const threadId = 'test-thread-1';
+    const input1: RunAgentInput = {
+      runId: 'run-1',
+      threadId,
+      messages: [],
+    };
+    const input2: RunAgentInput = {
+      runId: 'run-2',
+      threadId,
+      messages: [],
+    };
+    
+    // Start first run
+    const run1 = runner.run({ threadId, agent: slowAgent, input: input1 });
+    
+    // Wait a bit for first run to acquire lock
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    // Try to start second run on same thread - should error
+    const run2 = runner.run({ threadId, agent: slowAgent, input: input2 });
+    
+    let errorReceived = false;
+    let completedWithoutError = false;
+    
+    await new Promise<void>((resolve) => {
+      run2.subscribe({
+        next: () => {},
+        error: (err) => {
+          errorReceived = true;
+          expect(err.message).toBe('Thread already running');
+          resolve();
+        },
+        complete: () => {
+          completedWithoutError = true;
+          resolve();
+        }
+      });
+    });
+    
+    expect(errorReceived).toBe(true);
+    expect(completedWithoutError).toBe(false);
+    
+    // Let first run complete
+    const events1 = await firstValueFrom(run1.pipe(toArray()));
+    expect(events1.length).toBeGreaterThan(0);
+  });
+  
+  it('should handle RUN_FINISHED event correctly', async () => {
+    const agent = new MockAgent();
+    const threadId = 'test-thread-2';
+    const input: RunAgentInput = {
+      runId: 'run-finished',
+      threadId,
+      messages: [],
+    };
+    
+    const events = await firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Should contain RUN_FINISHED event
+    const runFinishedEvent = events.find(e => e.type === EventType.RUN_FINISHED);
+    expect(runFinishedEvent).toBeDefined();
+    
+    // Thread should not be running after completion
+    const isRunning = await runner.isRunning({ threadId });
+    expect(isRunning).toBe(false);
+    
+    // Stream should have retention TTL
+    const streamKey = `stream:${threadId}:${input.runId}`;
+    const ttl = await redis.pttl(streamKey);
+    expect(ttl).toBeGreaterThan(0);
+    expect(ttl).toBeLessThanOrEqual(60000); // retention period
+  });
+  
+  it('should handle RUN_ERROR event correctly', async () => {
+    const agent = new ErrorAgent();
+    const threadId = 'test-thread-3';
+    const input: RunAgentInput = {
+      runId: 'run-error',
+      threadId,
+      messages: [],
+    };
+    
+    const events = await firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Should contain RUN_ERROR event
+    const runErrorEvent = events.find(e => e.type === EventType.RUN_ERROR);
+    expect(runErrorEvent).toBeDefined();
+    
+    // Thread should not be running after error
+    const isRunning = await runner.isRunning({ threadId });
+    expect(isRunning).toBe(false);
+  });
+  
+  it('should allow late readers to catch up during retention period', async () => {
+    const agent = new MockAgent();
+    const threadId = 'test-thread-4';
+    const input: RunAgentInput = {
+      runId: 'run-retention',
+      threadId,
+      messages: [],
+    };
+    
+    // Start and complete a run
+    const runEvents = await firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Wait a bit
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    // Connect should still get all events
+    const connectEvents = await firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    
+    // Should get the same events (after compaction)
+    expect(connectEvents.length).toBeGreaterThan(0);
+    
+    // Should include text message events
+    const textStartEvents = connectEvents.filter(e => e.type === EventType.TEXT_MESSAGE_START);
+    expect(textStartEvents.length).toBeGreaterThan(0);
+  });
+  
+  it('should handle connect() with no active runs', async () => {
+    const threadId = 'test-thread-5';
+    
+    // Connect to thread with no runs
+    const events = await firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    
+    // Should complete with empty array
+    expect(events).toEqual([]);
+  });
+  
+  it('should handle connect() during active run', async () => {
+    const agent = new MockAgent();
+    const threadId = 'test-thread-6';
+    const input: RunAgentInput = {
+      runId: 'run-active',
+      threadId,
+      messages: [],
+    };
+    
+    // Start a run but don't wait for it
+    runner.run({ threadId, agent, input });
+    
+    // Wait for run to start
+    await new Promise(resolve => setTimeout(resolve, 50));
+    
+    // Connect while run is active
+    const connectPromise = firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    
+    // Should eventually complete when run finishes
+    const events = await connectPromise;
+    expect(events.length).toBeGreaterThan(0);
+    
+    // Should include RUN_FINISHED
+    const finishedEvent = events.find(e => e.type === EventType.RUN_FINISHED);
+    expect(finishedEvent).toBeDefined();
+  });
+  
+  it('should handle stop() correctly', async () => {
+    const agent = new MockAgent();
+    const threadId = 'test-thread-7';
+    const input: RunAgentInput = {
+      runId: 'run-stop',
+      threadId,
+      messages: [],
+    };
+    
+    // Mock a slow agent
+    const slowAgent: AbstractAgent = {
+      async runAgent(input, callbacks) {
+        await callbacks.onEvent({
+          event: {
+            type: EventType.RUN_STARTED,
+            threadId: input.threadId,
+            runId: input.runId,
+          }
+        });
+        
+        // Simulate long running task
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+    };
+    
+    // Start run
+    runner.run({ threadId, agent: slowAgent, input });
+    
+    // Wait for run to start
+    await new Promise(resolve => setTimeout(resolve, 50));
+    
+    // Stop the run
+    const stopped = await runner.stop({ threadId });
+    expect(stopped).toBe(true);
+    
+    // Should not be running
+    const isRunning = await runner.isRunning({ threadId });
+    expect(isRunning).toBe(false);
+    
+    // Stream should contain RUN_ERROR event
+    const streamKey = `stream:${threadId}:${input.runId}`;
+    const stream = await redis.xrange(streamKey, '-', '+');
+    const errorEvent = stream.find((entry: any) => {
+      const fields = entry[1];
+      for (let i = 0; i < fields.length; i += 2) {
+        if (fields[i] === 'type' && fields[i + 1] === EventType.RUN_ERROR) {
+          return true;
+        }
+      }
+      return false;
+    });
+    expect(errorEvent).toBeDefined();
+  });
+  
+  it('should handle multiple sequential runs on same thread', async () => {
+    const agent = new MockAgent();
+    const threadId = 'test-thread-8';
+    
+    // First run
+    const input1: RunAgentInput = {
+      runId: 'run-seq-1',
+      threadId,
+      messages: [],
+    };
+    
+    const events1 = await firstValueFrom(
+      runner.run({ threadId, agent, input: input1 }).pipe(toArray())
+    );
+    expect(events1.length).toBeGreaterThan(0);
+    
+    // Second run
+    const input2: RunAgentInput = {
+      runId: 'run-seq-2',
+      threadId,
+      messages: [],
+    };
+    
+    const events2 = await firstValueFrom(
+      runner.run({ threadId, agent, input: input2 }).pipe(toArray())
+    );
+    expect(events2.length).toBeGreaterThan(0);
+    
+    // Connect should get both runs' events
+    const allEvents = await firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    
+    // Should have events from both runs
+    expect(allEvents.length).toBeGreaterThan(events1.length);
+  });
+  
+  it('should handle input messages correctly', async () => {
+    const agent = new MockAgent();
+    const threadId = 'test-thread-9';
+    const input: RunAgentInput = {
+      runId: 'run-messages',
+      threadId,
+      messages: [
+        {
+          id: 'user-msg-1',
+          role: 'user',
+          content: 'Hello',
+        }
+      ],
+    };
+    
+    const events = await firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Run events should not include input messages
+    const userMessages = events.filter((e: any) => 
+      e.type === EventType.TEXT_MESSAGE_START && e.role === 'user'
+    );
+    expect(userMessages.length).toBe(0);
+    
+    // But connect should include them
+    const connectEvents = await firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    
+    const userMessagesInConnect = connectEvents.filter((e: any) => 
+      e.type === EventType.TEXT_MESSAGE_START && e.role === 'user'
+    );
+    expect(userMessagesInConnect.length).toBe(1);
+  });
+  
+  // Additional comprehensive tests to match SQLite/InMemory coverage
+  
+  it('should persist events across runner instances', async () => {
+    const threadId = 'test-thread-persistence';
+    const events: BaseEvent[] = [
+      { type: EventType.TEXT_MESSAGE_START, messageId: 'msg1', role: 'assistant' },
+      { type: EventType.TEXT_MESSAGE_CONTENT, messageId: 'msg1', delta: 'Persisted' },
+      { type: EventType.TEXT_MESSAGE_END, messageId: 'msg1' },
+      { type: EventType.RUN_FINISHED, threadId, runId: 'run1' },
+    ];
+    
+    const agent = new CustomEventAgent(events);
+    const input: RunAgentInput = {
+      threadId,
+      runId: 'run1',
+      messages: [],
+    };
+    
+    // Run with first instance
+    await firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Don't close the first runner's DB connection since we share it
+    // Just disconnect Redis
+    runner.redis.disconnect();
+    runner.redisSub.disconnect();
+    
+    // Create new runner instance with same DB but new Redis
+    const newRunner = new EnterpriseAgentRunner({
+      kysely: db,  // Reuse same DB connection
+      redis: new IORedisMock(),
+      streamRetentionMs: 60000,
+      streamActiveTTLMs: 10000,
+      lockTTLMs: 30000
+    });
+    
+    // Connect should get persisted events
+    const persistedEvents = await firstValueFrom(
+      newRunner.connect({ threadId }).pipe(toArray())
+    );
+    
+    expect(persistedEvents.length).toBeGreaterThan(0);
+    const textContent = persistedEvents.find(
+      e => e.type === EventType.TEXT_MESSAGE_CONTENT
+    ) as any;
+    expect(textContent?.delta).toBe('Persisted');
+    
+    // Clean up new runner's Redis connections only
+    newRunner.redis.disconnect();
+    newRunner.redisSub.disconnect();
+  });
+  
+  it('should handle concurrent connections', async () => {
+    const threadId = 'test-thread-concurrent';
+    const agent = new MockAgent();
+    const input: RunAgentInput = {
+      threadId,
+      runId: 'run1',
+      messages: [],
+    };
+    
+    // Start a run
+    const runPromise = firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Start multiple connections while run is active
+    await new Promise(resolve => setTimeout(resolve, 50));
+    
+    const conn1Promise = firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    const conn2Promise = firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    const conn3Promise = firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    
+    // Wait for all to complete
+    const [runEvents, conn1Events, conn2Events, conn3Events] = await Promise.all([
+      runPromise,
+      conn1Promise,
+      conn2Promise,
+      conn3Promise,
+    ]);
+    
+    // All connections should receive events
+    expect(conn1Events.length).toBeGreaterThan(0);
+    expect(conn2Events.length).toBeGreaterThan(0);
+    expect(conn3Events.length).toBeGreaterThan(0);
+  });
+  
+  it('should store compacted events in the database', async () => {
+    const threadId = 'test-thread-compaction';
+    const messageId = 'msg-compact';
+    
+    // Create events that will be compacted
+    const events: BaseEvent[] = [
+      { type: EventType.TEXT_MESSAGE_START, messageId, role: 'assistant' },
+      { type: EventType.TEXT_MESSAGE_CONTENT, messageId, delta: 'Hello' },
+      { type: EventType.TEXT_MESSAGE_CONTENT, messageId, delta: ' ' },
+      { type: EventType.TEXT_MESSAGE_CONTENT, messageId, delta: 'World' },
+      { type: EventType.TEXT_MESSAGE_END, messageId },
+      { type: EventType.RUN_FINISHED, threadId, runId: 'run1' },
+    ];
+    
+    const agent = new CustomEventAgent(events);
+    const input: RunAgentInput = {
+      threadId,
+      runId: 'run1',
+      messages: [],
+    };
+    
+    // Run the agent
+    await firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Check database has compacted events
+    const dbRuns = await db
+      .selectFrom('agent_runs')
+      .where('thread_id', '=', threadId)
+      .selectAll()
+      .execute();
+    
+    expect(dbRuns).toHaveLength(1);
+    const storedEvents = JSON.parse(dbRuns[0].events);
+    
+    // Should have compacted content into single delta
+    const contentEvents = storedEvents.filter(
+      (e: any) => e.type === EventType.TEXT_MESSAGE_CONTENT
+    );
+    expect(contentEvents).toHaveLength(1);
+    expect(contentEvents[0].delta).toBe('Hello World');
+  });
+  
+  it('should not store duplicate message IDs across multiple runs', async () => {
+    const threadId = 'test-thread-nodupe';
+    const messageId = 'shared-msg';
+    
+    // First run with a message
+    const input1: RunAgentInput = {
+      threadId,
+      runId: 'run1',
+      messages: [{
+        id: messageId,
+        role: 'user',
+        content: 'First message',
+      }],
+    };
+    
+    const agent = new CustomEventAgent([
+      { type: EventType.RUN_FINISHED, threadId, runId: 'run1' },
+    ]);
+    
+    await firstValueFrom(
+      runner.run({ threadId, agent, input: input1 }).pipe(toArray())
+    );
+    
+    // Second run with same message ID
+    const input2: RunAgentInput = {
+      threadId,
+      runId: 'run2',
+      messages: [{
+        id: messageId,
+        role: 'user',
+        content: 'First message',
+      }],
+    };
+    
+    await firstValueFrom(
+      runner.run({ threadId, agent, input: input2 }).pipe(toArray())
+    );
+    
+    // Check database - message should only be stored in first run
+    const dbRuns = await db
+      .selectFrom('agent_runs')
+      .where('thread_id', '=', threadId)
+      .selectAll()
+      .orderBy('created_at', 'asc')
+      .execute();
+    
+    expect(dbRuns).toHaveLength(2);
+    
+    const run1Events = JSON.parse(dbRuns[0].events);
+    const run2Events = JSON.parse(dbRuns[1].events);
+    
+    // First run should have the message events
+    const run1MessageEvents = run1Events.filter(
+      (e: any) => e.messageId === messageId
+    );
+    expect(run1MessageEvents.length).toBeGreaterThan(0);
+    
+    // Second run should NOT have the message events
+    const run2MessageEvents = run2Events.filter(
+      (e: any) => e.messageId === messageId
+    );
+    expect(run2MessageEvents.length).toBe(0);
+  });
+  
+  it('should handle all message types (user, assistant, tool, system, developer)', async () => {
+    const threadId = 'test-thread-alltypes';
+    const messages: Message[] = [
+      { id: 'user-1', role: 'user', content: 'User message' },
+      { id: 'assistant-1', role: 'assistant', content: 'Assistant message' },
+      { id: 'system-1', role: 'system', content: 'System message' },
+      { id: 'developer-1', role: 'developer', content: 'Developer message' },
+      { 
+        id: 'tool-1', 
+        role: 'tool', 
+        content: 'Tool result',
+        toolCallId: 'call-1'
+      },
+    ];
+    
+    const input: RunAgentInput = {
+      threadId,
+      runId: 'run1',
+      messages,
+    };
+    
+    const agent = new CustomEventAgent([
+      { type: EventType.RUN_FINISHED, threadId, runId: 'run1' },
+    ]);
+    
+    await firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Connect should get all message types
+    const connectEvents = await firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    
+    // Check each message type is present
+    const userEvents = connectEvents.filter(
+      (e: any) => e.type === EventType.TEXT_MESSAGE_START && e.role === 'user'
+    );
+    expect(userEvents.length).toBe(1);
+    
+    const assistantEvents = connectEvents.filter(
+      (e: any) => e.type === EventType.TEXT_MESSAGE_START && e.role === 'assistant'
+    );
+    expect(assistantEvents.length).toBe(1);
+    
+    const systemEvents = connectEvents.filter(
+      (e: any) => e.type === EventType.TEXT_MESSAGE_START && e.role === 'system'
+    );
+    expect(systemEvents.length).toBe(1);
+    
+    const developerEvents = connectEvents.filter(
+      (e: any) => e.type === EventType.TEXT_MESSAGE_START && e.role === 'developer'
+    );
+    expect(developerEvents.length).toBe(1);
+    
+    const toolEvents = connectEvents.filter(
+      (e: any) => e.type === EventType.TOOL_CALL_RESULT
+    );
+    expect(toolEvents.length).toBe(1);
+  });
+  
+  it('should handle tool calls correctly', async () => {
+    const threadId = 'test-thread-tools';
+    const messageId = 'assistant-msg';
+    const toolCallId = 'tool-call-1';
+    
+    const messages: Message[] = [
+      {
+        id: messageId,
+        role: 'assistant',
+        content: 'Let me help',
+        toolCalls: [{
+          id: toolCallId,
+          function: {
+            name: 'calculator',
+            arguments: '{"a": 1, "b": 2}'
+          }
+        }]
+      },
+      {
+        id: 'tool-result-1',
+        role: 'tool',
+        content: '3',
+        toolCallId: toolCallId
+      }
+    ];
+    
+    const input: RunAgentInput = {
+      threadId,
+      runId: 'run1',
+      messages,
+    };
+    
+    const agent = new CustomEventAgent([
+      { type: EventType.RUN_FINISHED, threadId, runId: 'run1' },
+    ]);
+    
+    await firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    const connectEvents = await firstValueFrom(
+      runner.connect({ threadId }).pipe(toArray())
+    );
+    
+    // Check tool call events
+    const toolCallStart = connectEvents.find(
+      (e: any) => e.type === EventType.TOOL_CALL_START && e.toolCallId === toolCallId
+    ) as any;
+    expect(toolCallStart).toBeDefined();
+    expect(toolCallStart.toolCallName).toBe('calculator');
+    
+    const toolCallArgs = connectEvents.find(
+      (e: any) => e.type === EventType.TOOL_CALL_ARGS && e.toolCallId === toolCallId
+    ) as any;
+    expect(toolCallArgs).toBeDefined();
+    expect(toolCallArgs.delta).toBe('{"a": 1, "b": 2}');
+    
+    const toolCallEnd = connectEvents.find(
+      (e: any) => e.type === EventType.TOOL_CALL_END && e.toolCallId === toolCallId
+    );
+    expect(toolCallEnd).toBeDefined();
+    
+    const toolResult = connectEvents.find(
+      (e: any) => e.type === EventType.TOOL_CALL_RESULT && e.toolCallId === toolCallId
+    ) as any;
+    expect(toolResult).toBeDefined();
+    expect(toolResult.content).toBe('3');
+  });
+  
+  it('should track running state correctly', async () => {
+    const threadId = 'test-thread-state';
+    
+    // Use a slow agent to ensure we can check running state
+    const slowAgent: AbstractAgent = {
+      async runAgent(input, callbacks) {
+        if (callbacks.onRunStartedEvent) {
+          await callbacks.onRunStartedEvent();
+        }
+        
+        await callbacks.onEvent({
+          event: {
+            type: EventType.RUN_STARTED,
+            threadId: input.threadId,
+            runId: input.runId,
+          }
+        });
+        
+        // Delay to ensure we can check running state
+        await new Promise(resolve => setTimeout(resolve, 200));
+        
+        await callbacks.onEvent({
+          event: {
+            type: EventType.RUN_FINISHED,
+            threadId: input.threadId,
+            runId: input.runId,
+          }
+        });
+      }
+    };
+    
+    const input: RunAgentInput = {
+      threadId,
+      runId: 'run1',
+      messages: [],
+    };
+    
+    // Check not running initially
+    let isRunning = await runner.isRunning({ threadId });
+    expect(isRunning).toBe(false);
+    
+    // Start run
+    const runPromise = runner.run({ threadId, agent: slowAgent, input });
+    
+    // Check running state during execution
+    await new Promise(resolve => setTimeout(resolve, 50));
+    isRunning = await runner.isRunning({ threadId });
+    expect(isRunning).toBe(true);
+    
+    // Wait for completion
+    await firstValueFrom(runPromise.pipe(toArray()));
+    
+    // Check not running after completion
+    isRunning = await runner.isRunning({ threadId });
+    expect(isRunning).toBe(false);
+  });
+  
+  it('should handle empty events arrays correctly', async () => {
+    const threadId = 'test-thread-empty';
+    const agent = new CustomEventAgent([]); // No events
+    const input: RunAgentInput = {
+      threadId,
+      runId: 'run1',
+      messages: [],
+    };
+    
+    await firstValueFrom(
+      runner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Check database - should still create a run record
+    const dbRuns = await db
+      .selectFrom('agent_runs')
+      .where('thread_id', '=', threadId)
+      .selectAll()
+      .execute();
+    
+    expect(dbRuns).toHaveLength(1);
+    const storedEvents = JSON.parse(dbRuns[0].events);
+    expect(storedEvents).toEqual([]);
+  });
+  
+  it('should handle parent-child run relationships', async () => {
+    const threadId = 'test-thread-parent-child';
+    const agent = new CustomEventAgent([
+      { type: EventType.RUN_FINISHED, threadId, runId: 'run1' },
+    ]);
+    
+    // First run (parent)
+    await firstValueFrom(
+      runner.run({ 
+        threadId, 
+        agent, 
+        input: { threadId, runId: 'run1', messages: [] } 
+      }).pipe(toArray())
+    );
+    
+    // Second run (child)
+    await firstValueFrom(
+      runner.run({ 
+        threadId, 
+        agent, 
+        input: { threadId, runId: 'run2', messages: [] } 
+      }).pipe(toArray())
+    );
+    
+    // Check parent-child relationship in database
+    const dbRuns = await db
+      .selectFrom('agent_runs')
+      .where('thread_id', '=', threadId)
+      .selectAll()
+      .orderBy('created_at', 'asc')
+      .execute();
+    
+    expect(dbRuns).toHaveLength(2);
+    expect(dbRuns[0].parent_run_id).toBeNull();
+    expect(dbRuns[1].parent_run_id).toBe('run1');
+  });
+  
+  it('should handle database initialization correctly', async () => {
+    // Check all tables exist
+    const tables = await db
+      .selectFrom('sqlite_master')
+      .where('type', '=', 'table')
+      .select('name')
+      .execute();
+    
+    const tableNames = tables.map(t => t.name);
+    expect(tableNames).toContain('agent_runs');
+    expect(tableNames).toContain('run_state');
+    expect(tableNames).toContain('schema_version');
+    
+    // Check schema version
+    const schemaVersion = await db
+      .selectFrom('schema_version')
+      .selectAll()
+      .executeTakeFirst();
+    
+    expect(schemaVersion).toBeDefined();
+    expect(schemaVersion?.version).toBe(1);
+  });
+  
+  it('should handle Redis stream expiry correctly', async () => {
+    const threadId = 'test-thread-expiry';
+    const agent = new MockAgent();
+    const input: RunAgentInput = {
+      threadId,
+      runId: 'run1',
+      messages: [],
+    };
+    
+    // Run with short TTL
+    const shortTTLRunner = new EnterpriseAgentRunner({
+      kysely: db,
+      redis,
+      redisSub,
+      streamRetentionMs: 100, // 100ms retention
+      streamActiveTTLMs: 50,   // 50ms active TTL
+      lockTTLMs: 1000
+    });
+    
+    await firstValueFrom(
+      shortTTLRunner.run({ threadId, agent, input }).pipe(toArray())
+    );
+    
+    // Stream should exist immediately after run
+    const streamKey = `stream:${threadId}:run1`;
+    let exists = await redis.exists(streamKey);
+    expect(exists).toBe(1);
+    
+    // Wait for retention period to expire
+    await new Promise(resolve => setTimeout(resolve, 150));
+    
+    // Stream should be gone
+    exists = await redis.exists(streamKey);
+    expect(exists).toBe(0);
+    
+    await shortTTLRunner.close();
+  });
+});