@ellyco/agentic 0.1.0

package/dist/nodes/function-node.d.ts

@@ -0,0 +1,59 @@
+import { type NodeLike } from "./types";
+import { ContextLayer } from "../graphs";
+/**
+ * A simple node that executes a function and returns partial state updates.
+ * Useful for stateless transformations or computations within a graph.
+ *
+ * @class FunctionNode
+ * @template T - The state type
+ * @implements {NodeLike<T, Partial<T>>}
+ *
+ * @example
+ * ```typescript
+ * const doubleNode = new FunctionNode((state) => ({
+ *   count: state.count * 2
+ * }));
+ *
+ * // Or using the helper function
+ * const node = makeNode((state, context) => ({
+ *   result: state.input + " processed"
+ * }));
+ * ```
+ */
+export declare class FunctionNode<T extends Record<string, unknown>> implements NodeLike<T, Partial<T>> {
+    private readonly func;
+    /**
+     * Creates a new function node.
+     *
+     * @param {(state: T, context: ContextLayer) => Partial<T> | Promise<Partial<T>>} func
+     *   The function to execute. Can return state changes synchronously or asynchronously.
+     *   The function receives the current state and context layer.
+     */
+    constructor(func: (state: T, context: ContextLayer) => Partial<T> | Promise<Partial<T>>);
+    /**
+     * Executes the function and returns the state updates.
+     *
+     * @param {T} state - The current state
+     * @param {ContextLayer} context - The execution context
+     * @returns {Promise<Partial<T>>} Partial state updates from the function
+     */
+    run(state: T, context: ContextLayer): Promise<Partial<T>>;
+}
+/**
+ * Helper function to create a FunctionNode with type inference.
+ *
+ * @template T - The state type
+ * @param {(state: T, context: ContextLayer) => Partial<T> | Promise<Partial<T>>} func
+ *   The function to execute
+ * @returns {NodeLike<T, Partial<T>>} A node that can be used in a graph
+ *
+ * @example
+ * ```typescript
+ * const node = makeNode((state, context) => {
+ *   console.log("Executing node with state:", state);
+ *   return { processed: true };
+ * });
+ * ```
+ */
+export declare function makeNode<T extends Record<string, unknown>>(func: (state: T, context: ContextLayer) => Partial<T> | Promise<Partial<T>>): NodeLike<T, Partial<T>>;
+//# sourceMappingURL=function-node.d.ts.map

package/dist/nodes/function-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-node.d.ts","sourceRoot":"","sources":["../../src/nodes/function-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IASvF,OAAO,CAAC,QAAQ,CAAC,IAAI;IARzB;;;;;;OAMG;gBAEkB,IAAI,EAAE,CACnB,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,YAAY,KACpB,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAGzC;;;;;;OAMG;IACG,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;CAQlE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtD,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAC5E,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAEzB"}

package/dist/nodes/function-node.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionNode = void 0;
+exports.makeNode = makeNode;
+/**
+ * A simple node that executes a function and returns partial state updates.
+ * Useful for stateless transformations or computations within a graph.
+ *
+ * @class FunctionNode
+ * @template T - The state type
+ * @implements {NodeLike<T, Partial<T>>}
+ *
+ * @example
+ * ```typescript
+ * const doubleNode = new FunctionNode((state) => ({
+ *   count: state.count * 2
+ * }));
+ *
+ * // Or using the helper function
+ * const node = makeNode((state, context) => ({
+ *   result: state.input + " processed"
+ * }));
+ * ```
+ */
+class FunctionNode {
+    func;
+    /**
+     * Creates a new function node.
+     *
+     * @param {(state: T, context: ContextLayer) => Partial<T> | Promise<Partial<T>>} func
+     *   The function to execute. Can return state changes synchronously or asynchronously.
+     *   The function receives the current state and context layer.
+     */
+    constructor(func) {
+        this.func = func;
+    }
+    /**
+     * Executes the function and returns the state updates.
+     *
+     * @param {T} state - The current state
+     * @param {ContextLayer} context - The execution context
+     * @returns {Promise<Partial<T>>} Partial state updates from the function
+     */
+    async run(state, context) {
+        const response = this.func(state, context);
+        if (response instanceof Promise) {
+            return await response;
+        }
+        return response;
+    }
+}
+exports.FunctionNode = FunctionNode;
+/**
+ * Helper function to create a FunctionNode with type inference.
+ *
+ * @template T - The state type
+ * @param {(state: T, context: ContextLayer) => Partial<T> | Promise<Partial<T>>} func
+ *   The function to execute
+ * @returns {NodeLike<T, Partial<T>>} A node that can be used in a graph
+ *
+ * @example
+ * ```typescript
+ * const node = makeNode((state, context) => {
+ *   console.log("Executing node with state:", state);
+ *   return { processed: true };
+ * });
+ * ```
+ */
+function makeNode(func) {
+    return new FunctionNode(func);
+}
+//# sourceMappingURL=function-node.js.map

