@copilotkitnext/runtime 0.0.16 → 0.0.17

package/dist/index.mjs

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@copilotkitnext/runtime",
-  version: "0.0.16",
+  version: "0.0.17",
   description: "Server-side runtime package for CopilotKit2",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -60,9 +60,134 @@ var AgentRunner = class {
 // src/runner/in-memory.ts
 import { ReplaySubject } from "rxjs";
 import {
-  EventType,
+  EventType as EventType2,
   compactEvents
 } from "@ag-ui/client";
+
+// src/runner/finalize-events.ts
+import { randomUUID } from "crypto";
+import {
+  EventType
+} from "@ag-ui/client";
+var defaultStopMessage = "Run stopped by user";
+var defaultAbruptEndMessage = "Run ended without emitting a terminal event";
+function finalizeRunEvents(events, options = {}) {
+  const { stopRequested = false, interruptionMessage } = options;
+  const resolvedStopMessage = interruptionMessage ?? defaultStopMessage;
+  const resolvedAbruptMessage = interruptionMessage && interruptionMessage !== defaultStopMessage ? interruptionMessage : defaultAbruptEndMessage;
+  const appended = [];
+  const openMessageIds = /* @__PURE__ */ new Set();
+  const openToolCalls = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    switch (event.type) {
+      case EventType.TEXT_MESSAGE_START: {
+        const messageId = event.messageId;
+        if (typeof messageId === "string") {
+          openMessageIds.add(messageId);
+        }
+        break;
+      }
+      case EventType.TEXT_MESSAGE_END: {
+        const messageId = event.messageId;
+        if (typeof messageId === "string") {
+          openMessageIds.delete(messageId);
+        }
+        break;
+      }
+      case EventType.TOOL_CALL_START: {
+        const toolCallId = event.toolCallId;
+        if (typeof toolCallId === "string") {
+          openToolCalls.set(toolCallId, {
+            hasEnd: false,
+            hasResult: false
+          });
+        }
+        break;
+      }
+      case EventType.TOOL_CALL_END: {
+        const toolCallId = event.toolCallId;
+        const info = toolCallId ? openToolCalls.get(toolCallId) : void 0;
+        if (info) {
+          info.hasEnd = true;
+        }
+        break;
+      }
+      case EventType.TOOL_CALL_RESULT: {
+        const toolCallId = event.toolCallId;
+        const info = toolCallId ? openToolCalls.get(toolCallId) : void 0;
+        if (info) {
+          info.hasResult = true;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const hasRunFinished = events.some((event) => event.type === EventType.RUN_FINISHED);
+  const hasRunError = events.some((event) => event.type === EventType.RUN_ERROR);
+  const hasTerminalEvent = hasRunFinished || hasRunError;
+  const terminalEventMissing = !hasTerminalEvent;
+  for (const messageId of openMessageIds) {
+    const endEvent = {
+      type: EventType.TEXT_MESSAGE_END,
+      messageId
+    };
+    events.push(endEvent);
+    appended.push(endEvent);
+  }
+  for (const [toolCallId, info] of openToolCalls) {
+    if (!info.hasEnd) {
+      const endEvent = {
+        type: EventType.TOOL_CALL_END,
+        toolCallId
+      };
+      events.push(endEvent);
+      appended.push(endEvent);
+    }
+    if (terminalEventMissing && !info.hasResult) {
+      const resultEvent = {
+        type: EventType.TOOL_CALL_RESULT,
+        toolCallId,
+        messageId: `${toolCallId ?? randomUUID()}-result`,
+        role: "tool",
+        content: JSON.stringify(
+          stopRequested ? {
+            status: "stopped",
+            reason: "stop_requested",
+            message: resolvedStopMessage
+          } : {
+            status: "error",
+            reason: "missing_terminal_event",
+            message: resolvedAbruptMessage
+          }
+        )
+      };
+      events.push(resultEvent);
+      appended.push(resultEvent);
+    }
+  }
+  if (terminalEventMissing) {
+    if (stopRequested) {
+      const finishedEvent = {
+        type: EventType.RUN_FINISHED
+      };
+      events.push(finishedEvent);
+      appended.push(finishedEvent);
+    } else {
+      const errorEvent = {
+        type: EventType.RUN_ERROR,
+        message: resolvedAbruptMessage,
+        code: "INCOMPLETE_STREAM"
+      };
+      events.push(errorEvent);
+      appended.push(errorEvent);
+    }
+  }
+  return appended;
+}
+
+// src/runner/in-memory.ts
 var InMemoryEventStore = class {
   constructor(threadId) {
     this.threadId = threadId;
@@ -71,12 +196,18 @@ var InMemoryEventStore = class {
   subject = null;
   /** True while a run is actively producing events. */
   isRunning = false;
-  /** Lets stop() cancel the current producer. */
-  abortController = new AbortController();
   /** 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 {
@@ -92,15 +223,18 @@ var InMemoryAgentRunner = class extends AgentRunner {
     }
     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) {
+        if (event.type === EventType2.RUN_STARTED) {
           const runStarted = event;
           const messages = runStarted.input?.messages ?? [];
           for (const message of messages) {
@@ -112,8 +246,8 @@ var InMemoryAgentRunner = class extends AgentRunner {
     const nextSubject = new ReplaySubject(Infinity);
     const prevSubject = store.subject;
     store.subject = nextSubject;
-    store.abortController = new AbortController();
     const runSubject = new ReplaySubject(Infinity);
+    store.runSubject = runSubject;
     const runAgent = async () => {
       const lastRun = store.historicRuns[store.historicRuns.length - 1];
       const parentRunId = lastRun?.runId ?? null;
@@ -121,7 +255,7 @@ var InMemoryAgentRunner = class extends AgentRunner {
         await request.agent.runAgent(request.input, {
           onEvent: ({ event }) => {
             let processedEvent = event;
-            if (event.type === EventType.RUN_STARTED) {
+            if (event.type === EventType2.RUN_STARTED) {
               const runStartedEvent = event;
               if (!runStartedEvent.input) {
                 const sanitizedMessages = request.input.messages ? request.input.messages.filter(
@@ -156,6 +290,13 @@ var InMemoryAgentRunner = class extends AgentRunner {
             }
           }
         });
+        const appendedEvents = finalizeRunEvents(currentRunEvents, {
+          stopRequested: store.stopRequested
+        });
+        for (const event of appendedEvents) {
+          runSubject.next(event);
+          nextSubject.next(event);
+        }
         if (store.currentRunId) {
           const compactedEvents = compactEvents(currentRunEvents);
           store.historicRuns.push({
@@ -166,11 +307,22 @@ var InMemoryAgentRunner = class extends AgentRunner {
             createdAt: Date.now()
           });
         }
-        store.isRunning = false;
+        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 event of appendedEvents) {
+          runSubject.next(event);
+          nextSubject.next(event);
+        }
         if (store.currentRunId && currentRunEvents.length > 0) {
           const compactedEvents = compactEvents(currentRunEvents);
           store.historicRuns.push({
@@ -181,8 +333,12 @@ var InMemoryAgentRunner = class extends AgentRunner {
             createdAt: Date.now()
           });
         }
-        store.isRunning = false;
+        store.currentEvents = null;
         store.currentRunId = null;
+        store.agent = null;
+        store.runSubject = null;
+        store.stopRequested = false;
+        store.isRunning = false;
         runSubject.complete();
         nextSubject.complete();
       }
@@ -217,7 +373,7 @@ var InMemoryAgentRunner = class extends AgentRunner {
         emittedMessageIds.add(event.messageId);
       }
     }
-    if (store.subject && store.isRunning) {
+    if (store.subject && (store.isRunning || store.stopRequested)) {
       store.subject.subscribe({
         next: (event) => {
           if ("messageId" in event && typeof event.messageId === "string" && emittedMessageIds.has(event.messageId)) {
@@ -237,9 +393,31 @@ var InMemoryAgentRunner = class extends AgentRunner {
     const store = GLOBAL_STORE.get(request.threadId);
     return Promise.resolve(store?.isRunning ?? false);
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  stop(_request) {
-    throw new Error("Method not implemented.");
+  stop(request) {
+    const store = GLOBAL_STORE.get(request.threadId);
+    if (!store || !store.isRunning) {
+      return Promise.resolve(false);
+    }
+    if (store.stopRequested) {
+      return Promise.resolve(false);
+    }
+    store.stopRequested = true;
+    store.isRunning = false;
+    const agent = store.agent;
+    if (!agent) {
+      store.stopRequested = false;
+      store.isRunning = false;
+      return Promise.resolve(false);
+    }
+    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);
+    }
   }
 };
 
@@ -562,9 +740,6 @@ import { logger as logger2 } from "@copilotkitnext/shared";
 
 // src/middleware.ts
 import { logger } from "@copilotkitnext/shared";
-function isMiddlewareURL(value) {
-  return typeof value === "string" && /^https?:\/\//.test(value);
-}
 async function callBeforeRequestMiddleware({
   runtime,
   request,
@@ -575,77 +750,6 @@ async function callBeforeRequestMiddleware({
   if (typeof mw === "function") {
     return mw({ runtime, request, path });
   }
-  if (isMiddlewareURL(mw)) {
-    const clone = request.clone();
-    const url = new URL(request.url);
-    const headersObj = {};
-    clone.headers.forEach((v, k) => {
-      headersObj[k] = v;
-    });
-    let bodyJson = void 0;
-    try {
-      bodyJson = await clone.json();
-    } catch {
-    }
-    const payload = {
-      method: request.method,
-      path: url.pathname,
-      query: url.search.startsWith("?") ? url.search.slice(1) : url.search,
-      headers: headersObj,
-      body: bodyJson
-    };
-    const ac = new AbortController();
-    const to = setTimeout(() => ac.abort(), 2e3);
-    let res;
-    try {
-      res = await fetch(mw, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "X-CopilotKit-Webhook-Stage": "before_request" /* BeforeRequest */
-        },
-        body: JSON.stringify(payload),
-        signal: ac.signal
-      });
-    } catch {
-      clearTimeout(to);
-      throw new Response(void 0, { status: 502 });
-    }
-    clearTimeout(to);
-    if (res.status >= 500) {
-      throw new Response(void 0, { status: 502 });
-    }
-    if (res.status >= 400) {
-      const errBody = await res.text();
-      throw new Response(errBody || null, {
-        status: res.status,
-        headers: {
-          "content-type": res.headers.get("content-type") || "application/json"
-        }
-      });
-    }
-    if (res.status === 204) return;
-    let json;
-    try {
-      json = await res.json();
-    } catch {
-      return;
-    }
-    if (json && typeof json === "object") {
-      const { headers, body } = json;
-      const init = {
-        method: request.method
-      };
-      if (headers) {
-        init.headers = headers;
-      }
-      if (body !== void 0 && request.method !== "GET" && request.method !== "HEAD") {
-        init.body = JSON.stringify(body);
-      }
-      return new Request(request.url, init);
-    }
-    return;
-  }
   logger.warn({ mw }, "Unsupported beforeRequestMiddleware value \u2013 skipped");
   return;
 }
@@ -659,45 +763,6 @@ async function callAfterRequestMiddleware({
   if (typeof mw === "function") {
     return mw({ runtime, response, path });
   }
-  if (isMiddlewareURL(mw)) {
-    const clone = response.clone();
-    const headersObj = {};
-    clone.headers.forEach((v, k) => {
-      headersObj[k] = v;
-    });
-    let body = "";
-    try {
-      body = await clone.text();
-    } catch {
-    }
-    const payload = {
-      status: clone.status,
-      headers: headersObj,
-      body
-    };
-    const ac = new AbortController();
-    const to = setTimeout(() => ac.abort(), 2e3);
-    let res;
-    try {
-      res = await fetch(mw, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "X-CopilotKit-Webhook-Stage": "after_request" /* AfterRequest */
-        },
-        body: JSON.stringify(payload),
-        signal: ac.signal
-      });
-    } finally {
-      clearTimeout(to);
-    }
-    if (!res.ok) {
-      throw new Error(
-        `after_request webhook ${mw} responded with ${res.status}`
-      );
-    }
-    return;
-  }
   logger.warn({ mw }, "Unsupported afterRequestMiddleware value \u2013 skipped");
 }
 
