@ellyco/agentic 0.1.0

package/dist/graphs/state-machine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-machine.js","sourceRoot":"","sources":["../../src/graphs/state-machine.ts"],"names":[],"mappings":";;;AAAA,mCAA4C;AAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAa,YAAoF,SAAQ,aAAW;IAChH;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAY,EAAE,IAAiC;QACnD,IAAI,IAAI,KAAK,aAAK,IAAI,IAAI,KAAK,WAAG,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,cAAc,CAAC,CAAC;QAChD,CAAC;QACD,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,iBAAiB,CAAC,CAAC;QACnD,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QACxB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,IAAY,EAAE,EAAU;QAC5B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,kBAAkB,CACd,IAAY,EACZ,EAAK,EACL,IAA6B;QAE7B,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CACX,8CAA8C,IAAI,EAAE,CACvD,CAAC;QACN,CAAC;QACD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QACjC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QACnC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACO,gBAAgB,CAAC,KAAQ;QAC/B,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;;;;OAMG;IACO,gBAAgB,CAAC,SAAqB;QAC5C,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ;AAzGD,oCAyGC"}

package/dist/graphs/store/base-store.d.ts

@@ -0,0 +1,90 @@
+import { StoredRun } from "./stored-run";
+/**
+ * Abstract base class for storing and retrieving graph run state.
+ * Implementations persist graph state between interruptions, enabling resumable workflows.
+ *
+ * @abstract
+ *
+ * @example
+ * ```typescript
+ * // Create a custom store implementation
+ * class MyCustomStore extends BaseStore {
+ *   async save(runId: string, cursor: string, state: object): Promise<void> {
+ *     // Custom persistence logic
+ *   }
+ *   async load(runId: string): Promise<{ cursor: string, state: object }> {
+ *     // Custom retrieval logic
+ *   }
+ *   // ... implement other methods
+ * }
+ *
+ * // Use with graph
+ * const store = new MyCustomStore();
+ * const result = await graph.invoke(state, { store });
+ * ```
+ */
+export declare abstract class BaseStore {
+    /**
+     * Saves the state and cursor position of a run.
+     *
+     * @abstract
+     * @param {string} runId - Unique run identifier
+     * @param {string} cursor - Position in the graph (encoded path through nodes)
+     * @param {object} state - Complete state at this point
+     * @returns {Promise<void>}
+     */
+    abstract save(runId: string, cursor: string, state: object): Promise<void>;
+    /**
+     * Checks if a run exists in the store.
+     *
+     * @abstract
+     * @param {string} runId - Unique run identifier
+     * @returns {Promise<boolean>} True if the run exists
+     */
+    abstract exists(runId: string): Promise<boolean>;
+    /**
+     * Loads the saved state and cursor for a run.
+     *
+     * @abstract
+     * @param {string} runId - Unique run identifier
+     * @returns {Promise<{cursor: string, state: object}>} The saved cursor and state
+     * @throws {Error} If the run is not found
+     */
+    abstract load(runId: string): Promise<{
+        cursor: string;
+        state: object;
+    }>;
+    /**
+     * Deletes a run from the store.
+     *
+     * @abstract
+     * @param {string} runId - Unique run identifier
+     * @returns {Promise<void>}
+     */
+    abstract delete(runId: string): Promise<void>;
+    /**
+     * Closes the store and releases resources.
+     * Called when the store is no longer needed.
+     *
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    abstract dispose(): Promise<void>;
+    /**
+     * Gets a StoredRun wrapper for a specific run ID.
+     *
+     * @param {string} runId - Unique run identifier
+     * @returns {StoredRun} Wrapper for interacting with this specific run
+     *
+     * @example
+     * ```typescript
+     * const storedRun = store.getStoredRun("run-123");
+     * if (await storedRun.exists()) {
+     *   const loaded = await storedRun.load();
+     *   console.log(loaded.state);
+     * }
+     * ```
+     */
+    getStoredRun(runId: string): StoredRun;
+}
+//# sourceMappingURL=base-store.d.ts.map

package/dist/graphs/store/base-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-store.d.ts","sourceRoot":"","sources":["../../../src/graphs/store/base-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,8BAAsB,SAAS;IAC3B;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1E;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAEhD;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAExE;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAE7C;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAEjC;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;CAGzC"}

