@copilotkitnext/runtime 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1841 @@
+// package.json
+var package_default = {
+  name: "@copilotkitnext/runtime",
+  version: "0.0.1",
+  description: "Server-side runtime package for CopilotKit2",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    }
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup",
+    prepublishOnly: "pnpm run build",
+    dev: "tsup --watch",
+    lint: "eslint . --max-warnings 0",
+    "check-types": "tsc --noEmit",
+    clean: "rm -rf dist",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  devDependencies: {
+    "@copilotkitnext/eslint-config": "workspace:*",
+    "@copilotkitnext/typescript-config": "workspace:*",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.15.3",
+    "better-sqlite3": "^12.2.0",
+    eslint: "^9.30.0",
+    "ioredis-mock": "^8.9.0",
+    openai: "^5.9.0",
+    tsup: "^8.5.0",
+    typescript: "5.8.2",
+    vitest: "^3.0.5"
+  },
+  dependencies: {
+    "@ag-ui/client": "0.0.36-alpha.1",
+    "@ag-ui/core": "0.0.36-alpha.1",
+    "@ag-ui/encoder": "0.0.36-alpha.1",
+    "@copilotkitnext/shared": "workspace:*",
+    hono: "^4.6.13",
+    ioredis: "^5.7.0",
+    kysely: "^0.28.5",
+    rxjs: "7.8.1"
+  },
+  peerDependencies: {
+    "better-sqlite3": "^12.2.0",
+    openai: "^5.9.0"
+  },
+  peerDependenciesMeta: {
+    "better-sqlite3": {
+      optional: true
+    }
+  },
+  engines: {
+    node: ">=18"
+  }
+};
+
+// src/runner/agent-runner.ts
+var AgentRunner = class {
+};
+
+// src/runner/in-memory.ts
+import { ReplaySubject } from "rxjs";
+import {
+  EventType as EventType2
+} from "@ag-ui/client";
+
+// src/runner/event-compaction.ts
+import {
+  EventType
+} from "@ag-ui/client";
+function compactEvents(events) {
+  const compacted = [];
+  const pendingTextMessages = /* @__PURE__ */ new Map();
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type === EventType.TEXT_MESSAGE_START) {
+      const startEvent = event;
+      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;
+      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;
+      const messageId = endEvent.messageId;
+      if (!pendingTextMessages.has(messageId)) {
+        pendingTextMessages.set(messageId, {
+          contents: [],
+          otherEvents: []
+        });
+      }
+      const pending = pendingTextMessages.get(messageId);
+      pending.end = endEvent;
+      flushTextMessage(messageId, pending, compacted);
+      pendingTextMessages.delete(messageId);
+    } else if (event.type === EventType.TOOL_CALL_START) {
+      const startEvent = event;
+      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;
+      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;
+      const toolCallId = endEvent.toolCallId;
+      if (!pendingToolCalls.has(toolCallId)) {
+        pendingToolCalls.set(toolCallId, {
+          args: [],
+          otherEvents: []
+        });
+      }
+      const pending = pendingToolCalls.get(toolCallId);
+      pending.end = endEvent;
+      flushToolCall(toolCallId, pending, compacted);
+      pendingToolCalls.delete(toolCallId);
+    } else {
+      let addedToBuffer = false;
+      for (const [messageId, pending] of pendingTextMessages) {
+        if (pending.start && !pending.end) {
+          pending.otherEvents.push(event);
+          addedToBuffer = true;
+          break;
+        }
+      }
+      if (!addedToBuffer) {
+        for (const [toolCallId, pending] of pendingToolCalls) {
+          if (pending.start && !pending.end) {
+            pending.otherEvents.push(event);
+            addedToBuffer = true;
+            break;
+          }
+        }
+      }
+      if (!addedToBuffer) {
+        compacted.push(event);
+      }
+    }
+  }
+  for (const [messageId, pending] of pendingTextMessages) {
+    flushTextMessage(messageId, pending, compacted);
+  }
+  for (const [toolCallId, pending] of pendingToolCalls) {
+    flushToolCall(toolCallId, pending, compacted);
+  }
+  return compacted;
+}
+function flushTextMessage(messageId, pending, compacted) {
+  if (pending.start) {
+    compacted.push(pending.start);
+  }
+  if (pending.contents.length > 0) {
+    const concatenatedDelta = pending.contents.map((c) => c.delta).join("");
+    const compactedContent = {
+      type: EventType.TEXT_MESSAGE_CONTENT,
+      messageId,
+      delta: concatenatedDelta
+    };
+    compacted.push(compactedContent);
+  }
+  if (pending.end) {
+    compacted.push(pending.end);
+  }
+  for (const otherEvent of pending.otherEvents) {
+    compacted.push(otherEvent);
+  }
+}
+function flushToolCall(toolCallId, pending, compacted) {
+  if (pending.start) {
+    compacted.push(pending.start);
+  }
+  if (pending.args.length > 0) {
+    const concatenatedArgs = pending.args.map((a) => a.delta).join("");
+    const compactedArgs = {
+      type: EventType.TOOL_CALL_ARGS,
+      toolCallId,
+      delta: concatenatedArgs
+    };
+    compacted.push(compactedArgs);
+  }
+  if (pending.end) {
+    compacted.push(pending.end);
+  }
+  for (const otherEvent of pending.otherEvents) {
+    compacted.push(otherEvent);
+  }
+}
+
+// src/runner/in-memory.ts
+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;
+  /** Lets stop() cancel the current producer. */
+  abortController = new AbortController();
+  /** Current run ID */
+  currentRunId = null;
+  /** Historic completed runs */
+  historicRuns = [];
+};
+var GLOBAL_STORE = /* @__PURE__ */ new Map();
+var InMemoryAgentRunner = class extends AgentRunner {
+  convertMessageToEvents(message) {
+    const events = [];
+    if ((message.role === "assistant" || message.role === "user" || message.role === "developer" || message.role === "system") && message.content) {
+      const textStartEvent = {
+        type: EventType2.TEXT_MESSAGE_START,
+        messageId: message.id,
+        role: message.role
+      };
+      events.push(textStartEvent);
+      const textContentEvent = {
+        type: EventType2.TEXT_MESSAGE_CONTENT,
+        messageId: message.id,
+        delta: message.content
+      };
+      events.push(textContentEvent);
+      const textEndEvent = {
+        type: EventType2.TEXT_MESSAGE_END,
+        messageId: message.id
+      };
+      events.push(textEndEvent);
+    }
+    if (message.role === "assistant" && message.toolCalls) {
+      for (const toolCall of message.toolCalls) {
+        const toolStartEvent = {
+          type: EventType2.TOOL_CALL_START,
+          toolCallId: toolCall.id,
+          toolCallName: toolCall.function.name,
+          parentMessageId: message.id
+        };
+        events.push(toolStartEvent);
+        const toolArgsEvent = {
+          type: EventType2.TOOL_CALL_ARGS,
+          toolCallId: toolCall.id,
+          delta: toolCall.function.arguments
+        };
+        events.push(toolArgsEvent);
+        const toolEndEvent = {
+          type: EventType2.TOOL_CALL_END,
+          toolCallId: toolCall.id
+        };
+        events.push(toolEndEvent);
+      }
+    }
+    if (message.role === "tool" && message.toolCallId) {
+      const toolResultEvent = {
+        type: EventType2.TOOL_CALL_RESULT,
+        messageId: message.id,
+        toolCallId: message.toolCallId,
+        content: message.content,
+        role: "tool"
+      };
+      events.push(toolResultEvent);
+    }
+    return events;
+  }
+  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;
+    const seenMessageIds = /* @__PURE__ */ new Set();
+    const 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);
+        }
+      }
+    }
+    const nextSubject = new ReplaySubject(Infinity);
+    const prevSubject = store.subject;
+    store.subject = nextSubject;
+    store.abortController = new AbortController();
+    const runSubject = new ReplaySubject(Infinity);
+    const runAgent = async () => {
+      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);
+            nextSubject.next(event);
+            currentRunEvents.push(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 events = this.convertMessageToEvents(message);
+                  const isNewMessage = !historicMessageIds.has(message.id);
+                  for (const event of events) {
+                    nextSubject.next(event);
+                    if (isNewMessage) {
+                      currentRunEvents.push(event);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        });
+        if (store.currentRunId) {
+          const compactedEvents = compactEvents(currentRunEvents);
+          store.historicRuns.push({
+            threadId: request.threadId,
+            runId: store.currentRunId,
+            parentRunId,
+            events: compactedEvents,
+            createdAt: Date.now()
+          });
+        }
+        store.isRunning = false;
+        store.currentRunId = null;
+        runSubject.complete();
+        nextSubject.complete();
+      } catch {
+        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()
+          });
+        }
+        store.isRunning = false;
+        store.currentRunId = null;
+        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);
+      }
+    }
+    if (store.subject && store.isRunning) {
+      store.subject.subscribe({
+        next: (event) => {
+          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 {
+      connectionSubject.complete();
+    }
+    return connectionSubject.asObservable();
+  }
+  isRunning(request) {
+    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.");
+  }
+};
+
+// src/runtime.ts
+var VERSION = package_default.version;
+var CopilotRuntime = class {
+  agents;
+  transcriptionService;
+  beforeRequestMiddleware;
+  afterRequestMiddleware;
+  runner;
+  constructor({
+    agents,
+    transcriptionService,
+    beforeRequestMiddleware,
+    afterRequestMiddleware,
+    runner
+  }) {
+    this.agents = agents;
+    this.transcriptionService = transcriptionService;
+    this.beforeRequestMiddleware = beforeRequestMiddleware;
+    this.afterRequestMiddleware = afterRequestMiddleware;
+    this.runner = runner ?? new InMemoryAgentRunner();
+  }
+};
+
+// src/endpoint.ts
+import { Hono } from "hono";
+
+// src/handlers/handle-run.ts
+import {
+  RunAgentInputSchema
+} from "@ag-ui/client";
+import { EventEncoder } from "@ag-ui/encoder";
+async function handleRunAgent({
+  runtime,
+  request,
+  agentId
+}) {
+  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 agent = agents[agentId].clone();
+    const stream = new TransformStream();
+    const writer = stream.writable.getWriter();
+    const encoder = new EventEncoder();
+    let streamClosed = false;
+    (async () => {
+      let input;
+      try {
+        const requestBody = await request.json();
+        input = RunAgentInputSchema.parse(requestBody);
+      } catch {
+        return new Response(
+          JSON.stringify({
+            error: "Invalid request body"
+          }),
+          { status: 400 }
+        );
+      }
+      agent.setMessages(input.messages);
+      agent.setState(input.state);
+      agent.threadId = input.threadId;
+      runtime.runner.run({
+        threadId: input.threadId,
+        agent,
+        input
+      }).subscribe({
+        next: async (event) => {
+          if (!request.signal.aborted && !streamClosed) {
+            try {
+              await writer.write(encoder.encode(event));
+            } catch (error) {
+              if (error instanceof Error && error.name === "AbortError") {
+                streamClosed = true;
+              }
+            }
+          }
+        },
+        error: async (error) => {
+          console.error("Error running agent:", error);
+          if (!streamClosed) {
+            try {
+              await writer.close();
+              streamClosed = true;
+            } catch {
+            }
+          }
+        },
+        complete: async () => {
+          if (!streamClosed) {
+            try {
+              await writer.close();
+              streamClosed = true;
+            } catch {
+            }
+          }
+        }
+      });
+    })().catch((error) => {
+      console.error("Error running agent:", error);
+      console.error(
+        "Error stack:",
+        error instanceof Error ? error.stack : "No stack trace"
+      );
+      console.error("Error details:", {
+        name: error instanceof Error ? error.name : "Unknown",
+        message: error instanceof Error ? error.message : String(error),
+        cause: error instanceof Error ? error.cause : void 0
+      });
+      if (!streamClosed) {
+        try {
+          writer.close();
+          streamClosed = true;
+        } catch {
+        }
+      }
+    });
+    return new Response(stream.readable, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  } catch (error) {
+    console.error("Error running agent:", error);
+    console.error(
+      "Error stack:",
+      error instanceof Error ? error.stack : "No stack trace"
+    );
+    console.error("Error details:", {
+      name: error instanceof Error ? error.name : "Unknown",
+      message: error instanceof Error ? error.message : String(error),
+      cause: error instanceof Error ? error.cause : void 0
+    });
+    return new Response(
+      JSON.stringify({
+        error: "Failed to run agent",
+        message: error instanceof Error ? error.message : "Unknown error"
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+
+// src/handlers/get-runtime-info.ts
+async function handleGetRuntimeInfo({
+  runtime
+}) {
+  try {
+    const agents = await runtime.agents;
+    const agentsDict = Object.entries(agents).reduce(
+      (acc, [name, agent]) => {
+        acc[name] = {
+          name,
+          description: agent.description,
+          className: agent.constructor.name
+        };
+        return acc;
+      },
+      {}
+    );
+    const runtimeInfo = {
+      version: VERSION,
+      agents: agentsDict,
+      audioFileTranscriptionEnabled: !!runtime.transcriptionService
+    };
+    return new Response(JSON.stringify(runtimeInfo), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  } catch (error) {
+    return new Response(
+      JSON.stringify({
+        error: "Failed to retrieve runtime information",
+        message: error instanceof Error ? error.message : "Unknown error"
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+
+// src/handlers/handle-transcribe.ts
+async function handleTranscribe({
+  runtime,
+  request
+}) {
+  try {
+    if (!runtime.transcriptionService) {
+      return new Response(
+        JSON.stringify({
+          error: "Transcription service not configured",
+          message: "No transcription service has been configured in the runtime"
+        }),
+        {
+          status: 503,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const contentType = request.headers.get("content-type");
+    if (!contentType || !contentType.includes("multipart/form-data")) {
+      return new Response(
+        JSON.stringify({
+          error: "Invalid content type",
+          message: "Request must contain multipart/form-data with an audio file"
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const formData = await request.formData();
+    const audioFile = formData.get("audio");
+    if (!audioFile || !(audioFile instanceof File)) {
+      return new Response(
+        JSON.stringify({
+          error: "Missing audio file",
+          message: "No audio file found in form data. Please include an 'audio' field."
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const validAudioTypes = [
+      "audio/mpeg",
+      "audio/mp3",
+      "audio/mp4",
+      "audio/wav",
+      "audio/webm",
+      "audio/ogg",
+      "audio/flac",
+      "audio/aac"
+    ];
+    const isValidType = validAudioTypes.includes(audioFile.type) || audioFile.type === "" || audioFile.type === "application/octet-stream";
+    if (!isValidType) {
+      return new Response(
+        JSON.stringify({
+          error: "Invalid file type",
+          message: `Unsupported audio file type: ${audioFile.type}. Supported types: ${validAudioTypes.join(", ")}, or files with unknown/empty types`
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const transcription = await runtime.transcriptionService.transcribeFile({
+      audioFile,
+      mimeType: audioFile.type,
+      size: audioFile.size
+    });
+    return new Response(
+      JSON.stringify({
+        text: transcription,
+        size: audioFile.size,
+        type: audioFile.type
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  } catch (error) {
+    return new Response(
+      JSON.stringify({
+        error: "Transcription failed",
+        message: error instanceof Error ? error.message : "Unknown error occurred during transcription"
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+
+// src/endpoint.ts
+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,
+  path
+}) {
+  const mw = runtime.beforeRequestMiddleware;
+  if (!mw) return;
+  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;
+}
+async function callAfterRequestMiddleware({
+  runtime,
+  response,
+  path
+}) {
+  const mw = runtime.afterRequestMiddleware;
+  if (!mw) return;
+  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");
+}
+
+// src/handlers/handle-connect.ts
+import { RunAgentInputSchema as RunAgentInputSchema2 } from "@ag-ui/client";
+import { EventEncoder as EventEncoder2 } from "@ag-ui/encoder";
+async function handleConnectAgent({
+  runtime,
+  request,
+  agentId
+}) {
+  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 stream = new TransformStream();
+    const writer = stream.writable.getWriter();
+    const encoder = new EventEncoder2();
+    let streamClosed = false;
+    (async () => {
+      let input;
+      try {
+        const requestBody = await request.json();
+        input = RunAgentInputSchema2.parse(requestBody);
+      } catch {
+        return new Response(
+          JSON.stringify({
+            error: "Invalid request body"
+          }),
+          { status: 400 }
+        );
+      }
+      runtime.runner.connect({
+        threadId: input.threadId
+      }).subscribe({
+        next: async (event) => {
+          if (!request.signal.aborted && !streamClosed) {
+            try {
+              await writer.write(encoder.encode(event));
+            } catch (error) {
+              if (error instanceof Error && error.name === "AbortError") {
+                streamClosed = true;
+              }
+            }
+          }
+        },
+        error: async (error) => {
+          console.error("Error running agent:", error);
+          if (!streamClosed) {
+            try {
+              await writer.close();
+              streamClosed = true;
+            } catch {
+            }
+          }
+        },
+        complete: async () => {
+          if (!streamClosed) {
+            try {
+              await writer.close();
+              streamClosed = true;
+            } catch {
+            }
+          }
+        }
+      });
+    })().catch((error) => {
+      console.error("Error running agent:", error);
+      console.error(
+        "Error stack:",
+        error instanceof Error ? error.stack : "No stack trace"
+      );
+      console.error("Error details:", {
+        name: error instanceof Error ? error.name : "Unknown",
+        message: error instanceof Error ? error.message : String(error),
+        cause: error instanceof Error ? error.cause : void 0
+      });
+      if (!streamClosed) {
+        try {
+          writer.close();
+          streamClosed = true;
+        } catch {
+        }
+      }
+    });
+    return new Response(stream.readable, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  } catch (error) {
+    console.error("Error running agent:", error);
+    console.error(
+      "Error stack:",
+      error instanceof Error ? error.stack : "No stack trace"
+    );
+    console.error("Error details:", {
+      name: error instanceof Error ? error.name : "Unknown",
+      message: error instanceof Error ? error.message : String(error),
+      cause: error instanceof Error ? error.cause : void 0
+    });
+    return new Response(
+      JSON.stringify({
+        error: "Failed to run 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("*", async (c, next) => {
+    const request = c.req.raw;
+    const path = c.req.path;
+    try {
+      const maybeModifiedRequest = await callBeforeRequestMiddleware({
+        runtime,
+        request,
+        path
+      });
+      if (maybeModifiedRequest) {
+        c.set("modifiedRequest", maybeModifiedRequest);
+      }
+    } catch (error) {
+      logger2.error(
+        { err: error, url: request.url, path },
+        "Error running before request middleware"
+      );
+      if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    }
+    await next();
+  }).use("*", async (c, next) => {
+    await next();
+    const response = c.res;
+    const path = c.req.path;
+    callAfterRequestMiddleware({
+      runtime,
+      response,
+      path
+    }).catch((error) => {
+      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");
+    const request = c.get("modifiedRequest") || c.req.raw;
+    try {
+      return await handleRunAgent({
+        runtime,
+        request,
+        agentId
+      });
+    } catch (error) {
+      logger2.error(
+        { err: error, url: request.url, path: c.req.path },
+        "Error running request handler"
+      );
+      throw error;
+    }
+  }).post("/agent/:agentId/connect", async (c) => {
+    const agentId = c.req.param("agentId");
+    const request = c.get("modifiedRequest") || c.req.raw;
+    try {
+      return await handleConnectAgent({
+        runtime,
+        request,
+        agentId
+      });
+    } catch (error) {
+      logger2.error(
+        { err: error, url: request.url, path: c.req.path },
+        "Error running request handler"
+      );
+      throw error;
+    }
+  }).get("/info", async (c) => {
+    const request = c.get("modifiedRequest") || c.req.raw;
+    try {
+      return await handleGetRuntimeInfo({
+        runtime,
+        request
+      });
+    } catch (error) {
+      logger2.error(
+        { err: error, url: request.url, path: c.req.path },
+        "Error running request handler"
+      );
+      throw error;
+    }
+  }).post("/transcribe", async (c) => {
+    const request = c.get("modifiedRequest") || c.req.raw;
+    try {
+      return await handleTranscribe({
+        runtime,
+        request
+      });
+    } catch (error) {
+      logger2.error(
+        { err: error, url: request.url, path: c.req.path },
+        "Error running request handler"
+      );
+      throw error;
+    }
+  }).notFound((c) => {
+    return c.json({ error: "Not found" }, 404);
+  });
+}
+
+// src/runner/sqlite.ts
+import { ReplaySubject as ReplaySubject2 } from "rxjs";
+import {
+  EventType as EventType3
+} from "@ag-ui/client";
+import Database from "better-sqlite3";
+var SCHEMA_VERSION = 1;
+var ACTIVE_CONNECTIONS = /* @__PURE__ */ new Map();
+var SqliteAgentRunner = class extends AgentRunner {
+  db;
+  constructor(options = {}) {
+    super();
+    const dbPath = options.dbPath ?? ":memory:";
+    if (!Database) {
+      throw new Error(
+        "better-sqlite3 is required for SqliteAgentRunner but was not found.\nPlease install it in your project:\n  npm install better-sqlite3\n  or\n  pnpm add better-sqlite3\n  or\n  yarn add better-sqlite3\n\nIf you don't need persistence, use InMemoryAgentRunner instead."
+      );
+    }
+    this.db = new Database(dbPath);
+    this.initializeSchema();
+  }
+  convertMessageToEvents(message) {
+    const events = [];
+    if ((message.role === "assistant" || message.role === "user" || message.role === "developer" || message.role === "system") && message.content) {
+      const textStartEvent = {
+        type: EventType3.TEXT_MESSAGE_START,
+        messageId: message.id,
+        role: message.role
+      };
+      events.push(textStartEvent);
+      const textContentEvent = {
+        type: EventType3.TEXT_MESSAGE_CONTENT,
+        messageId: message.id,
+        delta: message.content
+      };
+      events.push(textContentEvent);
+      const textEndEvent = {
+        type: EventType3.TEXT_MESSAGE_END,
+        messageId: message.id
+      };
+      events.push(textEndEvent);
+    }
+    if (message.role === "assistant" && message.toolCalls) {
+      for (const toolCall of message.toolCalls) {
+        const toolStartEvent = {
+          type: EventType3.TOOL_CALL_START,
+          toolCallId: toolCall.id,
+          toolCallName: toolCall.function.name,
+          parentMessageId: message.id
+        };
+        events.push(toolStartEvent);
+        const toolArgsEvent = {
+          type: EventType3.TOOL_CALL_ARGS,
+          toolCallId: toolCall.id,
+          delta: toolCall.function.arguments
+        };
+        events.push(toolArgsEvent);
+        const toolEndEvent = {
+          type: EventType3.TOOL_CALL_END,
+          toolCallId: toolCall.id
+        };
+        events.push(toolEndEvent);
+      }
+    }
+    if (message.role === "tool" && message.toolCallId) {
+      const toolResultEvent = {
+        type: EventType3.TOOL_CALL_RESULT,
+        messageId: message.id,
+        toolCallId: message.toolCallId,
+        content: message.content,
+        role: "tool"
+      };
+      events.push(toolResultEvent);
+    }
+    return events;
+  }
+  initializeSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_runs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        thread_id TEXT NOT NULL,
+        run_id TEXT NOT NULL UNIQUE,
+        parent_run_id TEXT,
+        events TEXT NOT NULL,
+        input TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        version INTEGER NOT NULL
+      )
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS run_state (
+        thread_id TEXT PRIMARY KEY,
+        is_running INTEGER DEFAULT 0,
+        current_run_id TEXT,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_thread_id ON agent_runs(thread_id);
+      CREATE INDEX IF NOT EXISTS idx_parent_run_id ON agent_runs(parent_run_id);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_version (
+        version INTEGER PRIMARY KEY,
+        applied_at INTEGER NOT NULL
+      )
+    `);
+    const currentVersion = this.db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
+    if (!currentVersion || currentVersion.version < SCHEMA_VERSION) {
+      this.db.prepare("INSERT OR REPLACE INTO schema_version (version, applied_at) VALUES (?, ?)").run(SCHEMA_VERSION, Date.now());
+    }
+  }
+  storeRun(threadId, runId, events, input, parentRunId) {
+    const compactedEvents = compactEvents(events);
+    const stmt = this.db.prepare(`
+      INSERT INTO agent_runs (thread_id, run_id, parent_run_id, events, input, created_at, version)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      threadId,
+      runId,
+      parentRunId ?? null,
+      JSON.stringify(compactedEvents),
+      // Store only this run's compacted events
+      JSON.stringify(input),
+      Date.now(),
+      SCHEMA_VERSION
+    );
+  }
+  getHistoricRuns(threadId) {
+    const stmt = this.db.prepare(`
+      WITH RECURSIVE run_chain AS (
+        -- Base case: find the root runs (those without parent)
+        SELECT * FROM agent_runs 
+        WHERE thread_id = ? AND parent_run_id IS NULL
+        
+        UNION ALL
+        
+        -- Recursive case: find children of current level
+        SELECT ar.* FROM agent_runs ar
+        INNER JOIN run_chain rc ON ar.parent_run_id = rc.run_id
+        WHERE ar.thread_id = ?
+      )
+      SELECT * FROM run_chain
+      ORDER BY created_at ASC
+    `);
+    const rows = stmt.all(threadId, threadId);
+    return rows.map((row) => ({
+      id: row.id,
+      thread_id: row.thread_id,
+      run_id: row.run_id,
+      parent_run_id: row.parent_run_id,
+      events: JSON.parse(row.events),
+      input: JSON.parse(row.input),
+      created_at: row.created_at,
+      version: row.version
+    }));
+  }
+  getLatestRunId(threadId) {
+    const stmt = this.db.prepare(`
+      SELECT run_id FROM agent_runs 
+      WHERE thread_id = ? 
+      ORDER BY created_at DESC 
+      LIMIT 1
+    `);
+    const result = stmt.get(threadId);
+    return result?.run_id ?? null;
+  }
+  setRunState(threadId, isRunning, runId) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO run_state (thread_id, is_running, current_run_id, updated_at)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(threadId, isRunning ? 1 : 0, runId ?? null, Date.now());
+  }
+  getRunState(threadId) {
+    const stmt = this.db.prepare(`
+      SELECT is_running, current_run_id FROM run_state WHERE thread_id = ?
+    `);
+    const result = stmt.get(threadId);
+    return {
+      isRunning: result?.is_running === 1,
+      currentRunId: result?.current_run_id ?? null
+    };
+  }
+  run(request) {
+    const runState = this.getRunState(request.threadId);
+    if (runState.isRunning) {
+      throw new Error("Thread already running");
+    }
+    this.setRunState(request.threadId, true, request.input.runId);
+    const seenMessageIds = /* @__PURE__ */ new Set();
+    const currentRunEvents = [];
+    const historicRuns = this.getHistoricRuns(request.threadId);
+    const historicMessageIds = /* @__PURE__ */ new Set();
+    for (const run of historicRuns) {
+      for (const event of run.events) {
+        if ("messageId" in event && typeof event.messageId === "string") {
+          historicMessageIds.add(event.messageId);
+        }
+      }
+    }
+    const nextSubject = new ReplaySubject2(Infinity);
+    const prevSubject = ACTIVE_CONNECTIONS.get(request.threadId);
+    ACTIVE_CONNECTIONS.set(request.threadId, nextSubject);
+    const runSubject = new ReplaySubject2(Infinity);
+    const runAgent = async () => {
+      const parentRunId = this.getLatestRunId(request.threadId);
+      try {
+        await request.agent.runAgent(request.input, {
+          onEvent: ({ event }) => {
+            runSubject.next(event);
+            nextSubject.next(event);
+            currentRunEvents.push(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 events = this.convertMessageToEvents(message);
+                  const isNewMessage = !historicMessageIds.has(message.id);
+                  for (const event of events) {
+                    nextSubject.next(event);
+                    if (isNewMessage) {
+                      currentRunEvents.push(event);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        });
+        this.storeRun(
+          request.threadId,
+          request.input.runId,
+          currentRunEvents,
+          request.input,
+          parentRunId
+        );
+        this.setRunState(request.threadId, false);
+        runSubject.complete();
+        nextSubject.complete();
+      } catch {
+        if (currentRunEvents.length > 0) {
+          this.storeRun(
+            request.threadId,
+            request.input.runId,
+            currentRunEvents,
+            request.input,
+            parentRunId
+          );
+        }
+        this.setRunState(request.threadId, 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 connectionSubject = new ReplaySubject2(Infinity);
+    const historicRuns = this.getHistoricRuns(request.threadId);
+    const allHistoricEvents = [];
+    for (const run of 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 activeSubject = ACTIVE_CONNECTIONS.get(request.threadId);
+    const runState = this.getRunState(request.threadId);
+    if (activeSubject && runState.isRunning) {
+      activeSubject.subscribe({
+        next: (event) => {
+          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 {
+      connectionSubject.complete();
+    }
+    return connectionSubject.asObservable();
+  }
+  isRunning(request) {
+    const runState = this.getRunState(request.threadId);
+    return Promise.resolve(runState.isRunning);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  stop(_request) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Close the database connection (for cleanup)
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+    }
+  }
+};
+
+// src/runner/enterprise.ts
+import { ReplaySubject as ReplaySubject3 } from "rxjs";
+import {
+  EventType as EventType4
+} from "@ag-ui/client";
+var SCHEMA_VERSION2 = 1;
+var redisKeys = {
+  stream: (threadId, runId) => `stream:${threadId}:${runId}`,
+  active: (threadId) => `active:${threadId}`,
+  lock: (threadId) => `lock:${threadId}`
+};
+var EnterpriseAgentRunner = class extends AgentRunner {
+  db;
+  redis;
+  redisSub;
+  serverId;
+  streamRetentionMs;
+  streamActiveTTLMs;
+  lockTTLMs;
+  constructor(options) {
+    super();
+    this.db = options.kysely;
+    this.redis = options.redis;
+    this.redisSub = options.redisSub || options.redis.duplicate();
+    this.serverId = options.serverId || this.generateServerId();
+    this.streamRetentionMs = options.streamRetentionMs ?? 36e5;
+    this.streamActiveTTLMs = options.streamActiveTTLMs ?? 3e5;
+    this.lockTTLMs = options.lockTTLMs ?? 3e5;
+    this.initializeSchema();
+  }
+  run(request) {
+    const runSubject = new ReplaySubject3(Infinity);
+    const executeRun = async () => {
+      const { threadId, input, agent } = request;
+      const runId = input.runId;
+      const streamKey = redisKeys.stream(threadId, runId);
+      const activeRunId = await this.redis.get(redisKeys.active(threadId));
+      if (activeRunId) {
+        throw new Error("Thread already running");
+      }
+      const lockAcquired = await this.redis.set(
+        redisKeys.lock(threadId),
+        this.serverId,
+        "PX",
+        this.lockTTLMs,
+        "NX"
+      );
+      if (!lockAcquired) {
+        throw new Error("Thread already running");
+      }
+      await this.redis.setex(
+        redisKeys.active(threadId),
+        Math.floor(this.lockTTLMs / 1e3),
+        runId
+      );
+      await this.setRunState(threadId, true, runId);
+      const currentRunEvents = [];
+      const seenMessageIds = /* @__PURE__ */ new Set();
+      const historicRuns = await this.getHistoricRuns(threadId);
+      const historicMessageIds = /* @__PURE__ */ new Set();
+      for (const run of historicRuns) {
+        const events = JSON.parse(run.events);
+        for (const event of events) {
+          if ("messageId" in event && typeof event.messageId === "string") {
+            historicMessageIds.add(event.messageId);
+          }
+        }
+      }
+      const parentRunId = historicRuns[historicRuns.length - 1]?.run_id ?? null;
+      try {
+        await agent.runAgent(input, {
+          onEvent: async ({ event }) => {
+            runSubject.next(event);
+            currentRunEvents.push(event);
+            await this.redis.xadd(
+              streamKey,
+              "MAXLEN",
+              "~",
+              "10000",
+              "*",
+              "type",
+              event.type,
+              "data",
+              JSON.stringify(event)
+            );
+            await this.redis.pexpire(streamKey, this.streamActiveTTLMs);
+            if (event.type === EventType4.RUN_FINISHED || event.type === EventType4.RUN_ERROR) {
+              await this.redis.pexpire(streamKey, this.streamRetentionMs);
+            }
+          },
+          onNewMessage: ({ message }) => {
+            if (!seenMessageIds.has(message.id)) {
+              seenMessageIds.add(message.id);
+            }
+          },
+          onRunStartedEvent: async () => {
+            if (input.messages) {
+              for (const message of input.messages) {
+                if (!seenMessageIds.has(message.id)) {
+                  seenMessageIds.add(message.id);
+                  const events = this.convertMessageToEvents(message);
+                  const isNewMessage = !historicMessageIds.has(message.id);
+                  for (const event of events) {
+                    await this.redis.xadd(
+                      streamKey,
+                      "MAXLEN",
+                      "~",
+                      "10000",
+                      "*",
+                      "type",
+                      event.type,
+                      "data",
+                      JSON.stringify(event)
+                    );
+                    if (isNewMessage) {
+                      currentRunEvents.push(event);
+                    }
+                  }
+                }
+              }
+            }
+            await this.redis.pexpire(streamKey, this.streamActiveTTLMs);
+          }
+        });
+        const compactedEvents = compactEvents(currentRunEvents);
+        await this.storeRun(threadId, runId, compactedEvents, input, parentRunId);
+      } finally {
+        await this.setRunState(threadId, false);
+        await this.redis.del(redisKeys.active(threadId));
+        await this.redis.del(redisKeys.lock(threadId));
+        const exists = await this.redis.exists(streamKey);
+        if (exists) {
+          await this.redis.pexpire(streamKey, this.streamRetentionMs);
+        }
+        runSubject.complete();
+      }
+    };
+    executeRun().catch((error) => {
+      runSubject.error(error);
+    });
+    return runSubject.asObservable();
+  }
+  connect(request) {
+    const connectionSubject = new ReplaySubject3(Infinity);
+    const streamConnection = async () => {
+      const { threadId } = request;
+      const historicRuns = await this.getHistoricRuns(threadId);
+      const allHistoricEvents = [];
+      for (const run of historicRuns) {
+        const events = JSON.parse(run.events);
+        allHistoricEvents.push(...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 activeRunId = await this.redis.get(redisKeys.active(threadId));
+      if (activeRunId) {
+        const streamKey = redisKeys.stream(threadId, activeRunId);
+        let lastId = "0-0";
+        let consecutiveEmptyReads = 0;
+        while (true) {
+          try {
+            const result = await this.redis.call(
+              "XREAD",
+              "BLOCK",
+              "5000",
+              "COUNT",
+              "100",
+              "STREAMS",
+              streamKey,
+              lastId
+            );
+            if (!result || result.length === 0) {
+              consecutiveEmptyReads++;
+              const exists = await this.redis.exists(streamKey);
+              if (!exists) {
+                break;
+              }
+              const stillActive = await this.redis.get(redisKeys.active(threadId));
+              if (stillActive !== activeRunId) {
+                break;
+              }
+              if (consecutiveEmptyReads > 3) {
+                break;
+              }
+              continue;
+            }
+            consecutiveEmptyReads = 0;
+            const [, messages] = result[0] || [null, []];
+            for (const [id, fields] of messages || []) {
+              lastId = id;
+              let eventData = null;
+              let eventType = null;
+              for (let i = 0; i < fields.length; i += 2) {
+                if (fields[i] === "data") {
+                  eventData = fields[i + 1] ?? null;
+                } else if (fields[i] === "type") {
+                  eventType = fields[i + 1] ?? null;
+                }
+              }
+              if (eventData) {
+                const event = JSON.parse(eventData);
+                if ("messageId" in event && typeof event.messageId === "string" && emittedMessageIds.has(event.messageId)) {
+                  continue;
+                }
+                connectionSubject.next(event);
+                if (eventType === EventType4.RUN_FINISHED || eventType === EventType4.RUN_ERROR) {
+                  connectionSubject.complete();
+                  return;
+                }
+              }
+            }
+          } catch {
+            break;
+          }
+        }
+      }
+      connectionSubject.complete();
+    };
+    streamConnection().catch(() => connectionSubject.complete());
+    return connectionSubject.asObservable();
+  }
+  async isRunning(request) {
+    const { threadId } = request;
+    const activeRunId = await this.redis.get(redisKeys.active(threadId));
+    if (activeRunId) return true;
+    const lockExists = await this.redis.exists(redisKeys.lock(threadId));
+    if (lockExists) return true;
+    const state = await this.db.selectFrom("run_state").where("thread_id", "=", threadId).selectAll().executeTakeFirst();
+    return state?.is_running === 1;
+  }
+  async stop(request) {
+    const { threadId } = request;
+    const activeRunId = await this.redis.get(redisKeys.active(threadId));
+    if (!activeRunId) {
+      return false;
+    }
+    const streamKey = redisKeys.stream(threadId, activeRunId);
+    await this.redis.xadd(
+      streamKey,
+      "*",
+      "type",
+      EventType4.RUN_ERROR,
+      "data",
+      JSON.stringify({
+        type: EventType4.RUN_ERROR,
+        error: "Run stopped by user"
+      })
+    );
+    await this.redis.pexpire(streamKey, this.streamRetentionMs);
+    await this.setRunState(threadId, false);
+    await this.redis.del(redisKeys.active(threadId));
+    await this.redis.del(redisKeys.lock(threadId));
+    return true;
+  }
+  // Helper methods
+  convertMessageToEvents(message) {
+    const events = [];
+    if ((message.role === "assistant" || message.role === "user" || message.role === "developer" || message.role === "system") && message.content) {
+      const textStartEvent = {
+        type: EventType4.TEXT_MESSAGE_START,
+        messageId: message.id,
+        role: message.role
+      };
+      events.push(textStartEvent);
+      const textContentEvent = {
+        type: EventType4.TEXT_MESSAGE_CONTENT,
+        messageId: message.id,
+        delta: message.content
+      };
+      events.push(textContentEvent);
+      const textEndEvent = {
+        type: EventType4.TEXT_MESSAGE_END,
+        messageId: message.id
+      };
+      events.push(textEndEvent);
+    }
+    if (message.role === "assistant" && message.toolCalls) {
+      for (const toolCall of message.toolCalls) {
+        const toolStartEvent = {
+          type: EventType4.TOOL_CALL_START,
+          toolCallId: toolCall.id,
+          toolCallName: toolCall.function.name,
+          parentMessageId: message.id
+        };
+        events.push(toolStartEvent);
+        const toolArgsEvent = {
+          type: EventType4.TOOL_CALL_ARGS,
+          toolCallId: toolCall.id,
+          delta: toolCall.function.arguments
+        };
+        events.push(toolArgsEvent);
+        const toolEndEvent = {
+          type: EventType4.TOOL_CALL_END,
+          toolCallId: toolCall.id
+        };
+        events.push(toolEndEvent);
+      }
+    }
+    if (message.role === "tool" && message.toolCallId) {
+      const toolResultEvent = {
+        type: EventType4.TOOL_CALL_RESULT,
+        messageId: message.id,
+        toolCallId: message.toolCallId,
+        content: message.content,
+        role: "tool"
+      };
+      events.push(toolResultEvent);
+    }
+    return events;
+  }
+  async initializeSchema() {
+    try {
+      await this.db.schema.createTable("agent_runs").ifNotExists().addColumn("id", "integer", (col) => col.primaryKey().autoIncrement()).addColumn("thread_id", "text", (col) => col.notNull()).addColumn("run_id", "text", (col) => col.notNull().unique()).addColumn("parent_run_id", "text").addColumn("events", "text", (col) => col.notNull()).addColumn("input", "text", (col) => col.notNull()).addColumn("created_at", "integer", (col) => col.notNull()).addColumn("version", "integer", (col) => col.notNull()).execute().catch(() => {
+      });
+      await this.db.schema.createTable("run_state").ifNotExists().addColumn("thread_id", "text", (col) => col.primaryKey()).addColumn("is_running", "integer", (col) => col.defaultTo(0)).addColumn("current_run_id", "text").addColumn("server_id", "text").addColumn("updated_at", "integer", (col) => col.notNull()).execute().catch(() => {
+      });
+      await this.db.schema.createTable("schema_version").ifNotExists().addColumn("version", "integer", (col) => col.primaryKey()).addColumn("applied_at", "integer", (col) => col.notNull()).execute().catch(() => {
+      });
+      await this.db.schema.createIndex("idx_thread_id").ifNotExists().on("agent_runs").column("thread_id").execute().catch(() => {
+      });
+      await this.db.schema.createIndex("idx_parent_run_id").ifNotExists().on("agent_runs").column("parent_run_id").execute().catch(() => {
+      });
+      const currentVersion = await this.db.selectFrom("schema_version").orderBy("version", "desc").limit(1).selectAll().executeTakeFirst();
+      if (!currentVersion || currentVersion.version < SCHEMA_VERSION2) {
+        await this.db.insertInto("schema_version").values({
+          version: SCHEMA_VERSION2,
+          applied_at: Date.now()
+        }).onConflict(
+          (oc) => oc.column("version").doUpdateSet({ applied_at: Date.now() })
+        ).execute();
+      }
+    } catch {
+    }
+  }
+  async storeRun(threadId, runId, events, input, parentRunId) {
+    await this.db.insertInto("agent_runs").values({
+      thread_id: threadId,
+      run_id: runId,
+      parent_run_id: parentRunId,
+      events: JSON.stringify(events),
+      input: JSON.stringify(input),
+      created_at: Date.now(),
+      version: SCHEMA_VERSION2
+    }).execute();
+  }
+  async getHistoricRuns(threadId) {
+    const rows = await this.db.selectFrom("agent_runs").where("thread_id", "=", threadId).orderBy("created_at", "asc").selectAll().execute();
+    return rows.map((row) => ({
+      id: Number(row.id),
+      thread_id: row.thread_id,
+      run_id: row.run_id,
+      parent_run_id: row.parent_run_id,
+      events: row.events,
+      input: row.input,
+      created_at: row.created_at,
+      version: row.version
+    }));
+  }
+  async setRunState(threadId, isRunning, runId) {
+    await this.db.insertInto("run_state").values({
+      thread_id: threadId,
+      is_running: isRunning ? 1 : 0,
+      current_run_id: runId ?? null,
+      server_id: this.serverId,
+      updated_at: Date.now()
+    }).onConflict(
+      (oc) => oc.column("thread_id").doUpdateSet({
+        is_running: isRunning ? 1 : 0,
+        current_run_id: runId ?? null,
+        server_id: this.serverId,
+        updated_at: Date.now()
+      })
+    ).execute();
+  }
+  async close() {
+    await this.db.destroy();
+    this.redis.disconnect();
+    this.redisSub.disconnect();
+  }
+  generateServerId() {
+    return `server-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+};
+export {
+  CopilotRuntime,
+  EnterpriseAgentRunner,
+  InMemoryAgentRunner,
+  SqliteAgentRunner,
+  VERSION,
+  createCopilotEndpoint
+};
+//# sourceMappingURL=index.mjs.map