@@ -825,11 +890,72 @@ async function handleConnectAgent({
   }
 }
 
-// src/endpoint.ts
-function createCopilotEndpoint({
+// src/handlers/handle-stop.ts
+import { EventType as EventType3 } from "@ag-ui/client";
+async function handleStopAgent({
   runtime,
-  basePath
+  request,
+  agentId,
+  threadId
 }) {
+  try {
+    const agents = await runtime.agents;
+    if (!agents[agentId]) {
+      return new Response(
+        JSON.stringify({
+          error: "Agent not found",
+          message: `Agent '${agentId}' does not exist`
+        }),
+        {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const stopped = await runtime.runner.stop({ threadId });
+    if (!stopped) {
+      return new Response(
+        JSON.stringify({
+          stopped: false,
+          message: `No active run for thread '${threadId}'.`
+        }),
+        {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    return new Response(
+      JSON.stringify({
+        stopped: true,
+        interrupt: {
+          type: EventType3.RUN_ERROR,
+          message: "Run stopped by user",
+          code: "STOPPED"
+        }
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  } catch (error) {
+    console.error("Error stopping agent run:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to stop agent",
+        message: error instanceof Error ? error.message : "Unknown error"
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+
+// src/endpoint.ts
+function createCopilotEndpoint({ runtime, basePath }) {
   const app = new Hono();
   return app.basePath(basePath).use(
     "*",
@@ -851,10 +977,7 @@ function createCopilotEndpoint({
         c.set("modifiedRequest", maybeModifiedRequest);
       }
     } catch (error) {
-      logger2.error(
-        { err: error, url: request.url, path },
-        "Error running before request middleware"
-      );
+      logger2.error({ err: error, url: request.url, path }, "Error running before request middleware");
       if (error instanceof Response) {
         return error;
       }
@@ -870,10 +993,7 @@ function createCopilotEndpoint({
       response,
       path
     }).catch((error) => {
-      logger2.error(
-        { err: error, url: c.req.url, path },
-        "Error running after request middleware"
-      );
+      logger2.error({ err: error, url: c.req.url, path }, "Error running after request middleware");
     });
   }).post("/agent/:agentId/run", async (c) => {
     const agentId = c.req.param("agentId");
@@ -885,10 +1005,7 @@ function createCopilotEndpoint({
         agentId
       });
     } catch (error) {
-      logger2.error(
-        { err: error, url: request.url, path: c.req.path },
-        "Error running request handler"
-      );
+      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).post("/agent/:agentId/connect", async (c) => {
@@ -901,10 +1018,22 @@ function createCopilotEndpoint({
         agentId
       });
     } catch (error) {
-      logger2.error(
-        { err: error, url: request.url, path: c.req.path },
-        "Error running request handler"
-      );
+      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
+      throw error;
+    }
+  }).post("/agent/:agentId/stop/:threadId", async (c) => {
+    const agentId = c.req.param("agentId");
+    const threadId = c.req.param("threadId");
+    const request = c.get("modifiedRequest") || c.req.raw;
+    try {
+      return await handleStopAgent({
+        runtime,
+        request,
+        agentId,
+        threadId
+      });
+    } catch (error) {
+      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).get("/info", async (c) => {
@@ -915,10 +1044,7 @@ function createCopilotEndpoint({
         request
       });
     } catch (error) {
-      logger2.error(
-        { err: error, url: request.url, path: c.req.path },
-        "Error running request handler"
-      );
+      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).post("/transcribe", async (c) => {
@@ -929,10 +1055,7 @@ function createCopilotEndpoint({
         request
       });
     } catch (error) {
-      logger2.error(
-        { err: error, url: request.url, path: c.req.path },
-        "Error running request handler"
-      );
+      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).notFound((c) => {
@@ -944,6 +1067,7 @@ export {
   CopilotRuntime,
   InMemoryAgentRunner,
   VERSION,
-  createCopilotEndpoint
+  createCopilotEndpoint,
+  finalizeRunEvents
 };
 //# sourceMappingURL=index.mjs.map