package/dist/graphs/store/base-store.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStore = void 0;
+const stored_run_1 = require("./stored-run");
+/**
+ * Abstract base class for storing and retrieving graph run state.
+ * Implementations persist graph state between interruptions, enabling resumable workflows.
+ *
+ * @abstract
+ *
+ * @example
+ * ```typescript
+ * // Create a custom store implementation
+ * class MyCustomStore extends BaseStore {
+ *   async save(runId: string, cursor: string, state: object): Promise<void> {
+ *     // Custom persistence logic
+ *   }
+ *   async load(runId: string): Promise<{ cursor: string, state: object }> {
+ *     // Custom retrieval logic
+ *   }
+ *   // ... implement other methods
+ * }
+ *
+ * // Use with graph
+ * const store = new MyCustomStore();
+ * const result = await graph.invoke(state, { store });
+ * ```
+ */
+class BaseStore {
+    /**
+     * Gets a StoredRun wrapper for a specific run ID.
+     *
+     * @param {string} runId - Unique run identifier
+     * @returns {StoredRun} Wrapper for interacting with this specific run
+     *
+     * @example
+     * ```typescript
+     * const storedRun = store.getStoredRun("run-123");
+     * if (await storedRun.exists()) {
+     *   const loaded = await storedRun.load();
+     *   console.log(loaded.state);
+     * }
+     * ```
+     */
+    getStoredRun(runId) {
+        return new stored_run_1.StoredRun(runId, this);
+    }
+}
+exports.BaseStore = BaseStore;
+//# sourceMappingURL=base-store.js.map

package/dist/graphs/store/base-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-store.js","sourceRoot":"","sources":["../../../src/graphs/store/base-store.ts"],"names":[],"mappings":";;;AAAA,6CAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAsB,SAAS;IAiD3B;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,KAAa;QACtB,OAAO,IAAI,sBAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACtC,CAAC;CACJ;AAnED,8BAmEC"}

package/dist/graphs/store/sqlite-store.d.ts

