@kortyx/runtime 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.4.0](https://github.com/kortyx-io/Kortyx/compare/runtime-v0.3.0...runtime-v0.4.0) (2026-02-07)
+
+
+### Features
+
+* **runtime:** add node registry and declarative workflow support ([8a4a66c](https://github.com/kortyx-io/Kortyx/commit/8a4a66c4bba6eed688e35380e000e053fb4af52c))
+* **runtime:** framework persistence adapter ([8383ad2](https://github.com/kortyx-io/Kortyx/commit/8383ad2d73754ccf4daf33e414e15c3ce44df8cb))
+
 ## [0.3.0](https://github.com/kortyx-io/kortyx/compare/runtime-v0.2.2...runtime-v0.3.0) (2026-01-25)
 
 

package/dist/checkpointer.d.ts

@@ -1,3 +1,3 @@
-import { MemorySaver } from "@langchain/langgraph";
-export declare function getCheckpointer(key: string): MemorySaver;
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+export declare function getCheckpointer(key: string): BaseCheckpointSaver;
 //# sourceMappingURL=checkpointer.d.ts.map

package/dist/checkpointer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkpointer.d.ts","sourceRoot":"","sources":["../src/checkpointer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAQxD"}
+{"version":3,"file":"checkpointer.d.ts","sourceRoot":"","sources":["../src/checkpointer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAM3E,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAehE"}

package/dist/checkpointer.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCheckpointer = getCheckpointer;
-const langgraph_1 = require("@langchain/langgraph");
+const in_memory_checkpointer_1 = require("./framework/in-memory-checkpointer");
+const MAX_CHECKPOINTERS = 200;
 const map = new Map();
 function getCheckpointer(key) {
     const k = key || "__default__";
-    let saver = map.get(k);
-    if (!saver) {
-        saver = new langgraph_1.MemorySaver();
-        map.set(k, saver);
+    const existing = map.get(k);
+    if (existing)
+        return existing;
+    const saver = (0, in_memory_checkpointer_1.createInMemoryCheckpointSaver)();
+    map.set(k, saver);
+    if (map.size > MAX_CHECKPOINTERS) {
+        const first = map.keys().next().value;
+        if (first)
+            map.delete(first);
     }
     return saver;
 }

package/dist/framework/adapter.d.ts

@@ -0,0 +1,21 @@
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import { type PendingRequestStore } from "./pending-requests";
+export type FrameworkAdapter = {
+    kind: "memory" | "redis";
+    pendingRequests: PendingRequestStore;
+    checkpointer: BaseCheckpointSaver;
+    ttlMs: number;
+    cleanupRun?: (runId: string, namespaces: string[]) => Promise<void>;
+};
+export type CreateInMemoryFrameworkAdapterOptions = {
+    ttlMs?: number;
+};
+export declare function createInMemoryFrameworkAdapter(options?: CreateInMemoryFrameworkAdapterOptions): FrameworkAdapter;
+export type CreateRedisFrameworkAdapterOptions = {
+    url: string;
+    ttlMs?: number;
+    prefix?: string;
+};
+export declare function createRedisFrameworkAdapter(options: CreateRedisFrameworkAdapterOptions): FrameworkAdapter;
+export declare function createFrameworkAdapterFromEnv(env?: Record<string, string | undefined>): FrameworkAdapter;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/framework/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/framework/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE3E,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAK5B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;IACzB,eAAe,EAAE,mBAAmB,CAAC;IACrC,YAAY,EAAE,mBAAmB,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;IAKd,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrE,CAAC;AAEF,MAAM,MAAM,qCAAqC,GAAG;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,OAAO,CAAC,EAAE,qCAAqC,GAC9C,gBAAgB,CAgBlB;AAED,MAAM,MAAM,kCAAkC,GAAG;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,kCAAkC,GAC1C,gBAAgB,CAsClB;AAED,wBAAgB,6BAA6B,CAC3C,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,gBAAgB,CAclB"}

package/dist/framework/adapter.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInMemoryFrameworkAdapter = createInMemoryFrameworkAdapter;
+exports.createRedisFrameworkAdapter = createRedisFrameworkAdapter;
+exports.createFrameworkAdapterFromEnv = createFrameworkAdapterFromEnv;
+const in_memory_checkpointer_1 = require("./in-memory-checkpointer");
+const pending_requests_1 = require("./pending-requests");
+const pending_request_store_1 = require("./redis/pending-request-store");
+const redis_checkpointer_1 = require("./redis/redis-checkpointer");
+const redis_store_1 = require("./redis/redis-store");
+function createInMemoryFrameworkAdapter(options) {
+    const ttlMs = options?.ttlMs ?? 15 * 60 * 1000;
+    const checkpointer = (0, in_memory_checkpointer_1.createInMemoryCheckpointSaver)();
+    return {
+        kind: "memory",
+        ttlMs,
+        pendingRequests: (0, pending_requests_1.createInMemoryPendingRequestStore)(),
+        checkpointer,
+        cleanupRun: async (runId) => {
+            try {
+                await checkpointer.deleteThread(runId);
+            }
+            catch {
+            }
+        },
+    };
+}
+function createRedisFrameworkAdapter(options) {
+    const ttlMs = options.ttlMs ?? 15 * 60 * 1000;
+    const store = (0, redis_store_1.createRedisFrameworkStore)({
+        url: options.url,
+        prefix: options.prefix ?? "kortyx:fw:",
+    });
+    const cpPrefix = "kortyx:cp:";
+    return {
+        kind: "redis",
+        ttlMs,
+        pendingRequests: (0, pending_request_store_1.createRedisPendingRequestStore)({
+            store,
+            prefix: "kortyx:pending:",
+        }),
+        checkpointer: (0, redis_checkpointer_1.createRedisCheckpointSaver)({
+            store,
+            ttlMs,
+            prefix: cpPrefix,
+        }),
+        cleanupRun: async (runId, namespaces) => {
+            const nsList = namespaces.length > 0 ? namespaces : [""];
+            await Promise.all(nsList.map(async (checkpointNs) => {
+                const ns = String(checkpointNs ?? "");
+                const latestKey = `${cpPrefix}latest:${runId}:${ns}`;
+                const checkpointId = (await store.get(latestKey)) ?? "";
+                if (!checkpointId)
+                    return;
+                await Promise.all([
+                    store.del(`${cpPrefix}chk:${runId}:${ns}:${checkpointId}`),
+                    store.del(`${cpPrefix}wr:${runId}:${ns}:${checkpointId}`),
+                    store.del(latestKey),
+                ]);
+            }));
+        },
+    };
+}
+function createFrameworkAdapterFromEnv(env = process.env) {
+    const url = env.KORTYX_REDIS_URL ||
+        env.REDIS_URL ||
+        env.KORTYX_FRAMEWORK_REDIS_URL ||
+        "";
+    const ttlMsRaw = env.KORTYX_FRAMEWORK_TTL_MS || env.KORTYX_TTL_MS || "";
+    const ttlMs = ttlMsRaw ? Number(ttlMsRaw) : undefined;
+    if (url)
+        return createRedisFrameworkAdapter({ url, ...(ttlMs ? { ttlMs } : {}) });
+    return createInMemoryFrameworkAdapter({ ...(ttlMs ? { ttlMs } : {}) });
+}

package/dist/framework/in-memory-checkpointer.d.ts

@@ -0,0 +1,9 @@
+import { type BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+export type InMemoryCheckpointSaverOptions = {
+    maxWritesPerCheckpoint?: number;
+};
+export type InMemoryCheckpointSaver = BaseCheckpointSaver & {
+    deleteThread: (threadId: string) => Promise<void>;
+};
+export declare function createInMemoryCheckpointSaver(options?: InMemoryCheckpointSaverOptions): InMemoryCheckpointSaver;
+//# sourceMappingURL=in-memory-checkpointer.d.ts.map

package/dist/framework/in-memory-checkpointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-checkpointer.d.ts","sourceRoot":"","sources":["../../src/framework/in-memory-checkpointer.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,mBAAmB,EASzB,MAAM,iCAAiC,CAAC;AAczC,MAAM,MAAM,8BAA8B,GAAG;IAK3C,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAeF,MAAM,MAAM,uBAAuB,GAAG,mBAAmB,GAAG;IAC1D,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD,CAAC;AASF,wBAAgB,6BAA6B,CAC3C,OAAO,CAAC,EAAE,8BAA8B,GACvC,uBAAuB,CAyKzB"}

package/dist/framework/in-memory-checkpointer.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInMemoryCheckpointSaver = createInMemoryCheckpointSaver;
+const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
+const utf8Bytes = (s) => new Uint8Array(Buffer.from(s, "utf8"));
+const utf8String = (u8) => typeof u8 === "string" ? u8 : Buffer.from(u8).toString("utf8");
+const jsonSerde = {
+    async dumpsTyped(data) {
+        return ["json", utf8Bytes(JSON.stringify(data))];
+    },
+    async loadsTyped(_type, data) {
+        return JSON.parse(utf8String(data));
+    },
+};
+function createInMemoryCheckpointSaver(options) {
+    const maxWritesPerCheckpoint = options?.maxWritesPerCheckpoint ?? 2_000;
+    const latest = new Map();
+    const checkpoints = new Map();
+    const nsKey = (threadId, checkpointNs) => `${threadId}\u0001${checkpointNs}`;
+    const chkKey = (threadId, checkpointNs, checkpointId) => `${threadId}\u0001${checkpointNs}\u0001${checkpointId}`;
+    const saver = {
+        serde: jsonSerde,
+        async get(config) {
+            const value = await saver.getTuple(config);
+            return value ? value.checkpoint : undefined;
+        },
+        getNextVersion(current) {
+            if (typeof current === "string") {
+                throw new Error("Please override this method to use string versions.");
+            }
+            return current !== undefined && typeof current === "number"
+                ? current + 1
+                : 1;
+        },
+        async getTuple(config) {
+            const threadId = config.configurable?.thread_id;
+            const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+            if (!threadId)
+                return undefined;
+            const requested = (0, langgraph_checkpoint_1.getCheckpointId)(config);
+            const id = requested || latest.get(nsKey(threadId, checkpointNs));
+            if (!id)
+                return undefined;
+            const stored = checkpoints.get(chkKey(threadId, checkpointNs, id));
+            if (!stored)
+                return undefined;
+            const pendingWrites = Array.from(stored.writes.values());
+            const tuple = {
+                config: {
+                    configurable: {
+                        thread_id: threadId,
+                        checkpoint_ns: checkpointNs,
+                        checkpoint_id: id,
+                    },
+                },
+                checkpoint: stored.checkpoint,
+                metadata: stored.metadata,
+                pendingWrites: pendingWrites,
+            };
+            if (stored.parentCheckpointId) {
+                tuple.parentConfig = {
+                    configurable: {
+                        thread_id: threadId,
+                        checkpoint_ns: checkpointNs,
+                        checkpoint_id: stored.parentCheckpointId,
+                    },
+                };
+            }
+            return tuple;
+        },
+        async *list(_config, _options) {
+        },
+        async put(config, checkpoint, metadata, _newVersions) {
+            const threadId = config.configurable?.thread_id;
+            const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+            if (!threadId) {
+                throw new Error('Failed to put checkpoint: missing "thread_id" in config.configurable.');
+            }
+            const ns = nsKey(threadId, checkpointNs);
+            const prevId = latest.get(ns);
+            const prepared = (0, langgraph_checkpoint_1.copyCheckpoint)(checkpoint);
+            const entry = {
+                checkpoint: prepared,
+                metadata,
+                parentCheckpointId: config.configurable?.checkpoint_id,
+                writes: new Map(),
+            };
+            const id = checkpoint.id;
+            checkpoints.set(chkKey(threadId, checkpointNs, id), entry);
+            latest.set(ns, id);
+            if (prevId && prevId !== id) {
+                checkpoints.delete(chkKey(threadId, checkpointNs, prevId));
+            }
+            return {
+                configurable: {
+                    thread_id: threadId,
+                    checkpoint_ns: checkpointNs,
+                    checkpoint_id: id,
+                },
+            };
+        },
+        async putWrites(config, writes, taskId) {
+            const threadId = config.configurable?.thread_id;
+            const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+            const checkpointId = config.configurable?.checkpoint_id;
+            if (!threadId || !checkpointId)
+                return;
+            const stored = checkpoints.get(chkKey(threadId, checkpointNs, checkpointId));
+            if (!stored)
+                return;
+            for (let idx = 0; idx < writes.length; idx++) {
+                const [channel, value] = writes[idx];
+                const mappedIdx = langgraph_checkpoint_1.WRITES_IDX_MAP[channel] ?? idx;
+                const key = `${taskId},${mappedIdx}`;
+                if (mappedIdx >= 0 && stored.writes.has(key))
+                    continue;
+                if (stored.writes.size >= maxWritesPerCheckpoint)
+                    break;
+                stored.writes.set(key, [taskId, channel, value]);
+            }
+        },
+        async deleteThread(threadId) {
+            for (const k of Array.from(latest.keys())) {
+                if (k.startsWith(`${threadId}\u0001`))
+                    latest.delete(k);
+            }
+            for (const k of Array.from(checkpoints.keys())) {
+                if (k.startsWith(`${threadId}\u0001`))
+                    checkpoints.delete(k);
+            }
+        },
+    };
+    return saver;
+}

package/dist/framework/pending-requests.d.ts

@@ -0,0 +1,33 @@
+import type { GraphState } from "@kortyx/core";
+export type HumanInputKind = "choice" | "multi-choice" | "text";
+export interface HumanInputOption {
+    id: string;
+    label: string;
+    description?: string;
+    value?: unknown;
+}
+export interface PendingRequestRecord {
+    token: string;
+    requestId: string;
+    sessionId?: string | undefined;
+    runId: string;
+    workflow: string;
+    node: string;
+    state?: GraphState;
+    schema: {
+        kind: HumanInputKind;
+        multiple: boolean;
+        question?: string;
+    };
+    options: HumanInputOption[];
+    createdAt: number;
+    ttlMs: number;
+}
+export interface PendingRequestStore {
+    save: (rec: PendingRequestRecord) => Promise<void>;
+    get: (token: string) => Promise<PendingRequestRecord | null>;
+    delete: (token: string) => Promise<void>;
+    update: (token: string, patch: Partial<PendingRequestRecord>) => Promise<void>;
+}
+export declare function createInMemoryPendingRequestStore(): PendingRequestStore;
+//# sourceMappingURL=pending-requests.d.ts.map

package/dist/framework/pending-requests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-requests.d.ts","sourceRoot":"","sources":["../../src/framework/pending-requests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,cAAc,GAAG,MAAM,CAAC;AAEhE,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAK/B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE;QAAE,IAAI,EAAE,cAAc,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACvE,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,CAAC,GAAG,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IAC7D,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,MAAM,EAAE,CACN,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,CAAC,oBAAoB,CAAC,KACjC,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED,wBAAgB,iCAAiC,IAAI,mBAAmB,CA4BvE"}

package/dist/framework/pending-requests.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInMemoryPendingRequestStore = createInMemoryPendingRequestStore;
+function createInMemoryPendingRequestStore() {
+    const store = new Map();
+    const prune = () => {
+        const t = Date.now();
+        for (const [k, v] of store.entries()) {
+            if (t - v.createdAt > v.ttlMs)
+                store.delete(k);
+        }
+    };
+    return {
+        async save(rec) {
+            prune();
+            store.set(rec.token, rec);
+        },
+        async get(token) {
+            prune();
+            return store.get(token) ?? null;
+        },
+        async delete(token) {
+            store.delete(token);
+        },
+        async update(token, patch) {
+            const prev = store.get(token);
+            if (!prev)
+                return;
+            store.set(token, { ...prev, ...patch });
+        },
+    };
+}

package/dist/framework/redis/pending-request-store.d.ts

@@ -0,0 +1,8 @@
+import type { PendingRequestStore } from "../pending-requests";
+import type { RedisFrameworkStore } from "./redis-store";
+export type RedisPendingRequestStoreOptions = {
+    store: RedisFrameworkStore;
+    prefix?: string;
+};
+export declare function createRedisPendingRequestStore(options: RedisPendingRequestStoreOptions): PendingRequestStore;
+//# sourceMappingURL=pending-request-store.d.ts.map

package/dist/framework/redis/pending-request-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-request-store.d.ts","sourceRoot":"","sources":["../../../src/framework/redis/pending-request-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,KAAK,EAAE,mBAAmB,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,+BAA+B,GACvC,mBAAmB,CAyBrB"}

package/dist/framework/redis/pending-request-store.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRedisPendingRequestStore = createRedisPendingRequestStore;
+function createRedisPendingRequestStore(options) {
+    const prefix = options.prefix ?? "kortyx:pending:";
+    const key = (token) => `${prefix}${token}`;
+    return {
+        async save(rec) {
+            await options.store.set(key(rec.token), JSON.stringify(rec), rec.ttlMs);
+        },
+        async get(token) {
+            const raw = await options.store.get(key(token));
+            if (!raw)
+                return null;
+            return JSON.parse(raw);
+        },
+        async delete(token) {
+            await options.store.del(key(token));
+        },
+        async update(token, patch) {
+            const prevRaw = await options.store.get(key(token));
+            if (!prevRaw)
+                return;
+            const prev = JSON.parse(prevRaw);
+            const next = { ...prev, ...patch };
+            const ttlLeft = Math.max(1, next.ttlMs - (Date.now() - next.createdAt));
+            await options.store.set(key(token), JSON.stringify(next), ttlLeft);
+        },
+    };
+}

package/dist/framework/redis/redis-checkpointer.d.ts

@@ -0,0 +1,13 @@
+import { type BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import type { RedisFrameworkStore } from "./redis-store";
+type RedisCheckpointSaverOptions = {
+    store: RedisFrameworkStore;
+    prefix?: string;
+    ttlMs: number;
+};
+export type RedisCheckpointSaver = BaseCheckpointSaver & {
+    deleteThread: (threadId: string) => Promise<void>;
+};
+export declare function createRedisCheckpointSaver(options: RedisCheckpointSaverOptions): RedisCheckpointSaver;
+export {};
+//# sourceMappingURL=redis-checkpointer.d.ts.map

package/dist/framework/redis/redis-checkpointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-checkpointer.d.ts","sourceRoot":"","sources":["../../../src/framework/redis/redis-checkpointer.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,mBAAmB,EASzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAOzD,KAAK,2BAA2B,GAAG;IACjC,KAAK,EAAE,mBAAmB,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8BF,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,GAAG;IACvD,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD,CAAC;AAEF,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,2BAA2B,GACnC,oBAAoB,CAwNtB"}

package/dist/framework/redis/redis-checkpointer.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRedisCheckpointSaver = createRedisCheckpointSaver;
+const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
+const utf8Bytes = (s) => new Uint8Array(Buffer.from(s, "utf8"));
+const utf8String = (u8) => typeof u8 === "string" ? u8 : Buffer.from(u8).toString("utf8");
+const jsonSerde = {
+    async dumpsTyped(data) {
+        return ["json", utf8Bytes(JSON.stringify(data))];
+    },
+    async loadsTyped(_type, data) {
+        return JSON.parse(utf8String(data));
+    },
+};
+const b64FromBytes = (u8) => Buffer.from(u8).toString("base64");
+const bytesFromB64 = (s) => new Uint8Array(Buffer.from(s, "base64"));
+function createRedisCheckpointSaver(options) {
+    const store = options.store;
+    const ttlMs = options.ttlMs;
+    const prefix = options.prefix ?? "kortyx:cp:";
+    const latestKey = (threadId, checkpointNs) => `${prefix}latest:${threadId}:${checkpointNs}`;
+    const checkpointKey = (threadId, checkpointNs, checkpointId) => `${prefix}chk:${threadId}:${checkpointNs}:${checkpointId}`;
+    const writesKey = (threadId, checkpointNs, checkpointId) => `${prefix}wr:${threadId}:${checkpointNs}:${checkpointId}`;
+    const serde = jsonSerde;
+    const saver = {
+        serde,
+        async get(config) {
+            const value = await saver.getTuple(config);
+            return value ? value.checkpoint : undefined;
+        },
+        getNextVersion(current) {
+            if (typeof current === "string") {
+                throw new Error("Please override this method to use string versions.");
+            }
+            return current !== undefined && typeof current === "number"
+                ? current + 1
+                : 1;
+        },
+        async getTuple(config) {
+            const threadId = config.configurable?.thread_id;
+            const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+            if (!threadId)
+                return undefined;
+            const requested = (0, langgraph_checkpoint_1.getCheckpointId)(config);
+            const checkpointId = requested || (await store.get(latestKey(threadId, checkpointNs))) || "";
+            if (!checkpointId)
+                return undefined;
+            const raw = await store.get(checkpointKey(threadId, checkpointNs, checkpointId));
+            if (!raw)
+                return undefined;
+            const parsed = JSON.parse(raw);
+            const checkpoint = (await serde.loadsTyped("json", bytesFromB64(parsed.checkpoint)));
+            const metadata = (await serde.loadsTyped("json", bytesFromB64(parsed.metadata)));
+            const writes = await store.hgetall(writesKey(threadId, checkpointNs, checkpointId));
+            const pendingWrites = await Promise.all(Object.values(writes).map(async (v) => {
+                const w = JSON.parse(v);
+                return [
+                    w.taskId,
+                    w.channel,
+                    await serde.loadsTyped("json", bytesFromB64(w.value)),
+                ];
+            }));
+            const tuple = {
+                config: {
+                    configurable: {
+                        thread_id: threadId,
+                        checkpoint_ns: checkpointNs,
+                        checkpoint_id: checkpointId,
+                    },
+                },
+                checkpoint,
+                metadata,
+                pendingWrites,
+            };
+            if (parsed.parentCheckpointId) {
+                tuple.parentConfig = {
+                    configurable: {
+                        thread_id: threadId,
+                        checkpoint_ns: checkpointNs,
+                        checkpoint_id: parsed.parentCheckpointId,
+                    },
+                };
+            }
+            return tuple;
+        },
+        async *list(_config, _options) {
+        },
+        async put(config, checkpoint, metadata, _newVersions) {
+            const threadId = config.configurable?.thread_id;
+            const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+            if (!threadId) {
+                throw new Error('Failed to put checkpoint: missing "thread_id" in config.configurable.');
+            }
+            const prevId = await store.get(latestKey(threadId, checkpointNs));
+            const prepared = (0, langgraph_checkpoint_1.copyCheckpoint)(checkpoint);
+            const [[, chkBytes], [, metaBytes]] = await Promise.all([
+                serde.dumpsTyped(prepared),
+                serde.dumpsTyped(metadata),
+            ]);
+            const checkpointId = checkpoint.id;
+            const key = checkpointKey(threadId, checkpointNs, checkpointId);
+            const stored = {
+                checkpoint: b64FromBytes(chkBytes),
+                metadata: b64FromBytes(metaBytes),
+                parentCheckpointId: config.configurable?.checkpoint_id,
+            };
+            await store.set(key, JSON.stringify(stored), ttlMs);
+            await store.set(latestKey(threadId, checkpointNs), checkpointId, ttlMs);
+            if (prevId && prevId !== checkpointId) {
+                await store.del(checkpointKey(threadId, checkpointNs, prevId));
+                await store.del(writesKey(threadId, checkpointNs, prevId));
+            }
+            return {
+                configurable: {
+                    thread_id: threadId,
+                    checkpoint_ns: checkpointNs,
+                    checkpoint_id: checkpointId,
+                },
+            };
+        },
+        async putWrites(config, writes, taskId) {
+            const threadId = config.configurable?.thread_id;
+            const checkpointNs = config.configurable?.checkpoint_ns;
+            const checkpointId = config.configurable?.checkpoint_id;
+            if (!threadId) {
+                throw new Error('Failed to put writes: missing "thread_id" in config.configurable.');
+            }
+            if (!checkpointId) {
+                throw new Error('Failed to put writes: missing "checkpoint_id" in config.configurable.');
+            }
+            const outer = writesKey(threadId, checkpointNs ?? "", checkpointId);
+            await store.expire(outer, ttlMs);
+            await Promise.all(writes.map(async ([channel, value], idx) => {
+                const [, vBytes] = await serde.dumpsTyped(value);
+                const mappedIdx = langgraph_checkpoint_1.WRITES_IDX_MAP[channel] ?? idx;
+                const innerKeyStr = `${taskId},${mappedIdx}`;
+                const payload = {
+                    taskId,
+                    channel,
+                    value: b64FromBytes(vBytes),
+                };
+                const serialized = JSON.stringify(payload);
+                if (mappedIdx >= 0) {
+                    await store.hsetnx(outer, innerKeyStr, serialized);
+                }
+                else {
+                    await store.hset(outer, innerKeyStr, serialized);
+                }
+            }));
+        },
+        async deleteThread(threadId) {
+            const chkKeys = await store.scanKeys(`${prefix}chk:${threadId}:`);
+            const wrKeys = await store.scanKeys(`${prefix}wr:${threadId}:`);
+            const latestKeys = await store.scanKeys(`${prefix}latest:${threadId}:`);
+            await store.delRaw([...chkKeys, ...wrKeys, ...latestKeys]);
+        },
+    };
+    return saver;
+}

package/dist/framework/redis/redis-client.d.ts

@@ -0,0 +1,13 @@
+export type RedisReply = string | number | null | RedisReply[] | {
+    type: "error";
+    message: string;
+};
+export type RedisClientOptions = {
+    url: string;
+    connectTimeoutMs?: number;
+};
+export type RedisClient = {
+    command: (cmd: string, args?: string[]) => Promise<RedisReply>;
+};
+export declare function createRedisClient(options: RedisClientOptions): RedisClient;
+//# sourceMappingURL=redis-client.d.ts.map

package/dist/framework/redis/redis-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-client.d.ts","sourceRoot":"","sources":["../../../src/framework/redis/redis-client.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,UAAU,GAClB,MAAM,GACN,MAAM,GACN,IAAI,GACJ,UAAU,EAAE,GACZ;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AA0EF,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CAChE,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CA6H1E"}