@copilotkitnext/sqlite-runner 1.51.5-next.0 → 1.51.5-next.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @copilotkitnext/sqlite-runner
 
+## 1.51.5-next.2
+
+### Patch Changes
+
+- @copilotkitnext/runtime@1.51.5-next.2
+
+## 1.51.5-next.1
+
+### Patch Changes
+
+- @copilotkitnext/runtime@1.51.5-next.1
+
 ## 1.51.5-next.0
 
 ### Patch Changes

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,29 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/index.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_sqlite_runner = require('./sqlite-runner.cjs');
+
+exports.SqliteAgentRunner = require_sqlite_runner.SqliteAgentRunner;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import { SqliteAgentRunner, SqliteAgentRunnerOptions } from "./sqlite-runner.cjs";
+export { SqliteAgentRunner, SqliteAgentRunnerOptions };

package/dist/index.d.mts

@@ -1,27 +1,2 @@
-import { AgentRunner, AgentRunnerRunRequest, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerStopRequest } from '@copilotkitnext/runtime';
-import { Observable } from 'rxjs';
-import { BaseEvent } from '@ag-ui/client';
-
-interface SqliteAgentRunnerOptions {
-    dbPath?: string;
-}
-declare class SqliteAgentRunner extends AgentRunner {
-    private db;
-    constructor(options?: SqliteAgentRunnerOptions);
-    private initializeSchema;
-    private storeRun;
-    private getHistoricRuns;
-    private getLatestRunId;
-    private setRunState;
-    private getRunState;
-    run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
-    connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
-    isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
-    stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
-    /**
-     * Close the database connection (for cleanup)
-     */
-    close(): void;
-}
-
-export { SqliteAgentRunner, type SqliteAgentRunnerOptions };
+import { SqliteAgentRunner, SqliteAgentRunnerOptions } from "./sqlite-runner.mjs";
+export { SqliteAgentRunner, SqliteAgentRunnerOptions };

package/dist/index.mjs

@@ -1,356 +1,3 @@
-// src/sqlite-runner.ts
-import {
-  AgentRunner,
-  finalizeRunEvents
-} from "@copilotkitnext/runtime";
-import { ReplaySubject } from "rxjs";
-import {
-  EventType,
-  compactEvents
-} 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();
-  }
-  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);
-        }
-        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);
-    const prevConnection = ACTIVE_CONNECTIONS.get(request.threadId);
-    const prevSubject = prevConnection?.subject;
-    const runSubject = new ReplaySubject(Infinity);
-    ACTIVE_CONNECTIONS.set(request.threadId, {
-      subject: nextSubject,
-      agent: request.agent,
-      runSubject,
-      currentEvents: currentRunEvents,
-      stopRequested: false
-    });
-    const runAgent = async () => {
-      const parentRunId = this.getLatestRunId(request.threadId);
-      try {
-        await request.agent.runAgent(request.input, {
-          onEvent: ({ event }) => {
-            let processedEvent = event;
-            if (event.type === EventType.RUN_STARTED) {
-              const runStartedEvent = event;
-              if (!runStartedEvent.input) {
-                const sanitizedMessages = request.input.messages ? request.input.messages.filter(
-                  (message) => !historicMessageIds.has(message.id)
-                ) : void 0;
-                const updatedInput = {
-                  ...request.input,
-                  ...sanitizedMessages !== void 0 ? { messages: sanitizedMessages } : {}
-                };
-                processedEvent = {
-                  ...runStartedEvent,
-                  input: updatedInput
-                };
-              }
-            }
-            runSubject.next(processedEvent);
-            nextSubject.next(processedEvent);
-            currentRunEvents.push(processedEvent);
-          },
-          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 connection = ACTIVE_CONNECTIONS.get(request.threadId);
-        const appendedEvents = finalizeRunEvents(currentRunEvents, {
-          stopRequested: connection?.stopRequested ?? false
-        });
-        for (const event of appendedEvents) {
-          runSubject.next(event);
-          nextSubject.next(event);
-        }
-        this.storeRun(
-          request.threadId,
-          request.input.runId,
-          currentRunEvents,
-          request.input,
-          parentRunId
-        );
-        this.setRunState(request.threadId, false);
-        if (connection) {
-          connection.agent = void 0;
-          connection.runSubject = void 0;
-          connection.currentEvents = void 0;
-          connection.stopRequested = false;
-        }
-        runSubject.complete();
-        nextSubject.complete();
-        ACTIVE_CONNECTIONS.delete(request.threadId);
-      } catch {
-        const connection = ACTIVE_CONNECTIONS.get(request.threadId);
-        const appendedEvents = finalizeRunEvents(currentRunEvents, {
-          stopRequested: connection?.stopRequested ?? false
-        });
-        for (const event of appendedEvents) {
-          runSubject.next(event);
-          nextSubject.next(event);
-        }
-        if (currentRunEvents.length > 0) {
-          this.storeRun(
-            request.threadId,
-            request.input.runId,
-            currentRunEvents,
-            request.input,
-            parentRunId
-          );
-        }
-        this.setRunState(request.threadId, false);
-        if (connection) {
-          connection.agent = void 0;
-          connection.runSubject = void 0;
-          connection.currentEvents = void 0;
-          connection.stopRequested = false;
-        }
-        runSubject.complete();
-        nextSubject.complete();
-        ACTIVE_CONNECTIONS.delete(request.threadId);
-      }
-    };
-    if (prevSubject) {
-      prevSubject.subscribe({
-        next: (e) => nextSubject.next(e),
-        error: (err) => nextSubject.error(err),
-        complete: () => {
-        }
-      });
-    }
-    runAgent();
-    return runSubject.asObservable();
-  }
-  connect(request) {
-    const connectionSubject = new ReplaySubject(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 activeConnection = ACTIVE_CONNECTIONS.get(request.threadId);
-    const runState = this.getRunState(request.threadId);
-    if (activeConnection && (runState.isRunning || activeConnection.stopRequested)) {
-      activeConnection.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 runState = this.getRunState(request.threadId);
-    return Promise.resolve(runState.isRunning);
-  }
-  stop(request) {
-    const runState = this.getRunState(request.threadId);
-    if (!runState.isRunning) {
-      return Promise.resolve(false);
-    }
-    const connection = ACTIVE_CONNECTIONS.get(request.threadId);
-    const agent = connection?.agent;
-    if (!connection || !agent) {
-      return Promise.resolve(false);
-    }
-    if (connection.stopRequested) {
-      return Promise.resolve(false);
-    }
-    connection.stopRequested = true;
-    this.setRunState(request.threadId, false);
-    try {
-      agent.abortRun();
-      return Promise.resolve(true);
-    } catch (error) {
-      console.error("Failed to abort sqlite agent run", error);
-      connection.stopRequested = false;
-      this.setRunState(request.threadId, true);
-      return Promise.resolve(false);
-    }
-  }
-  /**
-   * Close the database connection (for cleanup)
-   */
-  close() {
-    if (this.db) {
-      this.db.close();
-    }
-  }
-};
-export {
-  SqliteAgentRunner
-};
-//# sourceMappingURL=index.mjs.map
+import { SqliteAgentRunner } from "./sqlite-runner.mjs";
+
+export { SqliteAgentRunner };