@@ -0,0 +1,88 @@
+import { BaseStore } from "./base-store";
+import { Database } from "better-sqlite3";
+/**
+ * A store implementation using SQLite for persistent storage of graph run state.
+ * Provides reliable checkpoint-based resumption across sessions.
+ *
+ * @class SQLiteStore
+ * @extends {BaseStore}
+ *
+ * @example
+ * ```typescript
+ * import Database from "better-sqlite3";
+ *
+ * // Create or open a database
+ * const db = new Database("runs.db");
+ * const store = new SQLiteStore(db, "graph_runs");
+ *
+ * // Use with graph for persistent execution
+ * const result = await graph.invoke(initialState, { store });
+ *
+ * // Later, resume from checkpoint
+ * if (result.exitReason === "interrupt") {
+ *   const result2 = await graph.invoke(result.state, { store, resumeFrom: result.cursor });
+ * }
+ *
+ * // Clean up
+ * await store.dispose();
+ * ```
+ */
+export declare class SQLiteStore extends BaseStore {
+    private readonly db;
+    private readonly tableName;
+    /**
+     * Creates a new SQLite store.
+     * Automatically creates the table if it doesn't exist.
+     *
+     * @param {Database} db - The SQLite database connection
+     * @param {string} [tableName="runs"] - Name of the table for storing runs
+     */
+    constructor(db: Database, tableName?: string);
+    /**
+     * Saves the state and cursor for a run.
+     * Creates a new record or updates existing one.
+     *
+     * @async
+     * @param {string} runId - Unique run identifier
+     * @param {string} cursor - Encoded graph position
+     * @param {object} state - State to persist
+     * @returns {Promise<void>}
+     */
+    save(runId: string, cursor: string, state: object): Promise<void>;
+    /**
+     * Checks if a run exists in the store.
+     *
+     * @async
+     * @param {string} runId - Unique run identifier
+     * @returns {Promise<boolean>} True if the run exists
+     */
+    exists(runId: string): Promise<boolean>;
+    /**
+     * Loads the saved state and cursor for a run.
+     *
+     * @async
+     * @param {string} runId - Unique run identifier
+     * @returns {Promise<{cursor: string, state: object}>} The saved checkpoint
+     * @throws {Error} If the run is not found
+     */
+    load(runId: string): Promise<{
+        cursor: string;
+        state: object;
+    }>;
+    /**
+     * Deletes a run from the store.
+     *
+     * @async
+     * @param {string} runId - Unique run identifier
+     * @returns {Promise<void>}
+     */
+    delete(runId: string): Promise<void>;
+    /**
+     * Closes the database connection and releases resources.
+     *
+     * @async
+     * @returns {Promise<void>}
+     */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=sqlite-store.d.ts.map

package/dist/graphs/store/sqlite-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-store.d.ts","sourceRoot":"","sources":["../../../src/graphs/store/sqlite-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,WAAY,SAAQ,SAAS;IAS1B,OAAO,CAAC,QAAQ,CAAC,EAAE;IAAY,OAAO,CAAC,QAAQ,CAAC,SAAS;IAPrE;;;;;;OAMG;gBAC0B,EAAE,EAAE,QAAQ,EAAmB,SAAS,GAAE,MAAe;IAKtF;;;;;;;;;OASG;IACG,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOvE;;;;;;OAMG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK7C;;;;;;;OAOG;IACG,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAQrE;;;;;;OAMG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1C;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAGjC"}

package/dist/graphs/store/sqlite-store.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteStore = void 0;
+const base_store_1 = require("./base-store");
+/**
+ * A store implementation using SQLite for persistent storage of graph run state.
+ * Provides reliable checkpoint-based resumption across sessions.
+ *
+ * @class SQLiteStore
+ * @extends {BaseStore}
+ *
+ * @example
+ * ```typescript
+ * import Database from "better-sqlite3";
+ *
+ * // Create or open a database
+ * const db = new Database("runs.db");
+ * const store = new SQLiteStore(db, "graph_runs");
+ *
+ * // Use with graph for persistent execution
+ * const result = await graph.invoke(initialState, { store });
+ *
+ * // Later, resume from checkpoint
+ * if (result.exitReason === "interrupt") {
+ *   const result2 = await graph.invoke(result.state, { store, resumeFrom: result.cursor });
+ * }
+ *
+ * // Clean up
+ * await store.dispose();
+ * ```
+ */
+class SQLiteStore extends base_store_1.BaseStore {
+    db;
+    tableName;
+    /**
+     * Creates a new SQLite store.
+     * Automatically creates the table if it doesn't exist.
+     *
+     * @param {Database} db - The SQLite database connection
+     * @param {string} [tableName="runs"] - Name of the table for storing runs
+     */
+    constructor(db, tableName = "runs") {
+        super();
+        this.db = db;
+        this.tableName = tableName;
+        this.db.prepare(`CREATE TABLE IF NOT EXISTS ${this.tableName} (run_id TEXT PRIMARY KEY, cursor TEXT, state TEXT)`).run();
+    }
+    /**
+     * Saves the state and cursor for a run.
+     * Creates a new record or updates existing one.
+     *
+     * @async
+     * @param {string} runId - Unique run identifier
+     * @param {string} cursor - Encoded graph position
+     * @param {object} state - State to persist
+     * @returns {Promise<void>}
+     */
+    async save(runId, cursor, state) {
+        this.db.prepare(`INSERT INTO ${this.tableName} (run_id, cursor, state) VALUES (?, ?, ?)
+             ON CONFLICT(run_id) DO UPDATE SET cursor = excluded.cursor, state = excluded.state`).run(runId, cursor, JSON.stringify(state));
+    }
+    /**
+     * Checks if a run exists in the store.
+     *
+     * @async
+     * @param {string} runId - Unique run identifier
+     * @returns {Promise<boolean>} True if the run exists
+     */
+    async exists(runId) {
+        const result = this.db.prepare(`SELECT 1 FROM ${this.tableName} WHERE run_id = ?`).get(runId);
+        return result !== undefined;
+    }
+    /**
+     * Loads the saved state and cursor for a run.
+     *
+     * @async
+     * @param {string} runId - Unique run identifier
+     * @returns {Promise<{cursor: string, state: object}>} The saved checkpoint
+     * @throws {Error} If the run is not found
+     */
+    async load(runId) {
+        const result = this.db.prepare(`SELECT cursor, state FROM ${this.tableName} WHERE run_id = ?`).get(runId);
+        if (!result) {
+            throw new Error(`Run ${runId} not found`);
+        }
+        return { cursor: result.cursor, state: JSON.parse(result.state) };
+    }
+    /**
+     * Deletes a run from the store.
+     *
+     * @async
+     * @param {string} runId - Unique run identifier
+     * @returns {Promise<void>}
+     */
+    async delete(runId) {
+        this.db.prepare(`DELETE FROM ${this.tableName} WHERE run_id = ?`).run(runId);
+    }
+    /**
+     * Closes the database connection and releases resources.
+     *
+     * @async
+     * @returns {Promise<void>}
+     */
+    async dispose() {
+        this.db.close();
+    }
+}
+exports.SQLiteStore = SQLiteStore;
+//# sourceMappingURL=sqlite-store.js.map

package/dist/graphs/store/sqlite-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-store.js","sourceRoot":"","sources":["../../../src/graphs/store/sqlite-store.ts"],"names":[],"mappings":";;;AAAA,6CAAyC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,WAAY,SAAQ,sBAAS;IAST;IAA+B;IAP5D;;;;;;OAMG;IACH,YAA6B,EAAY,EAAmB,YAAoB,MAAM;QAClF,KAAK,EAAE,CAAC;QADiB,OAAE,GAAF,EAAE,CAAU;QAAmB,cAAS,GAAT,SAAS,CAAiB;QAElF,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,8BAA8B,IAAI,CAAC,SAAS,qDAAqD,CAAC,CAAC,GAAG,EAAE,CAAC;IAC7H,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,IAAI,CAAC,KAAa,EAAE,MAAc,EAAE,KAAa;QACnD,IAAI,CAAC,EAAE,CAAC,OAAO,CACX,eAAe,IAAI,CAAC,SAAS;gGACuD,CACvF,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,CAAC,KAAa;QACtB,MAAM,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,iBAAiB,IAAI,CAAC,SAAS,mBAAmB,CAAC,CAAC,GAAG,CAAC,KAAK,CAAsD,CAAC;QACnJ,OAAO,MAAM,KAAK,SAAS,CAAC;IAChC,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,CAAC,KAAa;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,6BAA6B,IAAI,CAAC,SAAS,mBAAmB,CAAC,CAAC,GAAG,CAAC,KAAK,CAAsD,CAAC;QAC/J,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,OAAO,KAAK,YAAY,CAAC,CAAC;QAC9C,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IACtE,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,CAAC,KAAa;QACtB,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,eAAe,IAAI,CAAC,SAAS,mBAAmB,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACjF,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAO;QACT,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;IACpB,CAAC;CACJ;AA/ED,kCA+EC"}

package/dist/graphs/store/stored-run.d.ts

@@ -0,0 +1,77 @@
+import { BaseStore } from "./base-store";
+/**
+ * Wrapper for interacting with a specific run's stored state and cursor.
+ * Provides a convenient interface for saving, loading, and managing individual runs.
+ *
+ * @class StoredRun
+ *
+ * @example
+ * ```typescript
+ * const storedRun = store.getStoredRun("run-123");
+ *
+ * // Check if run exists
+ * if (await storedRun.exists()) {
+ *   const { cursor, state } = await storedRun.load();
+ *   console.log("Previously interrupted at:", cursor);
+ * }
+ *
+ * // Save run state
+ * await storedRun.save("node-5", { data: "updated" });
+ *
+ * // Clean up when done
+ * await storedRun.delete();
+ * ```
+ */
+export declare class StoredRun {
+    readonly runId: string;
+    private readonly store;
+    /**
+     * Creates a wrapper for a specific run.
+     *
+     * @param {string} runId - Unique identifier for this run
+     * @param {BaseStore} store - The underlying store implementation
+     */
+    constructor(runId: string, store: BaseStore);
+    /**
+     * Saves the current state and cursor position of this run.
+     *
+     * @param {string} cursor - Encoded position in the graph
+     * @param {object} state - Complete state at this checkpoint
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * await storedRun.save("node-process", { count: 42, data: [...] });
+     * ```
+     */
+    save(cursor: string, state: object): Promise<void>;
+    /**
+     * Checks if this run has been saved to the store.
+     *
+     * @returns {Promise<boolean>} True if the run exists
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Loads the saved state and cursor for this run.
+     *
+     * @returns {Promise<{cursor: string, state: object}>} The saved checkpoint
+     * @throws {Error} If the run does not exist
+     *
+     * @example
+     * ```typescript
+     * const { cursor, state } = await storedRun.load();
+     * // Resume from cursor: await graph.invoke(state, { resumeFrom: cursor });
+     * ```
+     */
+    load(): Promise<{
+        cursor: string;
+        state: object;
+    }>;
+    /**
+     * Deletes this run from the store.
+     *
+     * @returns {Promise<void>}
+     */
+    delete(): Promise<void>;
+}
+//# sourceMappingURL=stored-run.d.ts.map

package/dist/graphs/store/stored-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-run.d.ts","sourceRoot":"","sources":["../../../src/graphs/store/stored-run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,SAAS;aAOU,KAAK,EAAE,MAAM;IAAE,OAAO,CAAC,QAAQ,CAAC,KAAK;IANjE;;;;;OAKG;gBACyB,KAAK,EAAE,MAAM,EAAmB,KAAK,EAAE,SAAS;IAG5E;;;;;;;;;;;OAWG;IACG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxD;;;;OAIG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IAIhC;;;;;;;;;;;OAWG;IACG,IAAI,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAIxD;;;;OAIG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}

