@copilotkitnext/runtime 0.0.22-alpha.0 → 0.0.22-alpha.1

package/dist/{chunk-LDTC5BLU.mjs → chunk-ELMYXVVN.mjs}

@@ -2,353 +2,250 @@
 var AgentRunner = class {
 };
 
-// src/runner/base.ts
+// src/runner/in-memory.ts
 import { ReplaySubject } from "rxjs";
-import { EventType as EventType2, compactEvents } from "@ag-ui/client";
+import {
+  EventType,
+  compactEvents
+} from "@ag-ui/client";
 import { finalizeRunEvents } from "@copilotkitnext/shared";
-
-// src/runner/utils.ts
-import { EventType } from "@ag-ui/client";
-function buildHistoricMessageIdIndex(runs) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const run of runs) {
-    for (const event of run.events) {
-      const msgId = event.messageId;
-      if (typeof msgId === "string") ids.add(msgId);
-      if (event.type === EventType.RUN_STARTED) {
-        const e = event;
-        for (const m of e.input?.messages ?? []) {
-          if (m?.id) ids.add(m.id);
-        }
-      }
+var InMemoryEventStore = class {
+  constructor(threadId) {
+    this.threadId = threadId;
+  }
+  /** The subject that current consumers subscribe to. */
+  subject = null;
+  /** True while a run is actively producing events. */
+  isRunning = false;
+  /** Current run ID */
+  currentRunId = null;
+  /** Historic completed runs */
+  historicRuns = [];
+  /** Currently running agent instance (if any). */
+  agent = null;
+  /** Subject returned from run() while the run is active. */
+  runSubject = null;
+  /** True once stop() has been requested but the run has not yet finalized. */
+  stopRequested = false;
+  /** Reference to the events emitted in the current run. */
+  currentEvents = null;
+};
+var GLOBAL_STORE = /* @__PURE__ */ new Map();
+var InMemoryAgentRunner = class extends AgentRunner {
+  run(request) {
+    let existingStore = GLOBAL_STORE.get(request.threadId);
+    if (!existingStore) {
+      existingStore = new InMemoryEventStore(request.threadId);
+      GLOBAL_STORE.set(request.threadId, existingStore);
     }
-  }
-  return ids;
-}
-function sanitizeRunStarted(event, input, historicIds) {
-  if (event.input) return event;
-  const sanitizedMessages = input.messages ? input.messages.filter((m) => !historicIds.has(m.id)) : void 0;
-  const updatedInput = {
-    ...input,
-    ...sanitizedMessages !== void 0 ? { messages: sanitizedMessages } : {}
-  };
-  return { ...event, input: updatedInput };
-}
-function deriveThreadMetadata(params) {
-  const { threadId, runs, isRunning, resourceId, properties } = params;
-  const createdAt = runs.length > 0 ? Math.min(...runs.map((r) => r.createdAt)) : Date.now();
-  const lastActivityAt = runs.length > 0 ? Math.max(...runs.map((r) => r.createdAt)) : createdAt;
-  let messageCount = 0;
-  let firstMessage;
-  for (const run of runs) {
-    for (const event of run.events) {
-      if (event.role && typeof event.content === "string") {
-        messageCount += 1;
-        if (!firstMessage) firstMessage = event.content;
-      }
-      if (event.type === EventType.RUN_STARTED) {
-        const e = event;
-        for (const m of e.input?.messages ?? []) {
-          messageCount += 1;
-          if (!firstMessage && typeof m.content === "string") {
-            firstMessage = m.content;
+    const store = existingStore;
+    if (store.isRunning) {
+      throw new Error("Thread already running");
+    }
+    store.isRunning = true;
+    store.currentRunId = request.input.runId;
+    store.agent = request.agent;
+    store.stopRequested = false;
+    const seenMessageIds = /* @__PURE__ */ new Set();
+    const currentRunEvents = [];
+    store.currentEvents = currentRunEvents;
+    const historicMessageIds = /* @__PURE__ */ new Set();
+    for (const run of store.historicRuns) {
+      for (const event of run.events) {
+        if ("messageId" in event && typeof event.messageId === "string") {
+          historicMessageIds.add(event.messageId);
+        }
+        if (event.type === EventType.RUN_STARTED) {
+          const runStarted = event;
+          const messages = runStarted.input?.messages ?? [];
+          for (const message of messages) {
+            historicMessageIds.add(message.id);
           }
         }
       }
     }
-  }
-  return {
-    threadId,
-    createdAt,
-    lastActivityAt,
-    isRunning,
-    messageCount,
-    firstMessage,
-    resourceId,
-    properties
-  };
-}
-function matchesScope(thread, scope) {
-  if (!scope) return true;
-  const { resourceId, properties } = scope;
-  if (resourceId !== void 0) {
-    if (Array.isArray(resourceId)) {
-      if (!resourceId.includes(thread.resourceId ?? "")) return false;
-    } else {
-      if ((thread.resourceId ?? "") !== resourceId) return false;
-    }
-  }
-  if (properties) {
-    const t = thread.properties ?? {};
-    for (const [k, v] of Object.entries(properties)) {
-      if (t[k] !== v) return false;
-    }
-  }
-  return true;
-}
-
-// src/runner/base.ts
-var AgentRunnerBase = class extends AgentRunner {
-  active = /* @__PURE__ */ new Map();
-  threadScope = /* @__PURE__ */ new Map();
-  constructor() {
-    super();
-  }
-  run(request) {
-    const { threadId, input, agent, scope } = request;
-    if (scope !== void 0) {
-      if (!this.threadScope.has(threadId)) this.threadScope.set(threadId, scope ?? null);
-    }
-    if (this.active.has(threadId)) {
-      throw new Error("Thread already running");
-    }
+    const nextSubject = new ReplaySubject(Infinity);
+    const prevSubject = store.subject;
+    store.subject = nextSubject;
     const runSubject = new ReplaySubject(Infinity);
-    void (async () => {
-      this.active.set(threadId, { agent, stopRequested: false });
-      const acquired = await this.acquireRun(threadId, input.runId);
-      if (!acquired) {
-        this.active.delete(threadId);
-        runSubject.error(new Error("Thread already running"));
-        return;
-      }
-      const currentRunEvents = [];
-      const priorRuns = await this.listRuns(threadId);
-      const historicIds = buildHistoricMessageIdIndex(priorRuns);
-      const onEvent = (event) => {
-        let processed = event;
-        if (event.type === EventType2.RUN_STARTED) {
-          processed = sanitizeRunStarted(event, input, historicIds);
-        }
-        runSubject.next(processed);
-        currentRunEvents.push(processed);
-        this.publishLive(threadId, processed);
-      };
+    store.runSubject = runSubject;
+    const runAgent = async () => {
+      const lastRun = store.historicRuns[store.historicRuns.length - 1];
+      const parentRunId = lastRun?.runId ?? null;
       try {
-        await agent.runAgent(input, {
-          onEvent: ({ event }) => onEvent(event),
+        await request.agent.runAgent(request.input, {
+          onEvent: ({ event }) => {
+            let processedEvent = event;
+            if (event.type === EventType.RUN_STARTED) {
+              const runStartedEvent = event;
+              if (!runStartedEvent.input) {
+                const sanitizedMessages = request.input.messages ? request.input.messages.filter(
+                  (message) => !historicMessageIds.has(message.id)
+                ) : void 0;
+                const updatedInput = {
+                  ...request.input,
+                  ...sanitizedMessages !== void 0 ? { messages: sanitizedMessages } : {}
+                };
+                processedEvent = {
+                  ...runStartedEvent,
+                  input: updatedInput
+                };
+              }
+            }
+            runSubject.next(processedEvent);
+            nextSubject.next(processedEvent);
+            currentRunEvents.push(processedEvent);
+          },
           onNewMessage: ({ message }) => {
+            if (!seenMessageIds.has(message.id)) {
+              seenMessageIds.add(message.id);
+            }
           },
           onRunStartedEvent: () => {
+            if (request.input.messages) {
+              for (const message of request.input.messages) {
+                if (!seenMessageIds.has(message.id)) {
+                  seenMessageIds.add(message.id);
+                }
+              }
+            }
           }
         });
-        const ctx = this.active.get(threadId);
-        const appended = finalizeRunEvents(currentRunEvents, { stopRequested: ctx?.stopRequested ?? false });
-        for (const e of appended) {
-          runSubject.next(e);
-          this.publishLive(threadId, e);
+        const appendedEvents = finalizeRunEvents(currentRunEvents, {
+          stopRequested: store.stopRequested
+        });
+        for (const event of appendedEvents) {
+          runSubject.next(event);
+          nextSubject.next(event);
         }
-        const parentRunId = priorRuns.at(-1)?.runId ?? null;
-        const compacted = compactEvents(currentRunEvents);
-        await this.saveRun(threadId, input.runId, compacted, input, parentRunId);
-      } catch (error) {
-        const ctx = this.active.get(threadId);
-        const appended = finalizeRunEvents(currentRunEvents, {
-          stopRequested: ctx?.stopRequested ?? false,
-          interruptionMessage: error instanceof Error ? error.message : void 0
+        if (store.currentRunId) {
+          const compactedEvents = compactEvents(currentRunEvents);
+          store.historicRuns.push({
+            threadId: request.threadId,
+            runId: store.currentRunId,
+            parentRunId,
+            events: compactedEvents,
+            createdAt: Date.now()
+          });
+        }
+        store.currentEvents = null;
+        store.currentRunId = null;
+        store.agent = null;
+        store.runSubject = null;
+        store.stopRequested = false;
+        store.isRunning = false;
+        runSubject.complete();
+        nextSubject.complete();
+      } catch {
+        const appendedEvents = finalizeRunEvents(currentRunEvents, {
+          stopRequested: store.stopRequested
         });
-        for (const e of appended) {
-          runSubject.next(e);
-          this.publishLive(threadId, e);
+        for (const event of appendedEvents) {
+          runSubject.next(event);
+          nextSubject.next(event);
         }
-        if (currentRunEvents.length > 0) {
-          const parentRunId = priorRuns.at(-1)?.runId ?? null;
-          const compacted = compactEvents(currentRunEvents);
-          await this.saveRun(threadId, input.runId, compacted, input, parentRunId);
+        if (store.currentRunId && currentRunEvents.length > 0) {
+          const compactedEvents = compactEvents(currentRunEvents);
+          store.historicRuns.push({
+            threadId: request.threadId,
+            runId: store.currentRunId,
+            parentRunId,
+            events: compactedEvents,
+            createdAt: Date.now()
+          });
         }
-      } finally {
-        await this.releaseRun(threadId);
-        this.active.delete(threadId);
-        this.completeLive(threadId);
+        store.currentEvents = null;
+        store.currentRunId = null;
+        store.agent = null;
+        store.runSubject = null;
+        store.stopRequested = false;
+        store.isRunning = false;
         runSubject.complete();
+        nextSubject.complete();
       }
-    })();
+    };
+    if (prevSubject) {
+      prevSubject.subscribe({
+        next: (e) => nextSubject.next(e),
+        error: (err) => nextSubject.error(err),
+        complete: () => {
+        }
+      });
+    }
+    runAgent();
     return runSubject.asObservable();
   }
   connect(request) {
-    const { threadId } = request;
-    const subject = new ReplaySubject(Infinity);
-    void (async () => {
-      const priorRuns = await this.listRuns(threadId);
-      const allHistoric = [];
-      for (const r of priorRuns) allHistoric.push(...r.events);
-      const compacted = compactEvents(allHistoric);
-      const emittedIds = /* @__PURE__ */ new Set();
-      for (const e of compacted) {
-        subject.next(e);
-        const id = e.messageId;
-        if (typeof id === "string") emittedIds.add(id);
-      }
-      const running = await this.isRunningState(threadId);
-      if (!running) {
-        subject.complete();
-        return;
+    const store = GLOBAL_STORE.get(request.threadId);
+    const connectionSubject = new ReplaySubject(Infinity);
+    if (!store) {
+      connectionSubject.complete();
+      return connectionSubject.asObservable();
+    }
+    const allHistoricEvents = [];
+    for (const run of store.historicRuns) {
+      allHistoricEvents.push(...run.events);
+    }
+    const compactedEvents = compactEvents(allHistoricEvents);
+    const emittedMessageIds = /* @__PURE__ */ new Set();
+    for (const event of compactedEvents) {
+      connectionSubject.next(event);
+      if ("messageId" in event && typeof event.messageId === "string") {
+        emittedMessageIds.add(event.messageId);
       }
-      const live = this.subscribeLive(threadId);
-      let completed = false;
-      live.subscribe({
-        next: (e) => {
-          const id = e.messageId;
-          if (typeof id === "string" && emittedIds.has(id)) return;
-          subject.next(e);
-          if (e.type === EventType2.RUN_FINISHED || e.type === EventType2.RUN_ERROR) {
-            if (!completed) {
-              completed = true;
-              subject.complete();
-            }
+    }
+    if (store.subject && (store.isRunning || store.stopRequested)) {
+      store.subject.subscribe({
+        next: (event) => {
+          if ("messageId" in event && typeof event.messageId === "string" && emittedMessageIds.has(event.messageId)) {
+            return;
           }
+          connectionSubject.next(event);
         },
-        error: (err) => subject.error(err),
-        complete: () => {
-          if (!completed) {
-            completed = true;
-            subject.complete();
-          }
-        }
+        complete: () => connectionSubject.complete(),
+        error: (err) => connectionSubject.error(err)
       });
-    })();
-    return subject.asObservable();
-  }
-  async isRunning(request) {
-    return this.isRunningState(request.threadId);
-  }
-  async stop(request) {
-    const ctx = this.active.get(request.threadId);
-    if (!ctx?.agent) return false;
-    if (ctx.stopRequested) return false;
-    ctx.stopRequested = true;
-    await this.releaseRun(request.threadId);
-    try {
-      ctx.agent.abortRun();
-      return true;
-    } catch {
-      ctx.stopRequested = false;
-      return false;
-    }
-  }
-  async listThreads(request) {
-    const limit = request.limit ?? 20;
-    const offset = request.offset ?? 0;
-    const page = await this.pageThreads({ scope: request.scope, limit: limit + offset, offset: 0 });
-    const resultThreads = [];
-    for (const id of page.threadIds) {
-      const md = await this.getThreadMetadata(id, request.scope);
-      if (!md) continue;
-      if (request.scope ? matchesScope(md, request.scope) : true) {
-        resultThreads.push(md);
-      }
+    } else {
+      connectionSubject.complete();
     }
-    resultThreads.sort((a, b) => b.lastActivityAt - a.lastActivityAt);
-    const sliced = resultThreads.slice(offset, offset + limit);
-    return { threads: sliced, total: page.total };
+    return connectionSubject.asObservable();
   }
-  async getThreadMetadata(threadId, scope) {
-    const runs = await this.listRuns(threadId);
-    if (runs.length === 0) return null;
-    const isRunning = await this.isRunningState(threadId);
-    const s = this.threadScope.get(threadId) ?? null;
-    return deriveThreadMetadata({
-      threadId,
-      runs,
-      isRunning,
-      resourceId: s?.resourceId ?? void 0,
-      properties: s?.properties
-    });
+  isRunning(request) {
+    const store = GLOBAL_STORE.get(request.threadId);
+    return Promise.resolve(store?.isRunning ?? false);
   }
-  async deleteThread(threadId, scope) {
-    const running = await this.isRunningState(threadId);
-    if (running) {
-      throw new Error("Cannot delete a running thread");
+  stop(request) {
+    const store = GLOBAL_STORE.get(request.threadId);
+    if (!store || !store.isRunning) {
+      return Promise.resolve(false);
     }
-    await this.deleteThreadStorage(threadId, scope);
-    if (this.closeLive) {
-      await this.closeLive(threadId);
+    if (store.stopRequested) {
+      return Promise.resolve(false);
     }
-    this.threadScope.delete(threadId);
-  }
-};
-
-// src/runner/in-memory-runner.ts
-import { ReplaySubject as ReplaySubject2 } from "rxjs";
-var InMemoryAgentRunner = class extends AgentRunnerBase {
-  state = /* @__PURE__ */ new Map();
-  runs = /* @__PURE__ */ new Map();
-  channels = /* @__PURE__ */ new Map();
-  constructor() {
-    super();
-  }
-  // Live channel helpers
-  ensureChannel(threadId) {
-    let s = this.channels.get(threadId);
-    if (!s || s.closed) {
-      s = new ReplaySubject2(Infinity);
-      this.channels.set(threadId, s);
+    store.stopRequested = true;
+    store.isRunning = false;
+    const agent = store.agent;
+    if (!agent) {
+      store.stopRequested = false;
+      store.isRunning = false;
+      return Promise.resolve(false);
     }
-    return s;
-  }
-  // Hooks implementation
-  async acquireRun(threadId, runId) {
-    const entry = this.state.get(threadId) ?? { isRunning: false, runId: null };
-    if (entry.isRunning) return false;
-    entry.isRunning = true;
-    entry.runId = runId;
-    this.state.set(threadId, entry);
-    return true;
-  }
-  async releaseRun(threadId) {
-    const entry = this.state.get(threadId) ?? { isRunning: false, runId: null };
-    entry.isRunning = false;
-    this.state.set(threadId, entry);
-  }
-  async isRunningState(threadId) {
-    return this.state.get(threadId)?.isRunning ?? false;
-  }
-  async listRuns(threadId) {
-    return this.runs.get(threadId) ?? [];
-  }
-  async saveRun(threadId, runId, events, input, parentRunId) {
-    const list = this.runs.get(threadId) ?? [];
-    list.push({ runId, events, createdAt: Date.now() });
-    this.runs.set(threadId, list);
-  }
-  async pageThreads(params) {
-    const all = [];
-    for (const [id, arr] of this.runs.entries()) {
-      const last = arr.length > 0 ? Math.max(...arr.map((r) => r.createdAt)) : 0;
-      all.push({ id, last });
+    try {
+      agent.abortRun();
+      return Promise.resolve(true);
+    } catch (error) {
+      console.error("Failed to abort agent run", error);
+      store.stopRequested = false;
+      store.isRunning = true;
+      return Promise.resolve(false);
     }
-    all.sort((a, b) => b.last - a.last);
-    const total = all.length;
-    const offset = params.offset ?? 0;
-    const limit = params.limit ?? 20;
-    const ids = all.slice(offset, offset + limit).map((x) => x.id);
-    return { threadIds: ids, total };
-  }
-  async deleteThreadStorage(threadId) {
-    this.runs.delete(threadId);
-    this.state.delete(threadId);
-  }
-  publishLive(threadId, event) {
-    const s = this.ensureChannel(threadId);
-    s.next(event);
-  }
-  completeLive(threadId) {
-    const s = this.ensureChannel(threadId);
-    if (!s.closed) s.complete();
-  }
-  subscribeLive(threadId) {
-    return this.ensureChannel(threadId).asObservable();
-  }
-  async closeLive(threadId) {
-    const s = this.channels.get(threadId);
-    if (s && !s.closed) s.complete();
-    this.channels.delete(threadId);
   }
 };
 
 // package.json
 var package_default = {
   name: "@copilotkitnext/runtime",
-  version: "0.0.22-alpha.0",
+  version: "0.0.22-alpha.1",
   description: "Server-side runtime package for CopilotKit2",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -392,9 +289,9 @@ var package_default = {
     vitest: "^3.0.5"
   },
   dependencies: {
-    "@ag-ui/client": "0.0.40-alpha.11",
-    "@ag-ui/core": "0.0.40-alpha.11",
-    "@ag-ui/encoder": "0.0.40-alpha.11",
+    "@ag-ui/client": "0.0.41-alpha.0",
+    "@ag-ui/core": "0.0.41-alpha.0",
+    "@ag-ui/encoder": "0.0.41-alpha.0",
     "@copilotkitnext/shared": "workspace:*",
     cors: "^2.8.5",
     express: "^4.21.2",
@@ -707,7 +604,7 @@ async function handleConnectAgent({
 }
 
 // src/handlers/handle-stop.ts
-import { EventType as EventType3 } from "@ag-ui/client";
+import { EventType as EventType2 } from "@ag-ui/client";
 async function handleStopAgent({
   runtime,
   request,
@@ -745,7 +642,7 @@ async function handleStopAgent({
       JSON.stringify({
         stopped: true,
         interrupt: {
-          type: EventType3.RUN_ERROR,
+          type: EventType2.RUN_ERROR,
           message: "Run stopped by user",
           code: "STOPPED"
         }
@@ -1025,7 +922,6 @@ export {
   handleConnectAgent,
   handleStopAgent,
   AgentRunner,
-  AgentRunnerBase,
   InMemoryAgentRunner,
   VERSION,
   CopilotRuntime,
@@ -1037,4 +933,4 @@ export {
   expectString,
   createJsonRequest
 };
-//# sourceMappingURL=chunk-LDTC5BLU.mjs.map
+//# sourceMappingURL=chunk-ELMYXVVN.mjs.map