@copilotkitnext/runtime 0.0.1

package/src/runner/event-compaction.ts

@@ -0,0 +1,250 @@
+import {
+  BaseEvent,
+  EventType,
+  TextMessageStartEvent,
+  TextMessageContentEvent,
+  TextMessageEndEvent,
+  ToolCallStartEvent,
+  ToolCallArgsEvent,
+  ToolCallEndEvent,
+} from "@ag-ui/client";
+
+/**
+ * Compacts streaming events by consolidating multiple deltas into single events.
+ * For text messages: multiple content deltas become one concatenated delta.
+ * For tool calls: multiple args deltas become one concatenated delta.
+ * Events between related streaming events are reordered to keep streaming events together.
+ * 
+ * @param events - Array of events to compact
+ * @returns Compacted array of events
+ */
+export function compactEvents(events: BaseEvent[]): BaseEvent[] {
+  const compacted: BaseEvent[] = [];
+  const pendingTextMessages = new Map<string, {
+    start?: TextMessageStartEvent;
+    contents: TextMessageContentEvent[];
+    end?: TextMessageEndEvent;
+    otherEvents: BaseEvent[];
+  }>();
+  const pendingToolCalls = new Map<string, {
+    start?: ToolCallStartEvent;
+    args: ToolCallArgsEvent[];
+    end?: ToolCallEndEvent;
+    otherEvents: BaseEvent[];
+  }>();
+
+  for (const event of events) {
+    // Handle text message streaming events
+    if (event.type === EventType.TEXT_MESSAGE_START) {
+      const startEvent = event as TextMessageStartEvent;
+      const messageId = startEvent.messageId;
+      
+      if (!pendingTextMessages.has(messageId)) {
+        pendingTextMessages.set(messageId, {
+          contents: [],
+          otherEvents: []
+        });
+      }
+      
+      const pending = pendingTextMessages.get(messageId)!;
+      pending.start = startEvent;
+    } else if (event.type === EventType.TEXT_MESSAGE_CONTENT) {
+      const contentEvent = event as TextMessageContentEvent;
+      const messageId = contentEvent.messageId;
+      
+      if (!pendingTextMessages.has(messageId)) {
+        pendingTextMessages.set(messageId, {
+          contents: [],
+          otherEvents: []
+        });
+      }
+      
+      const pending = pendingTextMessages.get(messageId)!;
+      pending.contents.push(contentEvent);
+    } else if (event.type === EventType.TEXT_MESSAGE_END) {
+      const endEvent = event as TextMessageEndEvent;
+      const messageId = endEvent.messageId;
+      
+      if (!pendingTextMessages.has(messageId)) {
+        pendingTextMessages.set(messageId, {
+          contents: [],
+          otherEvents: []
+        });
+      }
+      
+      const pending = pendingTextMessages.get(messageId)!;
+      pending.end = endEvent;
+      
+      // Flush this message's events
+      flushTextMessage(messageId, pending, compacted);
+      pendingTextMessages.delete(messageId);
+    } else if (event.type === EventType.TOOL_CALL_START) {
+      const startEvent = event as ToolCallStartEvent;
+      const toolCallId = startEvent.toolCallId;
+      
+      if (!pendingToolCalls.has(toolCallId)) {
+        pendingToolCalls.set(toolCallId, {
+          args: [],
+          otherEvents: []
+        });
+      }
+      
+      const pending = pendingToolCalls.get(toolCallId)!;
+      pending.start = startEvent;
+    } else if (event.type === EventType.TOOL_CALL_ARGS) {
+      const argsEvent = event as ToolCallArgsEvent;
+      const toolCallId = argsEvent.toolCallId;
+      
+      if (!pendingToolCalls.has(toolCallId)) {
+        pendingToolCalls.set(toolCallId, {
+          args: [],
+          otherEvents: []
+        });
+      }
+      
+      const pending = pendingToolCalls.get(toolCallId)!;
+      pending.args.push(argsEvent);
+    } else if (event.type === EventType.TOOL_CALL_END) {
+      const endEvent = event as ToolCallEndEvent;
+      const toolCallId = endEvent.toolCallId;
+      
+      if (!pendingToolCalls.has(toolCallId)) {
+        pendingToolCalls.set(toolCallId, {
+          args: [],
+          otherEvents: []
+        });
+      }
+      
+      const pending = pendingToolCalls.get(toolCallId)!;
+      pending.end = endEvent;
+      
+      // Flush this tool call's events
+      flushToolCall(toolCallId, pending, compacted);
+      pendingToolCalls.delete(toolCallId);
+    } else {
+      // For non-streaming events, check if we're in the middle of any streaming sequences
+      let addedToBuffer = false;
+      
+      // Check text messages
+      for (const [messageId, pending] of pendingTextMessages) {
+        // If we have a start but no end yet, this event is "in between"
+        if (pending.start && !pending.end) {
+          pending.otherEvents.push(event);
+          addedToBuffer = true;
+          break;
+        }
+      }
+      
+      // Check tool calls if not already buffered
+      if (!addedToBuffer) {
+        for (const [toolCallId, pending] of pendingToolCalls) {
+          // If we have a start but no end yet, this event is "in between"
+          if (pending.start && !pending.end) {
+            pending.otherEvents.push(event);
+            addedToBuffer = true;
+            break;
+          }
+        }
+      }
+      
+      // If not in the middle of any streaming sequence, add directly to compacted
+      if (!addedToBuffer) {
+        compacted.push(event);
+      }
+    }
+  }
+
+  // Flush any remaining incomplete messages
+  for (const [messageId, pending] of pendingTextMessages) {
+    flushTextMessage(messageId, pending, compacted);
+  }
+  
+  // Flush any remaining incomplete tool calls
+  for (const [toolCallId, pending] of pendingToolCalls) {
+    flushToolCall(toolCallId, pending, compacted);
+  }
+
+  return compacted;
+}
+
+function flushTextMessage(
+  messageId: string,
+  pending: {
+    start?: TextMessageStartEvent;
+    contents: TextMessageContentEvent[];
+    end?: TextMessageEndEvent;
+    otherEvents: BaseEvent[];
+  },
+  compacted: BaseEvent[]
+): void {
+  // Add start event if present
+  if (pending.start) {
+    compacted.push(pending.start);
+  }
+
+  // Compact all content events into one
+  if (pending.contents.length > 0) {
+    const concatenatedDelta = pending.contents
+      .map(c => c.delta)
+      .join('');
+    
+    const compactedContent: TextMessageContentEvent = {
+      type: EventType.TEXT_MESSAGE_CONTENT,
+      messageId: messageId,
+      delta: concatenatedDelta,
+    };
+    
+    compacted.push(compactedContent);
+  }
+
+  // Add end event if present
+  if (pending.end) {
+    compacted.push(pending.end);
+  }
+
+  // Add any events that were in between
+  for (const otherEvent of pending.otherEvents) {
+    compacted.push(otherEvent);
+  }
+}
+
+function flushToolCall(
+  toolCallId: string,
+  pending: {
+    start?: ToolCallStartEvent;
+    args: ToolCallArgsEvent[];
+    end?: ToolCallEndEvent;
+    otherEvents: BaseEvent[];
+  },
+  compacted: BaseEvent[]
+): void {
+  // Add start event if present
+  if (pending.start) {
+    compacted.push(pending.start);
+  }
+
+  // Compact all args events into one
+  if (pending.args.length > 0) {
+    const concatenatedArgs = pending.args
+      .map(a => a.delta)
+      .join('');
+    
+    const compactedArgs: ToolCallArgsEvent = {
+      type: EventType.TOOL_CALL_ARGS,
+      toolCallId: toolCallId,
+      delta: concatenatedArgs,
+    };
+    
+    compacted.push(compactedArgs);
+  }
+
+  // Add end event if present
+  if (pending.end) {
+    compacted.push(pending.end);
+  }
+
+  // Add any events that were in between
+  for (const otherEvent of pending.otherEvents) {
+    compacted.push(otherEvent);
+  }
+}