package/dist/nodes/function-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-node.js","sourceRoot":"","sources":["../../src/nodes/function-node.ts"],"names":[],"mappings":";;;AAuEA,4BAIC;AAxED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,YAAY;IASA;IARrB;;;;;;OAMG;IACH,YACqB,IAGoB;QAHpB,SAAI,GAAJ,IAAI,CAGgB;IACrC,CAAC;IAEL;;;;;;OAMG;IACH,KAAK,CAAC,GAAG,CAAC,KAAQ,EAAE,OAAqB;QACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC3C,IAAI,QAAQ,YAAY,OAAO,EAAE,CAAC;YAC9B,OAAO,MAAM,QAAQ,CAAC;QAC1B,CAAC;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;CACJ;AA9BD,oCA8BC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,QAAQ,CACpB,IAA2E;IAE3E,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;AAClC,CAAC"}

package/dist/nodes/index.d.ts

@@ -0,0 +1,4 @@
+export { FunctionNode, makeNode } from "./function-node";
+export { InterruptNode } from "./interrupt-node";
+export { type NodeLike } from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/nodes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC"}

package/dist/nodes/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterruptNode = exports.makeNode = exports.FunctionNode = void 0;
+var function_node_1 = require("./function-node");
+Object.defineProperty(exports, "FunctionNode", { enumerable: true, get: function () { return function_node_1.FunctionNode; } });
+Object.defineProperty(exports, "makeNode", { enumerable: true, get: function () { return function_node_1.makeNode; } });
+var interrupt_node_1 = require("./interrupt-node");
+Object.defineProperty(exports, "InterruptNode", { enumerable: true, get: function () { return interrupt_node_1.InterruptNode; } });
+//# sourceMappingURL=index.js.map

package/dist/nodes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/nodes/index.ts"],"names":[],"mappings":";;;AAAA,iDAAyD;AAAhD,6GAAA,YAAY,OAAA;AAAE,yGAAA,QAAQ,OAAA;AAC/B,mDAAiD;AAAxC,+GAAA,aAAa,OAAA"}

package/dist/nodes/interrupt-node.d.ts

@@ -0,0 +1,51 @@
+import { NodeLike } from "./types";
+import { ContextLayer } from "../graphs";
+/**
+ * A node that interrupts graph execution and returns control to the caller.
+ * Useful for handling user input, human-in-the-loop workflows, or pausing execution.
+ *
+ * When resumed, the graph will continue from after this node if the resumeFrom
+ * cursor indicates this node was the interruption point.
+ *
+ * @class InterruptNode
+ * @template T - The state type
+ * @implements {NodeLike<T, Partial<T>>}
+ *
+ * @example
+ * ```typescript
+ * // Interrupt for user confirmation
+ * const confirmNode = new InterruptNode("Please confirm the action");
+ *
+ * // Graph execution
+ * const result = await graph.invoke(state);
+ * if (result.exitReason === "interrupt") {
+ *   console.log("Paused:", result.exitMessage);
+ *   // Get user input...
+ *   // Resume with: await graph.invoke(result.state, { resumeFrom: result.cursor });
+ * }
+ * ```
+ */
+export declare class InterruptNode<T extends Record<string, unknown>> implements NodeLike<T> {
+    private readonly message?;
+    /**
+     * Creates an interrupt node.
+     *
+     * @param {string} [message] - Optional message to send when interrupting
+     */
+    constructor(message?: string | undefined);
+    /**
+     * Executes the interrupt.
+     * If resuming from a previous interrupt, marks the execution as resumed.
+     * Otherwise, marks the runtime as interrupted with an optional message.
+     *
+     * @param {T} state - The current state (unchanged by this node)
+     * @param {ContextLayer} context - The execution context
+     * @returns {Promise<Partial<T>>} Empty partial state (this node doesn't modify state)
+     *
+     * @remarks
+     * This node returns an empty object as it doesn't modify state.
+     * The actual interruption is signaled through the RuntimeContext.
+     */
+    run(state: T, context: ContextLayer): Promise<Partial<T>>;
+}
+//# sourceMappingURL=interrupt-node.d.ts.map

