@kortyx/runtime 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## [0.2.0](https://github.com/kortyx-io/kortyx/compare/runtime-v0.1.0...runtime-v0.2.0) (2026-01-21)
+
+
+### Features
+
+* create kortyx packages ([fb9d281](https://github.com/kortyx-io/kortyx/commit/fb9d281e92e885fcfc2948dc1ee9701e881f7321))

package/dist/checkpointer.d.ts

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

package/dist/checkpointer.d.ts.map

@@ -0,0 +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"}

package/dist/checkpointer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCheckpointer = getCheckpointer;
+const langgraph_1 = require("@langchain/langgraph");
+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);
+    }
+    return saver;
+}

package/dist/config/load-kortyx-config.d.ts

@@ -0,0 +1,14 @@
+export interface KortyxConfig {
+    workflowsDir?: string;
+    fallbackWorkflowId?: string;
+    registry?: {
+        cache?: boolean;
+        extensions?: string[];
+    };
+}
+export interface LoadKortyxConfigOptions {
+    cwd?: string;
+    configPath?: string;
+}
+export declare function loadKortyxConfig(options?: LoadKortyxConfigOptions): Promise<KortyxConfig | null>;
+//# sourceMappingURL=load-kortyx-config.d.ts.map

package/dist/config/load-kortyx-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-kortyx-config.d.ts","sourceRoot":"","sources":["../../src/config/load-kortyx-config.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE;QACT,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAWD,wBAAsB,gBAAgB,CACpC,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAgB9B"}