package/dist/graphs/store/stored-run.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoredRun = void 0;
+/**
+ * Wrapper for interacting with a specific run's stored state and cursor.
+ * Provides a convenient interface for saving, loading, and managing individual runs.
+ *
+ * @class StoredRun
+ *
+ * @example
+ * ```typescript
+ * const storedRun = store.getStoredRun("run-123");
+ *
+ * // Check if run exists
+ * if (await storedRun.exists()) {
+ *   const { cursor, state } = await storedRun.load();
+ *   console.log("Previously interrupted at:", cursor);
+ * }
+ *
+ * // Save run state
+ * await storedRun.save("node-5", { data: "updated" });
+ *
+ * // Clean up when done
+ * await storedRun.delete();
+ * ```
+ */
+class StoredRun {
+    runId;
+    store;
+    /**
+     * Creates a wrapper for a specific run.
+     *
+     * @param {string} runId - Unique identifier for this run
+     * @param {BaseStore} store - The underlying store implementation
+     */
+    constructor(runId, store) {
+        this.runId = runId;
+        this.store = store;
+    }
+    /**
+     * Saves the current state and cursor position of this run.
+     *
+     * @param {string} cursor - Encoded position in the graph
+     * @param {object} state - Complete state at this checkpoint
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * await storedRun.save("node-process", { count: 42, data: [...] });
+     * ```
+     */
+    async save(cursor, state) {
+        await this.store.save(this.runId, cursor, state);
+    }
+    /**
+     * Checks if this run has been saved to the store.
+     *
+     * @returns {Promise<boolean>} True if the run exists
+     */
+    async exists() {
+        return await this.store.exists(this.runId);
+    }
+    /**
+     * Loads the saved state and cursor for this run.
+     *
+     * @returns {Promise<{cursor: string, state: object}>} The saved checkpoint
+     * @throws {Error} If the run does not exist
+     *
+     * @example
+     * ```typescript
+     * const { cursor, state } = await storedRun.load();
+     * // Resume from cursor: await graph.invoke(state, { resumeFrom: cursor });
+     * ```
+     */
+    async load() {
+        return await this.store.load(this.runId);
+    }
+    /**
+     * Deletes this run from the store.
+     *
+     * @returns {Promise<void>}
+     */
+    async delete() {
+        await this.store.delete(this.runId);
+    }
+}
+exports.StoredRun = StoredRun;
+//# sourceMappingURL=stored-run.js.map