package/dist/nodes/interrupt-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt-node.d.ts","sourceRoot":"","sources":["../../src/nodes/interrupt-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IAMpE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IALrC;;;;OAIG;gBAC0B,OAAO,CAAC,EAAE,MAAM,YAAA;IAE7C;;;;;;;;;;;;OAYG;IACG,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;CAUlE"}

package/dist/nodes/interrupt-node.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterruptNode = void 0;
+/**
+ * A node that interrupts graph execution and returns control to the caller.
+ * Useful for handling user input, human-in-the-loop workflows, or pausing execution.
+ *
+ * When resumed, the graph will continue from after this node if the resumeFrom
+ * cursor indicates this node was the interruption point.
+ *
+ * @class InterruptNode
+ * @template T - The state type
+ * @implements {NodeLike<T, Partial<T>>}
+ *
+ * @example
+ * ```typescript
+ * // Interrupt for user confirmation
+ * const confirmNode = new InterruptNode("Please confirm the action");
+ *
+ * // Graph execution
+ * const result = await graph.invoke(state);
+ * if (result.exitReason === "interrupt") {
+ *   console.log("Paused:", result.exitMessage);
+ *   // Get user input...
+ *   // Resume with: await graph.invoke(result.state, { resumeFrom: result.cursor });
+ * }
+ * ```
+ */
+class InterruptNode {
+    message;
+    /**
+     * Creates an interrupt node.
+     *
+     * @param {string} [message] - Optional message to send when interrupting
+     */
+    constructor(message) {
+        this.message = message;
+    }
+    /**
+     * Executes the interrupt.
+     * If resuming from a previous interrupt, marks the execution as resumed.
+     * Otherwise, marks the runtime as interrupted with an optional message.
+     *
+     * @param {T} state - The current state (unchanged by this node)
+     * @param {ContextLayer} context - The execution context
+     * @returns {Promise<Partial<T>>} Empty partial state (this node doesn't modify state)
+     *
+     * @remarks
+     * This node returns an empty object as it doesn't modify state.
+     * The actual interruption is signaled through the RuntimeContext.
+     */
+    async run(state, context) {
+        // InterruptNode assumes that if a resumeFrom is provided, it's because this node originally called it.
+        // In that case, we don't need to interrupt the state machine at this spot again.
+        if (context.runtime.resuming) {
+            context.runtime.markResumed();
+        }
+        else {
+            context.runtime.markInterrupted(this.message);
+        }
+        return {};
+    }
+}
+exports.InterruptNode = InterruptNode;
+//# sourceMappingURL=interrupt-node.js.map

package/dist/nodes/interrupt-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt-node.js","sourceRoot":"","sources":["../../src/nodes/interrupt-node.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAa,aAAa;IAMO;IAL7B;;;;OAIG;IACH,YAA6B,OAAgB;QAAhB,YAAO,GAAP,OAAO,CAAS;IAAI,CAAC;IAElD;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,GAAG,CAAC,KAAQ,EAAE,OAAqB;QACrC,uGAAuG;QACvG,iFAAiF;QACjF,IAAI,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;YAC3B,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;QAClC,CAAC;aAAM,CAAC;YACJ,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,EAAE,CAAC;IACd,CAAC;CACJ;AA/BD,sCA+BC"}

package/dist/nodes/model-node.d.ts

