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

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

@@ -2,250 +2,353 @@
 var AgentRunner = class {
 };
 
-// src/runner/in-memory.ts
+// src/runner/base.ts
 import { ReplaySubject } from "rxjs";
-import {
-  EventType,
-  compactEvents
-} from "@ag-ui/client";
+import { EventType as EventType2, compactEvents } from "@ag-ui/client";
 import { finalizeRunEvents } from "@copilotkitnext/shared";
-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);
-    }
-    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);
+
+// 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);
         }
-        if (event.type === EventType.RUN_STARTED) {
-          const runStarted = event;
-          const messages = runStarted.input?.messages ?? [];
-          for (const message of messages) {
-            historicMessageIds.add(message.id);
+      }
+    }
+  }
+  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 nextSubject = new ReplaySubject(Infinity);
-    const prevSubject = store.subject;
-    store.subject = nextSubject;
+  }
+  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 runSubject = new ReplaySubject(Infinity);
-    store.runSubject = runSubject;
-    const runAgent = async () => {
-      const lastRun = store.historicRuns[store.historicRuns.length - 1];
-      const parentRunId = lastRun?.runId ?? null;
+    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);
+      };
       try {
-        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);
-          },
+        await agent.runAgent(input, {
+          onEvent: ({ event }) => onEvent(event),
           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 appendedEvents = finalizeRunEvents(currentRunEvents, {
-          stopRequested: store.stopRequested
-        });
-        for (const event of appendedEvents) {
-          runSubject.next(event);
-          nextSubject.next(event);
+        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);
         }
-        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
+        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
         });
-        for (const event of appendedEvents) {
-          runSubject.next(event);
-          nextSubject.next(event);
+        for (const e of appended) {
+          runSubject.next(e);
+          this.publishLive(threadId, e);
         }
-        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()
-          });
+        if (currentRunEvents.length > 0) {
+          const parentRunId = priorRuns.at(-1)?.runId ?? null;
+          const compacted = compactEvents(currentRunEvents);
+          await this.saveRun(threadId, input.runId, compacted, input, parentRunId);
         }
-        store.currentEvents = null;
-        store.currentRunId = null;
-        store.agent = null;
-        store.runSubject = null;
-        store.stopRequested = false;
-        store.isRunning = false;
+      } finally {
+        await this.releaseRun(threadId);
+        this.active.delete(threadId);
+        this.completeLive(threadId);
         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 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 { 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);
       }
-    }
-    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;
+      const running = await this.isRunningState(threadId);
+      if (!running) {
+        subject.complete();
+        return;
+      }
+      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();
+            }
           }
-          connectionSubject.next(event);
         },
-        complete: () => connectionSubject.complete(),
-        error: (err) => connectionSubject.error(err)
+        error: (err) => subject.error(err),
+        complete: () => {
+          if (!completed) {
+            completed = true;
+            subject.complete();
+          }
+        }
       });
-    } else {
-      connectionSubject.complete();
+    })();
+    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;
     }
-    return connectionSubject.asObservable();
   }
-  isRunning(request) {
-    const store = GLOBAL_STORE.get(request.threadId);
-    return Promise.resolve(store?.isRunning ?? 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);
+      }
+    }
+    resultThreads.sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+    const sliced = resultThreads.slice(offset, offset + limit);
+    return { threads: sliced, total: page.total };
   }
-  stop(request) {
-    const store = GLOBAL_STORE.get(request.threadId);
-    if (!store || !store.isRunning) {
-      return Promise.resolve(false);
+  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
+    });
+  }
+  async deleteThread(threadId, scope) {
+    const running = await this.isRunningState(threadId);
+    if (running) {
+      throw new Error("Cannot delete a running thread");
     }
-    if (store.stopRequested) {
-      return Promise.resolve(false);
+    await this.deleteThreadStorage(threadId, scope);
+    if (this.closeLive) {
+      await this.closeLive(threadId);
     }
-    store.stopRequested = true;
-    store.isRunning = false;
-    const agent = store.agent;
-    if (!agent) {
-      store.stopRequested = false;
-      store.isRunning = false;
-      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);
     }
-    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);
+    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 });
     }
+    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.21-alpha.0",
+  version: "0.0.22-alpha.0",
   description: "Server-side runtime package for CopilotKit2",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -604,7 +707,7 @@ async function handleConnectAgent({
 }
 
 // src/handlers/handle-stop.ts
-import { EventType as EventType2 } from "@ag-ui/client";
+import { EventType as EventType3 } from "@ag-ui/client";
 async function handleStopAgent({
   runtime,
   request,
@@ -642,7 +745,7 @@ async function handleStopAgent({
       JSON.stringify({
         stopped: true,
         interrupt: {
-          type: EventType2.RUN_ERROR,
+          type: EventType3.RUN_ERROR,
           message: "Run stopped by user",
           code: "STOPPED"
         }
@@ -922,6 +1025,7 @@ export {
   handleConnectAgent,
   handleStopAgent,
   AgentRunner,
+  AgentRunnerBase,
   InMemoryAgentRunner,
   VERSION,
   CopilotRuntime,
@@ -933,4 +1037,4 @@ export {
   expectString,
   createJsonRequest
 };
-//# sourceMappingURL=chunk-PBMAFLPB.mjs.map
+//# sourceMappingURL=chunk-LDTC5BLU.mjs.map