package/dist/graphs/store/stored-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-run.js","sourceRoot":"","sources":["../../../src/graphs/store/stored-run.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAa,SAAS;IAOU;IAAgC;IAN5D;;;;;OAKG;IACH,YAA4B,KAAa,EAAmB,KAAgB;QAAhD,UAAK,GAAL,KAAK,CAAQ;QAAmB,UAAK,GAAL,KAAK,CAAW;IAC5E,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,IAAI,CAAC,MAAc,EAAE,KAAa;QACpC,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM;QACR,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,IAAI;QACN,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM;QACR,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;CACJ;AA3DD,8BA2DC"}

package/dist/graphs/types.d.ts

@@ -0,0 +1,15 @@
+interface EndResult<S> {
+    runId: string;
+    state: S;
+    exitReason: "end";
+}
+interface InterruptResult<S> {
+    runId: string;
+    state: S;
+    exitReason: "interrupt";
+    exitMessage: string;
+    cursor: string;
+}
+export type GraphResult<S> = EndResult<S> | InterruptResult<S>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/graphs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/graphs/types.ts"],"names":[],"mappings":"AAAA,UAAU,SAAS,CAAC,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;IACT,UAAU,EAAE,KAAK,CAAC;CACrB;AAED,UAAU,eAAe,CAAC,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;IACT,UAAU,EAAE,WAAW,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC"}

package/dist/graphs/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/graphs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/graphs/types.ts"],"names":[],"mappings":""}

package/dist/messages/index.d.ts

@@ -0,0 +1,6 @@
+import { BaseMessage } from "./message";
+import { ToolUse } from "./tool";
+export type ModelMessages = BaseMessage | ToolUse;
+export * from "./message";
+export * from "./tool";
+//# sourceMappingURL=index.d.ts.map

package/dist/messages/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,OAAO,CAAC;AAElD,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC"}

package/dist/messages/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./message"), exports);
+__exportStar(require("./tool"), exports);
+//# sourceMappingURL=index.js.map

package/dist/messages/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAKA,4CAA0B;AAC1B,yCAAuB"}