@copilotkitnext/runtime 0.0.16 → 0.0.17

package/dist/index.js

@@ -24,14 +24,15 @@ __export(index_exports, {
   CopilotRuntime: () => CopilotRuntime,
   InMemoryAgentRunner: () => InMemoryAgentRunner,
   VERSION: () => VERSION,
-  createCopilotEndpoint: () => createCopilotEndpoint
+  createCopilotEndpoint: () => createCopilotEndpoint,
+  finalizeRunEvents: () => finalizeRunEvents
 });
 module.exports = __toCommonJS(index_exports);
 
 // 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",
@@ -89,7 +90,130 @@ var AgentRunner = class {
 
 // src/runner/in-memory.ts
 var import_rxjs = require("rxjs");
+var import_client2 = require("@ag-ui/client");
+
+// src/runner/finalize-events.ts
+var import_node_crypto = require("crypto");
 var import_client = require("@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 import_client.EventType.TEXT_MESSAGE_START: {
+        const messageId = event.messageId;
+        if (typeof messageId === "string") {
+          openMessageIds.add(messageId);
+        }
+        break;
+      }
+      case import_client.EventType.TEXT_MESSAGE_END: {
+        const messageId = event.messageId;
+        if (typeof messageId === "string") {
+          openMessageIds.delete(messageId);
+        }
+        break;
+      }
+      case import_client.EventType.TOOL_CALL_START: {
+        const toolCallId = event.toolCallId;
+        if (typeof toolCallId === "string") {
+          openToolCalls.set(toolCallId, {
+            hasEnd: false,
+            hasResult: false
+          });
+        }
+        break;
+      }
+      case import_client.EventType.TOOL_CALL_END: {
+        const toolCallId = event.toolCallId;
+        const info = toolCallId ? openToolCalls.get(toolCallId) : void 0;
+        if (info) {
+          info.hasEnd = true;
+        }
+        break;
+      }
+      case import_client.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 === import_client.EventType.RUN_FINISHED);
+  const hasRunError = events.some((event) => event.type === import_client.EventType.RUN_ERROR);
+  const hasTerminalEvent = hasRunFinished || hasRunError;
+  const terminalEventMissing = !hasTerminalEvent;
+  for (const messageId of openMessageIds) {
+    const endEvent = {
+      type: import_client.EventType.TEXT_MESSAGE_END,
+      messageId
+    };
+    events.push(endEvent);
+    appended.push(endEvent);
+  }
+  for (const [toolCallId, info] of openToolCalls) {
+    if (!info.hasEnd) {
+      const endEvent = {
+        type: import_client.EventType.TOOL_CALL_END,
+        toolCallId
+      };
+      events.push(endEvent);
+      appended.push(endEvent);
+    }
+    if (terminalEventMissing && !info.hasResult) {
+      const resultEvent = {
+        type: import_client.EventType.TOOL_CALL_RESULT,
+        toolCallId,
+        messageId: `${toolCallId ?? (0, import_node_crypto.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: import_client.EventType.RUN_FINISHED
+      };
+      events.push(finishedEvent);
+      appended.push(finishedEvent);
+    } else {
+      const errorEvent = {
+        type: import_client.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;
@@ -98,12 +222,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 {
@@ -119,15 +249,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 === import_client.EventType.RUN_STARTED) {
+        if (event.type === import_client2.EventType.RUN_STARTED) {
           const runStarted = event;
           const messages = runStarted.input?.messages ?? [];
           for (const message of messages) {
@@ -139,8 +272,8 @@ var InMemoryAgentRunner = class extends AgentRunner {
     const nextSubject = new import_rxjs.ReplaySubject(Infinity);
     const prevSubject = store.subject;
     store.subject = nextSubject;
-    store.abortController = new AbortController();
     const runSubject = new import_rxjs.ReplaySubject(Infinity);
+    store.runSubject = runSubject;
     const runAgent = async () => {
       const lastRun = store.historicRuns[store.historicRuns.length - 1];
       const parentRunId = lastRun?.runId ?? null;
@@ -148,7 +281,7 @@ var InMemoryAgentRunner = class extends AgentRunner {
         await request.agent.runAgent(request.input, {
           onEvent: ({ event }) => {
             let processedEvent = event;
-            if (event.type === import_client.EventType.RUN_STARTED) {
+            if (event.type === import_client2.EventType.RUN_STARTED) {
               const runStartedEvent = event;
               if (!runStartedEvent.input) {
                 const sanitizedMessages = request.input.messages ? request.input.messages.filter(
@@ -183,8 +316,15 @@ 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 = (0, import_client.compactEvents)(currentRunEvents);
+          const compactedEvents = (0, import_client2.compactEvents)(currentRunEvents);
           store.historicRuns.push({
             threadId: request.threadId,
             runId: store.currentRunId,
@@ -193,13 +333,24 @@ 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 = (0, import_client.compactEvents)(currentRunEvents);
+          const compactedEvents = (0, import_client2.compactEvents)(currentRunEvents);
           store.historicRuns.push({
             threadId: request.threadId,
             runId: store.currentRunId,
@@ -208,8 +359,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();
       }
@@ -236,7 +391,7 @@ var InMemoryAgentRunner = class extends AgentRunner {
     for (const run of store.historicRuns) {
       allHistoricEvents.push(...run.events);
     }
-    const compactedEvents = (0, import_client.compactEvents)(allHistoricEvents);
+    const compactedEvents = (0, import_client2.compactEvents)(allHistoricEvents);
     const emittedMessageIds = /* @__PURE__ */ new Set();
     for (const event of compactedEvents) {
       connectionSubject.next(event);
@@ -244,7 +399,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)) {
@@ -264,9 +419,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);
+    }
   }
 };
 
@@ -298,7 +475,7 @@ var import_hono = require("hono");
 var import_cors = require("hono/cors");
 
 // src/handlers/handle-run.ts
-var import_client2 = require("@ag-ui/client");
+var import_client3 = require("@ag-ui/client");
 var import_encoder = require("@ag-ui/encoder");
 async function handleRunAgent({
   runtime,
@@ -345,7 +522,7 @@ async function handleRunAgent({
       let input;
       try {
         const requestBody = await request.json();
-        input = import_client2.RunAgentInputSchema.parse(requestBody);
+        input = import_client3.RunAgentInputSchema.parse(requestBody);
       } catch {
         return new Response(
           JSON.stringify({
@@ -587,9 +764,6 @@ var import_shared2 = require("@copilotkitnext/shared");
 
 // src/middleware.ts
 var import_shared = require("@copilotkitnext/shared");
-function isMiddlewareURL(value) {
-  return typeof value === "string" && /^https?:\/\//.test(value);
-}
 async function callBeforeRequestMiddleware({
   runtime,
   request,
@@ -600,77 +774,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;
-  }
   import_shared.logger.warn({ mw }, "Unsupported beforeRequestMiddleware value \u2013 skipped");
   return;
 }
@@ -684,50 +787,11 @@ 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;
-  }
   import_shared.logger.warn({ mw }, "Unsupported afterRequestMiddleware value \u2013 skipped");
 }
 
 // src/handlers/handle-connect.ts
-var import_client3 = require("@ag-ui/client");
+var import_client4 = require("@ag-ui/client");
 var import_encoder2 = require("@ag-ui/encoder");
 async function handleConnectAgent({
   runtime,
@@ -756,7 +820,7 @@ async function handleConnectAgent({
       let input;
       try {
         const requestBody = await request.json();
-        input = import_client3.RunAgentInputSchema.parse(requestBody);
+        input = import_client4.RunAgentInputSchema.parse(requestBody);
       } catch {
         return new Response(
           JSON.stringify({
@@ -850,11 +914,72 @@ async function handleConnectAgent({
   }
 }
 
-// src/endpoint.ts
-function createCopilotEndpoint({
+// src/handlers/handle-stop.ts
+var import_client5 = require("@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: import_client5.EventType.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 import_hono.Hono();
   return app.basePath(basePath).use(
     "*",
@@ -876,10 +1001,7 @@ function createCopilotEndpoint({
         c.set("modifiedRequest", maybeModifiedRequest);
       }
     } catch (error) {
-      import_shared2.logger.error(
-        { err: error, url: request.url, path },
-        "Error running before request middleware"
-      );
+      import_shared2.logger.error({ err: error, url: request.url, path }, "Error running before request middleware");
       if (error instanceof Response) {
         return error;
       }
@@ -895,10 +1017,7 @@ function createCopilotEndpoint({
       response,
       path
     }).catch((error) => {
-      import_shared2.logger.error(
-        { err: error, url: c.req.url, path },
-        "Error running after request middleware"
-      );
+      import_shared2.logger.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");
@@ -910,10 +1029,7 @@ function createCopilotEndpoint({
         agentId
       });
     } catch (error) {
-      import_shared2.logger.error(
-        { err: error, url: request.url, path: c.req.path },
-        "Error running request handler"
-      );
+      import_shared2.logger.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).post("/agent/:agentId/connect", async (c) => {
@@ -926,10 +1042,22 @@ function createCopilotEndpoint({
         agentId
       });
     } catch (error) {
-      import_shared2.logger.error(
-        { err: error, url: request.url, path: c.req.path },
-        "Error running request handler"
-      );
+      import_shared2.logger.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) {
+      import_shared2.logger.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).get("/info", async (c) => {
@@ -940,10 +1068,7 @@ function createCopilotEndpoint({
         request
       });
     } catch (error) {
-      import_shared2.logger.error(
-        { err: error, url: request.url, path: c.req.path },
-        "Error running request handler"
-      );
+      import_shared2.logger.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).post("/transcribe", async (c) => {
@@ -954,10 +1079,7 @@ function createCopilotEndpoint({
         request
       });
     } catch (error) {
-      import_shared2.logger.error(
-        { err: error, url: request.url, path: c.req.path },
-        "Error running request handler"
-      );
+      import_shared2.logger.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).notFound((c) => {
@@ -970,6 +1092,7 @@ function createCopilotEndpoint({
   CopilotRuntime,
   InMemoryAgentRunner,
   VERSION,
-  createCopilotEndpoint
+  createCopilotEndpoint,
+  finalizeRunEvents
 });
 //# sourceMappingURL=index.js.map