@copilotkitnext/runtime 0.0.3 → 0.0.5

package/src/runner/event-compaction.ts

@@ -1,250 +0,0 @@
-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

@@ -1,328 +0,0 @@
-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,
-  MessagesSnapshotEvent,
-} 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.");
-  }
-}