package/src/runner/in-memory.ts

@@ -0,0 +1,322 @@
+import {
+  AgentRunner,
+  AgentRunnerConnectRequest,
+  AgentRunnerIsRunningRequest,
+  AgentRunnerRunRequest,
+  type AgentRunnerStopRequest,
+} from "./agent-runner";
+import { Observable, ReplaySubject } from "rxjs";
+import { 
+  BaseEvent,
+  Message,
+  EventType,
+  TextMessageStartEvent,
+  TextMessageContentEvent,
+  TextMessageEndEvent,
+  ToolCallStartEvent,
+  ToolCallArgsEvent,
+  ToolCallEndEvent,
+  ToolCallResultEvent
+} from "@ag-ui/client";
+import { compactEvents } from "./event-compaction";
+
+interface HistoricRun {
+  threadId: string;
+  runId: string;
+  parentRunId: string | null;
+  events: BaseEvent[];
+  createdAt: number;
+}
+
+class InMemoryEventStore {
+  constructor(public threadId: string) {}
+
+  /** The subject that current consumers subscribe to. */
+  subject: ReplaySubject<BaseEvent> | null = null;
+
+  /** True while a run is actively producing events. */
+  isRunning = false;
+
+  /** Lets stop() cancel the current producer. */
+  abortController = new AbortController();
+
+  /** Current run ID */
+  currentRunId: string | null = null;
+  
+  /** Historic completed runs */
+  historicRuns: HistoricRun[] = [];
+}
+
+const GLOBAL_STORE = new Map<string, InMemoryEventStore>();
+
+export class InMemoryAgentRunner extends AgentRunner {
+  private convertMessageToEvents(message: Message): BaseEvent[] {
+    const events: BaseEvent[] = [];
+
+    if (
+      (message.role === "assistant" ||
+        message.role === "user" ||
+        message.role === "developer" ||
+        message.role === "system") &&
+      message.content
+    ) {
+      const textStartEvent: TextMessageStartEvent = {
+        type: EventType.TEXT_MESSAGE_START,
+        messageId: message.id,
+        role: message.role,
+      };
+      events.push(textStartEvent);
+
+      const textContentEvent: TextMessageContentEvent = {
+        type: EventType.TEXT_MESSAGE_CONTENT,
+        messageId: message.id,
+        delta: message.content,
+      };
+      events.push(textContentEvent);
+
+      const textEndEvent: TextMessageEndEvent = {
+        type: EventType.TEXT_MESSAGE_END,
+        messageId: message.id,
+      };
+      events.push(textEndEvent);
+    }
+
+    if (message.role === "assistant" && message.toolCalls) {
+      for (const toolCall of message.toolCalls) {
+        const toolStartEvent: ToolCallStartEvent = {
+          type: EventType.TOOL_CALL_START,
+          toolCallId: toolCall.id,
+          toolCallName: toolCall.function.name,
+          parentMessageId: message.id,
+        };
+        events.push(toolStartEvent);
+
+        const toolArgsEvent: ToolCallArgsEvent = {
+          type: EventType.TOOL_CALL_ARGS,
+          toolCallId: toolCall.id,
+          delta: toolCall.function.arguments,
+        };
+        events.push(toolArgsEvent);
+
+        const toolEndEvent: ToolCallEndEvent = {
+          type: EventType.TOOL_CALL_END,
+          toolCallId: toolCall.id,
+        };
+        events.push(toolEndEvent);
+      }
+    }
+
+    if (message.role === "tool" && message.toolCallId) {
+      const toolResultEvent: ToolCallResultEvent = {
+        type: EventType.TOOL_CALL_RESULT,
+        messageId: message.id,
+        toolCallId: message.toolCallId,
+        content: message.content,
+        role: "tool",
+      };
+      events.push(toolResultEvent);
+    }
+
+    return events;
+  }
+
+  run(request: AgentRunnerRunRequest): Observable<BaseEvent> {
+    let existingStore = GLOBAL_STORE.get(request.threadId);
+    if (!existingStore) {
+      existingStore = new InMemoryEventStore(request.threadId);
+      GLOBAL_STORE.set(request.threadId, existingStore);
+    }
+    const store = existingStore; // Now store is const and non-null
+
+    if (store.isRunning) {
+      throw new Error("Thread already running");
+    }
+    store.isRunning = true;
+    store.currentRunId = request.input.runId;
+
+    // Track seen message IDs and current run events for this run
+    const seenMessageIds = new Set<string>();
+    const currentRunEvents: BaseEvent[] = [];
+    
+    // Get all previously seen message IDs from historic runs
+    const historicMessageIds = new Set<string>();
+    for (const run of store.historicRuns) {
+      for (const event of run.events) {
+        if ('messageId' in event && typeof event.messageId === 'string') {
+          historicMessageIds.add(event.messageId);
+        }
+      }
+    }
+
+    const nextSubject = new ReplaySubject<BaseEvent>(Infinity);
+    const prevSubject = store.subject;
+
+    // Update the store's subject immediately
+    store.subject = nextSubject;
+    store.abortController = new AbortController();
+
+    // Create a subject for run() return value
+    const runSubject = new ReplaySubject<BaseEvent>(Infinity);
+
+    // Helper function to run the agent and handle errors
+    const runAgent = async () => {
+      // Get parent run ID for chaining
+      const lastRun = store.historicRuns[store.historicRuns.length - 1];
+      const parentRunId = lastRun?.runId ?? null;
+      
+      try {
+        await request.agent.runAgent(request.input, {
+          onEvent: ({ event }) => {
+            runSubject.next(event); // For run() return - only agent events
+            nextSubject.next(event); // For connect() / store - all events
+            currentRunEvents.push(event); // Accumulate for storage
+          },
+          onNewMessage: ({ message }) => {
+            // Called for each new message
+            if (!seenMessageIds.has(message.id)) {
+              seenMessageIds.add(message.id);
+            }
+          },
+          onRunStartedEvent: () => {
+            // Process input messages (same logic as SQLite)
+            if (request.input.messages) {
+              for (const message of request.input.messages) {
+                if (!seenMessageIds.has(message.id)) {
+                  seenMessageIds.add(message.id);
+                  const events = this.convertMessageToEvents(message);
+                  
+                  // Check if this message is NEW (not in historic runs)
+                  const isNewMessage = !historicMessageIds.has(message.id);
+                  
+                  for (const event of events) {
+                    // Always emit to stream for context
+                    nextSubject.next(event);
+                    
+                    // Store if this is a NEW message for this run
+                    if (isNewMessage) {
+                      currentRunEvents.push(event);
+                    }
+                  }
+                }
+              }
+            }
+          },
+        });
+        
+        // Store the completed run in memory with ONLY its events
+        if (store.currentRunId) {
+          // Compact the events before storing (like SQLite does)
+          const compactedEvents = compactEvents(currentRunEvents);
+          store.historicRuns.push({
+            threadId: request.threadId,
+            runId: store.currentRunId,
+            parentRunId,
+            events: compactedEvents,
+            createdAt: Date.now(),
+          });
+        }
+        
+        // Complete the run
+        store.isRunning = false;
+        store.currentRunId = null;
+        runSubject.complete();
+        nextSubject.complete();
+      } catch {
+        // Store the run even if it failed (partial events)
+        if (store.currentRunId && currentRunEvents.length > 0) {
+          // Compact the events before storing (like SQLite does)
+          const compactedEvents = compactEvents(currentRunEvents);
+          store.historicRuns.push({
+            threadId: request.threadId,
+            runId: store.currentRunId,
+            parentRunId,
+            events: compactedEvents,
+            createdAt: Date.now(),
+          });
+        }
+        
+        // Complete the run
+        store.isRunning = false;
+        store.currentRunId = null;
+        runSubject.complete();
+        nextSubject.complete();
+      }
+    };
+
+    // Bridge previous events if they exist
+    if (prevSubject) {
+      prevSubject.subscribe({
+        next: (e) => nextSubject.next(e),
+        error: (err) => nextSubject.error(err),
+        complete: () => {
+          // Don't complete nextSubject here - it needs to stay open for new events
+        },
+      });
+    }
+
+    // Start the agent execution immediately (not lazily)
+    runAgent();
+
+    // Return the run subject (only agent events, no injected messages)
+    return runSubject.asObservable();
+  }
+
+  connect(request: AgentRunnerConnectRequest): Observable<BaseEvent> {
+    const store = GLOBAL_STORE.get(request.threadId);
+    const connectionSubject = new ReplaySubject<BaseEvent>(Infinity);
+
+    if (!store) {
+      // No store means no events
+      connectionSubject.complete();
+      return connectionSubject.asObservable();
+    }
+
+    // Collect all historic events from memory
+    const allHistoricEvents: BaseEvent[] = [];
+    for (const run of store.historicRuns) {
+      allHistoricEvents.push(...run.events);
+    }
+    
+    // Apply compaction to all historic events together (like SQLite)
+    const compactedEvents = compactEvents(allHistoricEvents);
+    
+    // Emit compacted events and track message IDs
+    const emittedMessageIds = new Set<string>();
+    for (const event of compactedEvents) {
+      connectionSubject.next(event);
+      if ('messageId' in event && typeof event.messageId === 'string') {
+        emittedMessageIds.add(event.messageId);
+      }
+    }
+    
+    // Bridge active run to connection if exists
+    if (store.subject && store.isRunning) {
+      store.subject.subscribe({
+        next: (event) => {
+          // Skip message events that we've already emitted from historic
+          if ('messageId' in event && typeof event.messageId === 'string' && emittedMessageIds.has(event.messageId)) {
+            return;
+          }
+          connectionSubject.next(event);
+        },
+        complete: () => connectionSubject.complete(),
+        error: (err) => connectionSubject.error(err)
+      });
+    } else {
+      // No active run, complete after historic events
+      connectionSubject.complete();
+    }
+    
+    return connectionSubject.asObservable();
+  }
+
+  isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean> {
+    const store = GLOBAL_STORE.get(request.threadId);
+    return Promise.resolve(store?.isRunning ?? false);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  stop(_request: AgentRunnerStopRequest): Promise<boolean | undefined> {
+    throw new Error("Method not implemented.");
+  }
+}