package/dist/config/load-kortyx-config.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadKortyxConfig = loadKortyxConfig;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const url_1 = require("url");
+async function exists(filePath) {
+    try {
+        const info = await (0, promises_1.stat)(filePath);
+        return info.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function loadKortyxConfig(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const configPath = options.configPath ?? "kortyx.config.mjs";
+    const resolvedPath = (0, path_1.resolve)(cwd, configPath);
+    if (!(await exists(resolvedPath)))
+        return null;
+    try {
+        const mod = await import((0, url_1.pathToFileURL)(resolvedPath).href);
+        const config = (mod?.default ?? mod?.kortyx ?? mod);
+        if (!config || typeof config !== "object")
+            return null;
+        return config;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to load ${configPath}: ${message}`);
+    }
+}

package/dist/graph/create-langgraph.d.ts

@@ -0,0 +1,15 @@
+import type { Edge, GraphState, NodeMap, WorkflowDefinition } from "@kortyx/core";
+import type { MemoryAdapter } from "@kortyx/memory";
+import type { GetProviderFn } from "@kortyx/providers";
+export interface GraphRuntimeConfig {
+    emit?: (event: string, payload: unknown) => void;
+    onCheckpoint?: (args: {
+        nodeId: string;
+        state: GraphState;
+    }) => void;
+    memoryAdapter?: MemoryAdapter;
+    getProvider?: GetProviderFn;
+    [key: string]: unknown;
+}
+export declare function createLangGraph<const N extends NodeMap, const E extends readonly Edge<(keyof N & string) | "__start__", (keyof N & string) | "__end__">[]>(workflow: WorkflowDefinition<N, E>, config: GraphRuntimeConfig): Promise<any>;
+//# sourceMappingURL=create-langgraph.d.ts.map

package/dist/graph/create-langgraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-langgraph.d.ts","sourceRoot":"","sources":["../../src/graph/create-langgraph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,IAAI,EACJ,UAAU,EAGV,OAAO,EAEP,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAUvD,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACjD,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE,KAAK,IAAI,CAAC;IACrE,aAAa,CAAC,EAAE,aAAa,CAAC;IAK9B,WAAW,CAAC,EAAE,aAAa,CAAC;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,wBAAsB,eAAe,CACnC,KAAK,CAAC,CAAC,SAAS,OAAO,EACvB,KAAK,CAAC,CAAC,SAAS,SAAS,IAAI,CAC3B,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,WAAW,EAChC,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,SAAS,CAC/B,EAAE,EACH,QAAQ,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,kBAAkB,gBA4Y/D"}

package/dist/graph/create-langgraph.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLangGraph = createLangGraph;
+const hooks_1 = require("@kortyx/hooks");
+const utils_1 = require("@kortyx/utils");
+const messages_1 = require("@langchain/core/messages");
+const langgraph_1 = require("@langchain/langgraph");
+const checkpointer_1 = require("../checkpointer");
+async function createLangGraph(workflow, config) {
+    const StateAnnotation = langgraph_1.Annotation.Root({
+        input: (langgraph_1.Annotation),
+        output: (langgraph_1.Annotation),
+        lastNode: (langgraph_1.Annotation),
+        lastCondition: (langgraph_1.Annotation),
+        lastIntent: (langgraph_1.Annotation),
+        memory: (0, langgraph_1.Annotation)({
+            reducer: (l, r) => (0, utils_1.deepMergeWithArrayOverwrite)(l ?? {}, r ?? {}),
+            default: () => ({}),
+        }),
+        config: (langgraph_1.Annotation),
+        transitionTo: (langgraph_1.Annotation),
+        data: (0, langgraph_1.Annotation)({
+            reducer: (l, r) => (0, utils_1.deepMergeWithArrayOverwrite)(l ?? {}, r ?? {}),
+            default: () => ({}),
+        }),
+        conversationHistory: (0, langgraph_1.Annotation)({
+            reducer: (l, r) => [...(l ?? []), ...(r ?? [])],
+            default: () => [],
+        }),
+        awaitingHumanInput: (langgraph_1.Annotation),
+    });
+    const builder = new langgraph_1.StateGraph(StateAnnotation);
+    const edgeApi = builder;
+    const workflowName = workflow.name;
+    const runtimeConfig = config;
+    if (!runtimeConfig.emit) {
+        runtimeConfig.emit = () => { };
+    }
+    const nodesMap = workflow.nodes;
+    for (const [nodeId, node] of Object.entries(nodesMap)) {
+        const nodeConfig = node.config ?? {};
+        const behavior = nodeConfig.behavior ?? {};
+        builder.addNode(nodeId, async (state) => {
+            const ctx = {
+                graph: { name: workflowName, node: nodeId },
+                config: nodeConfig,
+                emit: (event, payload) => {
+                    runtimeConfig.emit(event, payload);
+                },
+                error: (message) => {
+                    runtimeConfig.emit("error", {
+                        node: nodeId,
+                        message,
+                    });
+                },
+                awaitInterrupt: (interruptConfig) => {
+                    const { kind, question } = interruptConfig;
+                    const isMulti = kind === "multi-choice" ||
+                        (interruptConfig.kind !== "text" &&
+                            interruptConfig.multiple === true);
+                    const payload = {
+                        kind,
+                        multiple: isMulti,
+                        question,
+                        ...(interruptConfig.kind !== "text"
+                            ? { options: interruptConfig.options }
+                            : {}),
+                    };
+                    runtimeConfig.emit("interrupt", {
+                        node: nodeId,
+                        workflow: workflowName,
+                        input: payload,
+                    });
+                    const resumed = (0, langgraph_1.interrupt)(payload);
+                    if (isMulti) {
+                        if (Array.isArray(resumed)) {
+                            return resumed
+                                .map((v) => typeof v === "string"
+                                ? v
+                                : v && typeof v.id === "string"
+                                    ? v.id
+                                    : "")
+                                .filter(Boolean);
+                        }
+                        if (typeof resumed === "string")
+                            return [resumed];
+                        return [];
+                    }
+                    if (typeof resumed === "string")
+                        return resumed;
+                    if (resumed && typeof resumed.id === "string")
+                        return String(resumed.id);
+                    return "";
+                },
+                speak: async (args) => {
+                    const providerId = args.model?.provider ?? nodeConfig.model?.provider ?? "google";
+                    const modelName = args.model?.name ?? nodeConfig.model?.name ?? "gemini-2.5-flash";
+                    const temperature = args.model?.temperature ?? nodeConfig.model?.temperature ?? 0.3;
+                    const getProvider = runtimeConfig.getProvider;
+                    if (!getProvider) {
+                        throw new Error("Runtime config is missing getProvider; wire a provider factory into @kortyx/runtime.");
+                    }
+                    const model = getProvider(providerId, modelName, {
+                        temperature,
+                        streaming: true,
+                    });
+                    const messages = [
+                        ...(args.system ? [new messages_1.SystemMessage(args.system)] : []),
+                        new messages_1.HumanMessage(args.user ?? ""),
+                    ];
+                    const minChars = args.stream?.minChars ?? 24;
+                    const flushMs = args.stream?.flushMs ?? 100;
+                    const segmentChars = args.stream?.segmentChars ?? 60;
+                    let final = "";
+                    let buffer = "";
+                    let timer = null;
+                    const t0 = Date.now();
+                    let seenFirst = false;
+                    const isSilent = false;
+                    const flush = () => {
+                        if (!buffer)
+                            return;
+                        if (!isSilent)
+                            ctx.emit("text-delta", { node: nodeId, delta: buffer });
+                        buffer = "";
+                        timer = null;
+                    };
+                    if (!isSilent)
+                        ctx.emit("text-start", { node: nodeId });
+                    const stream = await model.stream(messages);
+                    for await (const chunk of stream) {
+                        const part = (0, utils_1.contentToText)(chunk.content);
+                        if (!part)
+                            continue;
+                        if (!seenFirst) {
+                            seenFirst = true;
+                            const ttft = Date.now() - t0;
+                            ctx.emit("status", {
+                                node: nodeId,
+                                message: `⏱️ TTFT ${ttft}ms`,
+                            });
+                        }
+                        final += part;
+                        for (let i = 0; i < part.length; i += segmentChars) {
+                            const seg = part.slice(i, i + segmentChars);
+                            buffer += seg;
+                            if (buffer.length >= minChars) {
+                                flush();
+                            }
+                            else if (!timer) {
+                                timer = setTimeout(flush, flushMs);
+                            }
+                        }
+                    }
+                    if (timer)
+                        clearTimeout(timer);
+                    flush();
+                    if (!isSilent)
+                        ctx.emit("text-end", { node: nodeId });
+                    const t1 = Date.now();
+                    if (seenFirst)
+                        ctx.emit("status", {
+                            node: nodeId,
+                            message: `✅ Stream done in ${t1 - t0}ms`,
+                        });
+                    return final;
+                },
+            };
+            if (behavior.checkpoint && config?.onCheckpoint) {
+                config.onCheckpoint({ nodeId, state });
+            }
+            const maxAttempts = behavior.retry?.maxAttempts ?? 1;
+            let attempt = 0;
+            let nodeResult;
+            let hookMemoryUpdates = null;
+            while (attempt < maxAttempts) {
+                try {
+                    attempt++;
+                    const hookContext = {
+                        node: ctx,
+                        state,
+                        ...(runtimeConfig.getProvider
+                            ? { getProvider: runtimeConfig.getProvider }
+                            : {}),
+                        ...(runtimeConfig.memoryAdapter
+                            ? { memoryAdapter: runtimeConfig.memoryAdapter }
+                            : {}),
+                    };
+                    const hookRun = await (0, hooks_1.runWithHookContext)(hookContext, () => node.run(state, ctx));
+                    nodeResult = hookRun.result;
+                    hookMemoryUpdates = hookRun.memoryUpdates;
+                    break;
+                }
+                catch (err) {
+                    const hasMore = attempt < maxAttempts;
+                    const delayMs = behavior.retry?.delayMs ?? 0;
+                    if (hasMore && delayMs > 0) {
+                        await new Promise((r) => setTimeout(r, delayMs));
+                        continue;
+                    }
+                    if (!hasMore)
+                        throw err;
+                }
+            }
+            const res = (nodeResult ?? {});
+            if (hookMemoryUpdates) {
+                res.infra = {
+                    ...(res.infra ?? {}),
+                    memory: (0, utils_1.deepMergeWithArrayOverwrite)((res.infra?.memory ?? {}) || {}, hookMemoryUpdates),
+                };
+            }
+            const uiMessage = res.ui?.message;
+            const shouldRespond = typeof uiMessage === "string" && uiMessage.trim().length > 0;
+            if (shouldRespond) {
+                ctx.emit("message", { node: nodeId, content: uiMessage });
+            }
+            if (res.transitionTo) {
+                ctx.emit("transition", {
+                    transitionTo: res.transitionTo,
+                    payload: res.data ?? {},
+                });
+            }
+            const updates = {};
+            if (typeof res.condition === "string")
+                updates.lastCondition = res.condition;
+            if (typeof res.intent === "string")
+                updates.lastIntent = res.intent;
+            if (res.data && typeof res.data === "object") {
+                updates.data = (0, utils_1.deepMergeWithArrayOverwrite)((state.data ?? {}), res.data);
+            }
+            if (res.infra?.memory && typeof res.infra.memory === "object") {
+                updates.memory = (0, utils_1.deepMergeWithArrayOverwrite)((state.memory ?? {}), res.infra.memory);
+            }
+            if (res.ui) {
+                updates.ui = {
+                    message: typeof res.ui.message === "string"
+                        ? res.ui.message
+                        : (state.ui?.message ?? ""),
+                    structured: (0, utils_1.deepMergeWithArrayOverwrite)((state.ui?.structured ?? {}), (res.ui.structured ?? {})),
+                };
+            }
+            if (shouldRespond && uiMessage) {
+                updates.conversationHistory = [
+                    ...(state.conversationHistory ?? []),
+                    {
+                        node: nodeId,
+                        message: uiMessage,
+                        timestamp: new Date().toISOString(),
+                    },
+                ];
+            }
+            if (res.ui?.structured) {
+                const payload = res.ui.structured;
+                const inferredType = payload && typeof payload === "object" && "jobs" in payload
+                    ? "jobs"
+                    : typeof payload.summary === "string" ||
+                        payload.topJobs
+                        ? "summary"
+                        : "generic";
+                ctx.emit("structured_data", {
+                    node: nodeId,
+                    dataType: inferredType,
+                    data: payload,
+                });
+            }
+            return updates;
+        });
+    }
+    const condGroups = {};
+    const plainEdges = [];
+    for (const edge of workflow.edges) {
+        const [from, to, condition] = edge;
+        if (condition && typeof condition.when === "string" && condition.when) {
+            if (!condGroups[from])
+                condGroups[from] = [];
+            condGroups[from].push({ when: condition.when, to });
+        }
+        else {
+            plainEdges.push([from, to]);
+        }
+    }
+    for (const [from, to] of plainEdges) {
+        edgeApi.addEdge(from, to);
+    }
+    for (const [from, rules] of Object.entries(condGroups)) {
+        const mapping = Object.fromEntries(rules.map((r) => [r.when, r.to]));
+        const fallbackKey = `__default__:${from}`;
+        mapping[fallbackKey] = "__end__";
+        edgeApi.addConditionalEdges(from, (s) => {
+            const trigger = s.lastCondition ?? s.lastIntent;
+            if (trigger && Object.hasOwn(mapping, trigger)) {
+                return trigger;
+            }
+            return fallbackKey;
+        }, mapping);
+    }
+    const sessionId = config?.session?.id ?? "__default__";
+    const checkpointer = (0, checkpointer_1.getCheckpointer)(sessionId);
+    const graph = builder.compile({ checkpointer });
+    const runtimeGraph = graph;
+    runtimeGraph.name = workflow.name;
+    runtimeGraph.config = config;
+    runtimeGraph.resume = async (state, input) => {
+        const resumed = { ...state, input, awaitingHumanInput: false };
+        return graph.invoke(resumed);
+    };
+    runtimeGraph.timeTravelTo = async (state, checkpointId) => {
+        const checkpoints = state.memory?.checkpoints;
+        const snapshot = checkpoints?.[checkpointId];
+        if (!snapshot)
+            throw new Error(`Checkpoint '${checkpointId}' not found`);
+        return graph.invoke(snapshot.snapshot);
+    };
+    return runtimeGraph;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./checkpointer";
+export * from "./config/load-kortyx-config";
+export * from "./graph/create-langgraph";
+export * from "./interrupt/tokens";
+export * from "./registry/file-registry";
+export * from "./registry/interface";
+export * from "./state/build-initial-state";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+"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("./checkpointer"), exports);
+__exportStar(require("./config/load-kortyx-config"), exports);
+__exportStar(require("./graph/create-langgraph"), exports);
+__exportStar(require("./interrupt/tokens"), exports);
+__exportStar(require("./registry/file-registry"), exports);
+__exportStar(require("./registry/interface"), exports);
+__exportStar(require("./state/build-initial-state"), exports);

package/dist/interrupt/tokens.d.ts

@@ -0,0 +1,3 @@
+export declare function makeResumeToken(): string;
+export declare function makeRequestId(prefix?: string): string;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/interrupt/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/interrupt/tokens.ts"],"names":[],"mappings":"AAEA,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,wBAAgB,aAAa,CAAC,MAAM,SAAQ,GAAG,MAAM,CAEpD"}

package/dist/interrupt/tokens.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeResumeToken = makeResumeToken;
+exports.makeRequestId = makeRequestId;
+const uuid_1 = require("uuid");
+function makeResumeToken() {
+    return (0, uuid_1.v7)();
+}
+function makeRequestId(prefix = "req") {
+    return `${prefix}-${(0, uuid_1.v7)()}`;
+}

package/dist/registry/file-registry.d.ts

@@ -0,0 +1,9 @@
+import type { WorkflowRegistry } from "./interface";
+export interface FileWorkflowRegistryOptions {
+    workflowsDir: string;
+    fallbackId?: string;
+    cache?: boolean;
+    extensions?: string[];
+}
+export declare function createFileWorkflowRegistry(options: FileWorkflowRegistryOptions): WorkflowRegistry;
+//# sourceMappingURL=file-registry.d.ts.map

package/dist/registry/file-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-registry.d.ts","sourceRoot":"","sources":["../../src/registry/file-registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,2BAA2B;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAeD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,2BAA2B,GACnC,gBAAgB,CAgGlB"}

package/dist/registry/file-registry.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileWorkflowRegistry = createFileWorkflowRegistry;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const DEFAULT_EXTENSIONS = [
+    ".workflow.ts",
+    ".workflow.mts",
+    ".workflow.js",
+    ".workflow.mjs",
+];
+function isWorkflowFile(name, extensions) {
+    return extensions.some((ext) => name.endsWith(ext));
+}
+function createFileWorkflowRegistry(options) {
+    const workflowsDir = options.workflowsDir;
+    const fallbackId = options.fallbackId ?? "general-chat";
+    const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+    const shouldCache = options.cache ?? true;
+    let workflowCache = null;
+    async function loadWorkflows() {
+        if (shouldCache && workflowCache)
+            return workflowCache;
+        const files = await (0, promises_1.readdir)(workflowsDir, { withFileTypes: true });
+        const workflowFiles = files
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name)
+            .filter((file) => isWorkflowFile(file, extensions));
+        const workflows = {};
+        for (const file of workflowFiles) {
+            try {
+                const modulePath = (0, path_1.join)(workflowsDir, file);
+                const module = await import(modulePath);
+                const workflowExport = Object.values(module).find((exp) => {
+                    const obj = exp;
+                    return (exp !== null &&
+                        typeof exp === "object" &&
+                        typeof obj.name === "string" &&
+                        typeof obj.nodes === "object" &&
+                        obj.nodes !== null &&
+                        Array.isArray(obj.edges));
+                });
+                if (workflowExport) {
+                    workflows[workflowExport.name] = workflowExport;
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to load workflow from ${file}:`, error);
+            }
+        }
+        if (shouldCache)
+            workflowCache = workflows;
+        return workflows;
+    }
+    async function list() {
+        const workflows = await loadWorkflows();
+        return Object.values(workflows);
+    }
+    async function get(id) {
+        const workflows = await loadWorkflows();
+        return workflows[id] ?? null;
+    }
+    async function select(id, selectOptions) {
+        const workflows = await loadWorkflows();
+        const fallback = selectOptions?.fallbackId ?? fallbackId;
+        const selected = workflows[id] ?? (fallback ? workflows[fallback] : null);
+        if (!selected) {
+            throw new Error(`No workflow found for id "${id}" and no fallback "${fallback}" workflow available`);
+        }
+        return selected;
+    }
+    async function refresh() {
+        workflowCache = null;
+        await loadWorkflows();
+    }
+    return {
+        list,
+        get,
+        select,
+        refresh,
+    };
+}