@@ -0,0 +1,72 @@
+import { ModelMessages } from "../messages";
+import { BaseModel, StructuredOutputWrapper } from "../models/BaseModel";
+import { NodeLike } from "./types";
+import { ContextLayer } from "../graphs/runtime-context";
+import { TypedKeys } from "../types";
+/**
+ * Helper type to extract keys from an object that have ModelMessages[] values.
+ */
+type MessagesKeys<T> = TypedKeys<T, ModelMessages[]>;
+/**
+ * Configuration for messages provided through a function.
+ */
+interface ConstructedMessages<T extends Record<string, unknown>> {
+    messages: (state: T, context: ContextLayer) => ModelMessages[];
+}
+/**
+ * Configuration for messages provided through a state path.
+ */
+interface MessagesPath<T> {
+    messages: MessagesKeys<T>;
+}
+/**
+ * Settings for a ModelNode specifying where to get messages and where to store output.
+ */
+type ModelNodeSettings<T extends Record<string, unknown>> = {
+    output: keyof T;
+} & (ConstructedMessages<T> | MessagesPath<T>);
+/**
+ * A node that invokes an AI model and stores the response in the state.
+ * Can be configured to either construct messages dynamically or read from state.
+ *
+ * @class ModelNode
+ * @template T - The state type
+ * @implements {NodeLike<T, Partial<T>>}
+ *
+ * @example
+ * ```typescript
+ * // With messages from a function
+ * const node = new ModelNode(model, {
+ *   messages: (state, context) => [new UserMessage(state.input)],
+ *   output: "modelResponse"
+ * });
+ *
+ * // With messages from state
+ * const node = new ModelNode(model, {
+ *   messages: "conversationMessages",
+ *   output: "modelResponse"
+ * });
+ * ```
+ */
+export declare class ModelNode<T extends Record<string, unknown>> implements NodeLike<T> {
+    private readonly model;
+    private readonly settings;
+    /**
+     * Creates a new model node.
+     *
+     * @param {BaseModel | StructuredOutputWrapper<any>} model - The model to invoke
+     * @param {ModelNodeSettings<T>} settings - Configuration for message source and output location
+     */
+    constructor(model: BaseModel | StructuredOutputWrapper<any>, settings: ModelNodeSettings<T>);
+    /**
+     * Runs the model with configured messages and stores the response in state.
+     *
+     * @param {T} state - The current state
+     * @param {ContextLayer} context - The execution context
+     * @returns {Promise<Partial<T>>} Partial state containing the model's response
+     * @throws {Error} If messages path is specified but not found in state
+     */
+    run(state: T, context: ContextLayer): Promise<Partial<T>>;
+}
+export {};
+//# sourceMappingURL=model-node.d.ts.map

package/dist/nodes/model-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-node.d.ts","sourceRoot":"","sources":["../../src/nodes/model-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAcrC;;GAEG;AACH,KAAK,YAAY,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC;AAErD;;GAEG;AACH,UAAU,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC3D,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,KAAK,aAAa,EAAE,CAAC;CAClE;AAED;;GAEG;AACH,UAAU,YAAY,CAAC,CAAC;IACpB,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;CAC7B;AAED;;GAEG;AACH,KAAK,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACpD;IAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACjB,CAAC,mBAAmB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IAQxE,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAR7B;;;;;OAKG;gBAEkB,KAAK,EAAE,SAAS,GAAG,uBAAuB,CAAC,GAAG,CAAC,EAC/C,QAAQ,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAGnD;;;;;;;OAOG;IACG,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;CAkBlE"}

package/dist/nodes/model-node.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelNode = void 0;
+const BaseModel_1 = require("../models/BaseModel");
+/**
+ * Type guard to check if a value is a function that returns messages.
+ *
+ * @private
+ * @param {any} value - Value to check
+ * @returns {boolean} True if value is a messages-returning function
+ */
+function isMessagesFunction(value) {
+    return typeof value === "function";
+}
+/**
+ * A node that invokes an AI model and stores the response in the state.
+ * Can be configured to either construct messages dynamically or read from state.
+ *
+ * @class ModelNode
+ * @template T - The state type
+ * @implements {NodeLike<T, Partial<T>>}
+ *
+ * @example
+ * ```typescript
+ * // With messages from a function
+ * const node = new ModelNode(model, {
+ *   messages: (state, context) => [new UserMessage(state.input)],
+ *   output: "modelResponse"
+ * });
+ *
+ * // With messages from state
+ * const node = new ModelNode(model, {
+ *   messages: "conversationMessages",
+ *   output: "modelResponse"
+ * });
+ * ```
+ */
+class ModelNode {
+    model;
+    settings;
+    /**
+     * Creates a new model node.
+     *
+     * @param {BaseModel | StructuredOutputWrapper<any>} model - The model to invoke
+     * @param {ModelNodeSettings<T>} settings - Configuration for message source and output location
+     */
+    constructor(model, settings) {
+        this.model = model;
+        this.settings = settings;
+    }
+    /**
+     * Runs the model with configured messages and stores the response in state.
+     *
+     * @param {T} state - The current state
+     * @param {ContextLayer} context - The execution context
+     * @returns {Promise<Partial<T>>} Partial state containing the model's response
+     * @throws {Error} If messages path is specified but not found in state
+     */
+    async run(state, context) {
+        let messages = [];
+        if (isMessagesFunction(this.settings.messages)) {
+            messages = this.settings.messages(state, context);
+        }
+        else {
+            const stateMessages = state[this.settings.messages];
+            if (!stateMessages || !Array.isArray(stateMessages)) {
+                throw new Error(`No Messages array found for key ${this.settings.messages}`);
+            }
+            messages = stateMessages;
+        }
+        if (this.model instanceof BaseModel_1.StructuredOutputWrapper) {
+            const output = await this.model.invoke(messages);
+            return { [this.settings.output]: output };
+        }
+        const response = await this.model.invoke(messages);
+        return { [this.settings.output]: response.messages };
+    }
+}
+exports.ModelNode = ModelNode;
+//# sourceMappingURL=model-node.js.map

