@copilotkitnext/runtime 0.0.15 → 0.0.17-alpha.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@copilotkitnext/runtime",
-  version: "0.0.15",
+  version: "0.0.17-alpha.0",
   description: "Server-side runtime package for CopilotKit2",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -29,35 +29,25 @@ var package_default = {
   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.40-alpha.3",
-    "@ag-ui/core": "0.0.40-alpha.3",
-    "@ag-ui/encoder": "0.0.40-alpha.3",
+    "@ag-ui/client": "0.0.40-alpha.6",
+    "@ag-ui/core": "0.0.40-alpha.6",
+    "@ag-ui/encoder": "0.0.40-alpha.6",
     "@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
-    }
-  },
+  peerDependenciesMeta: {},
   engines: {
     node: ">=18"
   }
@@ -70,161 +60,9 @@ 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
+  EventType,
+  compactEvents
 } 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;
@@ -242,61 +80,6 @@ var InMemoryEventStore = class {
 };
 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) {
@@ -317,6 +100,13 @@ var InMemoryAgentRunner = class extends AgentRunner {
         if ("messageId" in event && typeof event.messageId === "string") {
           historicMessageIds.add(event.messageId);
         }
+        if (event.type === EventType.RUN_STARTED) {
+          const runStarted = event;
+          const messages = runStarted.input?.messages ?? [];
+          for (const message of messages) {
+            historicMessageIds.add(message.id);
+          }
+        }
       }
     }
     const nextSubject = new ReplaySubject(Infinity);
@@ -330,9 +120,26 @@ var InMemoryAgentRunner = class extends AgentRunner {
       try {
         await request.agent.runAgent(request.input, {
           onEvent: ({ event }) => {
-            runSubject.next(event);
-            nextSubject.next(event);
-            currentRunEvents.push(event);
+            let processedEvent = event;
+            if (event.type === EventType.RUN_STARTED) {
+              const runStartedEvent = event;
+              if (!runStartedEvent.input) {
+                const sanitizedMessages = request.input.messages ? request.input.messages.filter(
+                  (message) => !historicMessageIds.has(message.id)
+                ) : void 0;
+                const updatedInput = {
+                  ...request.input,
+                  ...sanitizedMessages !== void 0 ? { messages: sanitizedMessages } : {}
+                };
+                processedEvent = {
+                  ...runStartedEvent,
+                  input: updatedInput
+                };
+              }
+            }
+            runSubject.next(processedEvent);
+            nextSubject.next(processedEvent);
+            currentRunEvents.push(processedEvent);
           },
           onNewMessage: ({ message }) => {
             if (!seenMessageIds.has(message.id)) {
@@ -344,14 +151,6 @@ var InMemoryAgentRunner = class extends AgentRunner {
               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);
-                    }
-                  }
                 }
               }
             }
@@ -1140,726 +939,10 @@ function createCopilotEndpoint({
     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 {
+  AgentRunner,
   CopilotRuntime,
-  EnterpriseAgentRunner,
   InMemoryAgentRunner,
-  SqliteAgentRunner,
   VERSION,
   createCopilotEndpoint
 };