package/dist/registry/interface.d.ts

@@ -0,0 +1,12 @@
+import type { Edge, NodeMap, WorkflowDefinition } from "@kortyx/core";
+type AnyWorkflow = WorkflowDefinition<NodeMap, readonly Edge<string, string>[]>;
+export interface WorkflowRegistry {
+    list: () => Promise<AnyWorkflow[]>;
+    get: (id: string) => Promise<AnyWorkflow | null>;
+    select: (id: string, options?: {
+        fallbackId?: string;
+    }) => Promise<AnyWorkflow>;
+    refresh?: () => Promise<void>;
+}
+export {};
+//# sourceMappingURL=interface.d.ts.map

package/dist/registry/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/registry/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEtE,KAAK,WAAW,GAAG,kBAAkB,CAAC,OAAO,EAAE,SAAS,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;AAEhF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACnC,GAAG,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACjD,MAAM,EAAE,CACN,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,KAC9B,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B"}

package/dist/registry/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/state/build-initial-state.d.ts

@@ -0,0 +1,9 @@
+import type { GraphState, MemoryEnvelope } from "@kortyx/core";
+export interface InitialStateArgs<Config = unknown> {
+    input: string;
+    memory: MemoryEnvelope;
+    config: Config;
+    defaultWorkflowId?: string;
+}
+export declare function buildInitialGraphState<Config>({ input, memory, config, defaultWorkflowId, }: InitialStateArgs<Config>): Promise<GraphState>;
+//# sourceMappingURL=build-initial-state.d.ts.map

package/dist/state/build-initial-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-initial-state.d.ts","sourceRoot":"","sources":["../../src/state/build-initial-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAM/D,MAAM,WAAW,gBAAgB,CAAC,MAAM,GAAG,OAAO;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,EACnD,KAAK,EACL,MAAM,EACN,MAAM,EACN,iBAA+B,GAChC,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAWhD"}

package/dist/state/build-initial-state.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInitialGraphState = buildInitialGraphState;
+async function buildInitialGraphState({ input, memory, config, defaultWorkflowId = "frontdesk", }) {
+    return {
+        input,
+        lastNode: "__start__",
+        memory,
+        config: config,
+        conversationHistory: [],
+        currentWorkflow: memory.currentWorkflow || defaultWorkflowId,
+        awaitingHumanInput: false,
+    };
+}