package/dist/nodes/model-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-node.js","sourceRoot":"","sources":["../../src/nodes/model-node.ts"],"names":[],"mappings":";;;AACA,mDAAyE;AAMzE;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAoC,KAAU;IACrE,OAAO,OAAO,KAAK,KAAK,UAAU,CAAC;AACvC,CAAC;AA4BD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAa,SAAS;IAQG;IACA;IARrB;;;;;OAKG;IACH,YACqB,KAA+C,EAC/C,QAA8B;QAD9B,UAAK,GAAL,KAAK,CAA0C;QAC/C,aAAQ,GAAR,QAAQ,CAAsB;IAC/C,CAAC;IAEL;;;;;;;OAOG;IACH,KAAK,CAAC,GAAG,CAAC,KAAQ,EAAE,OAAqB;QACrC,IAAI,QAAQ,GAAoB,EAAE,CAAC;QACnC,IAAI,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7C,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACtD,CAAC;aAAM,CAAC;YACJ,MAAM,aAAa,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAmB,CAAC,CAAC;YAC/D,IAAI,CAAC,aAAa,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;gBAClD,MAAM,IAAI,KAAK,CAAC,mCAAmC,IAAI,CAAC,QAAQ,CAAC,QAAkB,EAAE,CAAC,CAAC;YAC3F,CAAC;YACD,QAAQ,GAAG,aAAgC,CAAC;QAChD,CAAC;QACD,IAAI,IAAI,CAAC,KAAK,YAAY,mCAAuB,EAAE,CAAC;YAChD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACjD,OAAO,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,EAAgB,CAAC;QAC5D,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACnD,OAAO,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,QAAQ,EAAgB,CAAC;IACvE,CAAC;CACJ;AAtCD,8BAsCC"}

package/dist/nodes/types.d.ts

@@ -0,0 +1,5 @@
+import { ContextLayer } from "../graphs/runtime-context";
+export interface NodeLike<I extends Record<string, unknown>, O extends Record<string, unknown> = Partial<I>> {
+    run(state: I, context: ContextLayer): Promise<O>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/nodes/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IACvG,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACpD"}

package/dist/nodes/types.js

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

package/dist/nodes/types.js.map

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

package/dist/tools.d.ts

@@ -0,0 +1,65 @@
+import * as z from "zod";
+/**
+ * Defines the structure for a tool that can be used by AI models.
+ *
+ * @template T - The input type for the tool, validated against the schema
+ * @property {string} name - Unique identifier for the tool
+ * @property {string} [description] - Human-readable description of what the tool does
+ * @property {z.ZodSchema<T>} schema - Zod schema that validates the tool's input parameters
+ */
+export interface ToolDefinition<T = object> {
+    name: string;
+    description?: string;
+    schema: z.ZodSchema<T>;
+}
+/**
+ * Creates a tool definition with validation schema.
+ * Used to declare what tools are available to AI models.
+ *
+ * @template T - The input parameter type
+ * @param {string} name - Unique identifier for the tool
+ * @param {string} description - Description of the tool's purpose and behavior
+ * @param {z.ZodSchema<T>} schema - Zod schema for validating input parameters
+ * @returns {ToolDefinition<T>} A tool definition object
+ *
+ * @example
+ * ```typescript
+ * const searchTool = defineTool(
+ *   "search",
+ *   "Search the web for information",
+ *   z.object({ query: z.string() })
+ * );
+ * ```
+ */
+export declare function defineTool<T>(name: string, description: string, schema: z.ZodSchema<T>): ToolDefinition<T>;
+/**
+ * Internal interface extending ToolDefinition with the actual implementation function.
+ *
+ * @template T - The input type for the tool
+ * @template K - The output type returned by the tool function
+ */
+interface ToolImplementation<T, K> extends ToolDefinition<T> {
+    func: (input: T) => K | Promise<K>;
+}
+/**
+ * Creates a complete tool implementation by combining a tool definition with its function.
+ *
+ * @template T - The input parameter type
+ * @template K - The return type of the tool function
+ * @param {ToolDefinition<T>} toolDefinition - The tool definition created with defineTool()
+ * @param {(input: T) => K | Promise<K>} func - The function that implements the tool's behavior
+ * @returns {ToolImplementation<T, K>} A complete tool with both definition and implementation
+ *
+ * @example
+ * ```typescript
+ * const searchTool = tool(
+ *   defineTool("search", "Search the web", z.object({ query: z.string() })),
+ *   async (input) => {
+ *     return await fetch(`https://api.search.com?q=${input.query}`);
+ *   }
+ * );
+ * ```
+ */
+export declare function tool<T, K>(toolDefinition: ToolDefinition<T>, func: (input: T) => K | Promise<K>): ToolImplementation<T, K>;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,MAAM;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EACxB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GACvB,cAAc,CAAC,CAAC,CAAC,CAMnB;AAED;;;;;GAKG;AACH,UAAU,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACxD,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EACrB,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,EACjC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACnC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAK1B"}

package/dist/tools.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTool = defineTool;
+exports.tool = tool;
+/**
+ * Creates a tool definition with validation schema.
+ * Used to declare what tools are available to AI models.
+ *
+ * @template T - The input parameter type
+ * @param {string} name - Unique identifier for the tool
+ * @param {string} description - Description of the tool's purpose and behavior
+ * @param {z.ZodSchema<T>} schema - Zod schema for validating input parameters
+ * @returns {ToolDefinition<T>} A tool definition object
+ *
+ * @example
+ * ```typescript
+ * const searchTool = defineTool(
+ *   "search",
+ *   "Search the web for information",
+ *   z.object({ query: z.string() })
+ * );
+ * ```
+ */
+function defineTool(name, description, schema) {
+    return {
+        name,
+        description,
+        schema,
+    };
+}
+/**
+ * Creates a complete tool implementation by combining a tool definition with its function.
+ *
+ * @template T - The input parameter type
+ * @template K - The return type of the tool function
+ * @param {ToolDefinition<T>} toolDefinition - The tool definition created with defineTool()
+ * @param {(input: T) => K | Promise<K>} func - The function that implements the tool's behavior
+ * @returns {ToolImplementation<T, K>} A complete tool with both definition and implementation
+ *
+ * @example
+ * ```typescript
+ * const searchTool = tool(
+ *   defineTool("search", "Search the web", z.object({ query: z.string() })),
+ *   async (input) => {
+ *     return await fetch(`https://api.search.com?q=${input.query}`);
+ *   }
+ * );
+ * ```
+ */
+function tool(toolDefinition, func) {
+    return {
+        ...toolDefinition,
+        func,
+    };
+}
+//# sourceMappingURL=tools.js.map

package/dist/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":";;AAmCA,gCAUC;AA+BD,oBAQC;AApED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,UAAU,CACtB,IAAY,EACZ,WAAmB,EACnB,MAAsB;IAEtB,OAAO;QACH,IAAI;QACJ,WAAW;QACX,MAAM;KACT,CAAC;AACN,CAAC;AAYD;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,IAAI,CAChB,cAAiC,EACjC,IAAkC;IAElC,OAAO;QACH,GAAG,cAAc;QACjB,IAAI;KACP,CAAC;AACN,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Utility type that extracts keys from an object where the value matches a specific type.
+ *
+ * @template O - The object type to extract keys from
+ * @template T - The type to match against object values
+ * @returns A union of keys from O where the value type extends T
+ *
+ * @example
+ * ```typescript
+ * type Obj = { a: string; b: number; c: string };
+ * type StringKeys = TypedKeys<Obj, string>; // 'a' | 'c'
+ * ```
+ */
+export type TypedKeys<O, T> = {
+    [K in keyof O]: O[K] extends T ? K : never;
+}[keyof O];
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CAC7C,CAAC,MAAM,CAAC,CAAC,CAAC"}

package/dist/types.js

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

package/dist/types.js.map

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