@graph-compose/core 1.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/types/nodes/tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBzB,CAAC;AAGH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQzB,CAAC;AAGH,eAAO,MAAM,mBAAmB,qBAE9B,CAAC;AAGH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1B,CAAC;AAGH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW1B,CAAC;AAGH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQvB,CAAC;AACL,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/types/nodes/tools.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolNodeSchema = exports.GraphToolSchema = exports.GraphNodeSchema = exports.GraphNodeTypeSchema = exports.HttpToolSchema = exports.BaseToolSchema = void 0;
+// Remove import from index
+// import { NodeSchema } from ".";
+// Import directly from specific files
+const zod_1 = require("zod");
+const config_1 = require("../config");
+const http_1 = require("../config/http");
+const http_2 = require("./http");
+// Base tool configuration
+exports.BaseToolSchema = zod_1.z.object({
+    id: zod_1.z.string().openapi({
+        description: "A unique identifier for this tool within the workflow's tool collection.",
+        example: "get_weather_api_tool",
+    }),
+    description: zod_1.z.string().optional().openapi({
+        description: "An optional description of the tool's purpose, used by the Agent to decide when to use it.",
+        example: "Fetches the current weather for a given location.",
+    }),
+    type: zod_1.z.enum(["http", "graph"]).openapi({
+        description: "The type of tool - either a single HTTP endpoint or a graph of nodes",
+    }),
+    activityConfig: config_1.ActivityConfigSchema.optional(),
+});
+// HTTP-based tool (current implementation)
+exports.HttpToolSchema = exports.BaseToolSchema.extend({
+    type: zod_1.z.literal("http"),
+    http: http_1.HTTPConfigSchema,
+}).openapi({
+    ref: "HttpTool",
+    description: "Defines a tool that makes a single HTTP request. \n\nTools are used by Agent nodes to interact with external services or perform specific actions. They are defined separately (e.g., under a dedicated 'tools' key) so they can be called by multiple agents. \n\nNote: The structure of an HTTP Tool is very similar to a standard HTTP Node.",
+    "x-tags": ["Tools"],
+});
+// First, define what types of nodes can be in a graph tool
+exports.GraphNodeTypeSchema = zod_1.z.enum(["http"]).openapi({
+    description: "The types of nodes that can be included in a graph tool",
+});
+// Define the node reference schema
+exports.GraphNodeSchema = http_2.HttpNodeSchema.openapi({
+    ref: "GraphNode",
+    description: "A reference to a node within a graph tool",
+});
+// Update the GraphToolSchema to use the simpler node reference
+exports.GraphToolSchema = exports.BaseToolSchema.extend({
+    type: zod_1.z.literal("graph"),
+    graph: zod_1.z.object({
+        nodes: zod_1.z.array(exports.GraphNodeSchema),
+        context: zod_1.z.record(zod_1.z.any()).optional(),
+    }),
+}).openapi({
+    ref: "GraphTool",
+    description: "Defines a tool composed of multiple connected steps (a sub-graph). \n\nTools are used by Agent nodes to perform multi-step operations. They are defined separately (e.g., under a dedicated 'tools' key) so they can be called by multiple agents. \n\nNote: The nodes within a Graph Tool are structured similarly to standard workflow nodes.",
+    "x-tags": ["Tools"],
+});
+// Combined tool schema using discriminated union
+exports.ToolNodeSchema = zod_1.z
+    .discriminatedUnion("type", [exports.HttpToolSchema, exports.GraphToolSchema])
+    .openapi({
+    ref: "ToolNode",
+    title: "ToolNode",
+    description: "Represents a collection of available tools (HTTP or Graph-based) that can be invoked by Agent nodes within the workflow. \n\nTools are defined separately (e.g., under a dedicated 'tools' key) so they can potentially be called by multiple different agents. Note that individual tools are structured very similarly to standard nodes (like HTTP nodes). \n\nThis collection can be left empty if no agents requiring tools are present in the workflow.",
+    "x-tags": ["Tools"],
+});
+//# sourceMappingURL=tools.js.map

package/dist/types/nodes/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../src/types/nodes/tools.ts"],"names":[],"mappings":";;;AAAA,2BAA2B;AAC3B,kCAAkC;AAClC,sCAAsC;AACtC,6BAAwB;AACxB,sCAAiD;AACjD,yCAAkD;AAClD,iCAAwC;AAExC,0BAA0B;AACb,QAAA,cAAc,GAAG,OAAC,CAAC,MAAM,CAAC;IACrC,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC;QACrB,WAAW,EACT,0EAA0E;QAC5E,OAAO,EAAE,sBAAsB;KAChC,CAAC;IACF,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC;QACzC,WAAW,EACT,4FAA4F;QAC9F,OAAO,EAAE,mDAAmD;KAC7D,CAAC;IACF,IAAI,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;QACtC,WAAW,EACT,sEAAsE;KACzE,CAAC;IACF,cAAc,EAAE,6BAAoB,CAAC,QAAQ,EAAE;CAChD,CAAC,CAAC;AAEH,2CAA2C;AAC9B,QAAA,cAAc,GAAG,sBAAc,CAAC,MAAM,CAAC;IAClD,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IACvB,IAAI,EAAE,uBAAgB;CACvB,CAAC,CAAC,OAAO,CAAC;IACT,GAAG,EAAE,UAAU;IACf,WAAW,EACT,iVAAiV;IACnV,QAAQ,EAAE,CAAC,OAAO,CAAC;CACpB,CAAC,CAAC;AAEH,2DAA2D;AAC9C,QAAA,mBAAmB,GAAG,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;IAC1D,WAAW,EAAE,yDAAyD;CACvE,CAAC,CAAC;AAEH,mCAAmC;AACtB,QAAA,eAAe,GAAG,qBAAc,CAAC,OAAO,CAAC;IACpD,GAAG,EAAE,WAAW;IAChB,WAAW,EAAE,2CAA2C;CACzD,CAAC,CAAC;AAEH,+DAA+D;AAClD,QAAA,eAAe,GAAG,sBAAc,CAAC,MAAM,CAAC;IACnD,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,OAAO,CAAC;IACxB,KAAK,EAAE,OAAC,CAAC,MAAM,CAAC;QACd,KAAK,EAAE,OAAC,CAAC,KAAK,CAAC,uBAAe,CAAC;QAC/B,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE;KACtC,CAAC;CACH,CAAC,CAAC,OAAO,CAAC;IACT,GAAG,EAAE,WAAW;IAChB,WAAW,EACT,iVAAiV;IACnV,QAAQ,EAAE,CAAC,OAAO,CAAC;CACpB,CAAC,CAAC;AAEH,iDAAiD;AACpC,QAAA,cAAc,GAAG,OAAC;KAC5B,kBAAkB,CAAC,MAAM,EAAE,CAAC,sBAAc,EAAE,uBAAe,CAAC,CAAC;KAC7D,OAAO,CAAC;IACP,GAAG,EAAE,UAAU;IACf,KAAK,EAAE,UAAU;IACjB,WAAW,EACT,+bAA+b;IACjc,QAAQ,EAAE,CAAC,OAAO,CAAC;CACpB,CAAC,CAAC"}

package/dist/types/primitives/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./shared";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/primitives/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/primitives/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/types/primitives/index.js

@@ -0,0 +1,18 @@
+"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("./shared"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/primitives/index.js.map

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

package/dist/types/primitives/shared.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const TemplatedStringSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const JsonataObjectSchema: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodEffects<z.ZodString, string, string>]>;
+export type JsonataObject = z.infer<typeof JsonataObjectSchema>;
+export declare const JsonataExpressionSchema: z.ZodString;
+export type JsonataExpression = z.infer<typeof JsonataExpressionSchema>;
+export declare const JsonataParamSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export type JsonataParam = z.infer<typeof JsonataParamSchema>;
+export declare const durationRegex: RegExp;
+export declare const DurationSchema: z.ZodEffects<z.ZodString, string, string>;
+export type Duration = z.infer<typeof DurationSchema>;
+interface DurationBounds {
+    min?: string;
+    max?: string;
+}
+/**
+ * Factory function to create a Zod schema for duration string with optional min/max bounds.
+ */
+export declare function createBoundedDurationSchema({ min, max, }?: DurationBounds): z.ZodEffects<typeof DurationSchema, Duration, Duration>;
+export {};
+//# sourceMappingURL=shared.d.ts.map

package/dist/types/primitives/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/types/primitives/shared.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,qBAAqB,2CAO7B,CAAC;AAGN,eAAO,MAAM,mBAAmB,6FAG9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,uBAAuB,aAGlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,kBAAkB,uCAAgD,CAAC;AAEhF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAI9D,eAAO,MAAM,aAAa,QACmG,CAAC;AAwB9H,eAAO,MAAM,cAAc,2CAqBvB,CAAC;AAEL,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,UAAU,cAAc;IACtB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,EAC1C,GAAG,EACH,GAAG,GACJ,GAAE,cAAmB,GAAG,CAAC,CAAC,UAAU,CACnC,OAAO,cAAc,EACrB,QAAQ,EACR,QAAQ,CACT,CA+CA"}

package/dist/types/primitives/shared.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurationSchema = exports.durationRegex = exports.JsonataParamSchema = exports.JsonataExpressionSchema = exports.JsonataObjectSchema = exports.TemplatedStringSchema = void 0;
+exports.createBoundedDurationSchema = createBoundedDurationSchema;
+const ms_1 = __importDefault(require("ms"));
+const zod_1 = require("zod");
+const template_1 = require("../../utils/template");
+// Schema for strings that must contain JSONata expressions
+exports.TemplatedStringSchema = zod_1.z
+    .string()
+    .regex(/.*\{\{.*\}\}.*/, {
+    message: "String must contain a JSONata expression wrapped in {{ }}",
+})
+    .refine(template_1.validateTemplateExpression, val => ({
+    message: `Invalid JSONata template expression in: ${val}`,
+}));
+// Updated to require template expressions in strings
+exports.JsonataObjectSchema = zod_1.z.union([
+    zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+    exports.TemplatedStringSchema,
+]);
+exports.JsonataExpressionSchema = zod_1.z.string().regex(/^\{\{(.*)\}\}$/, {
+    message: "Expression must be wrapped in double curly braces (e.g. '{{your.expression}}')",
+});
+exports.JsonataParamSchema = zod_1.z.record(zod_1.z.string(), exports.JsonataExpressionSchema);
+// Regex to validate duration strings like "1s", "5 minutes", "2.5hrs"
+// This is kept for basic string format check before passing to ms()
+exports.durationRegex = /^(\d*\.?\d+)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)$/i;
+// Helper to convert a pre-validated duration string to milliseconds
+// It assumes the input string format is already validated by DurationSchema
+function durationStringToMs(duration) {
+    try {
+        // Use ms() which is robust. We expect it to succeed here.
+        const valueMs = (0, ms_1.default)(duration);
+        if (typeof valueMs !== "number" || valueMs < 0) {
+            // Should ideally not happen if schema validation works
+            return null;
+        }
+        return valueMs;
+    }
+    catch (error) {
+        // Should not happen if the schema validation catches format errors
+        console.error(`Error parsing already validated duration string: ${duration}`, error);
+        return null;
+    }
+}
+// Base schema for duration string, validates format using 'ms' logic
+exports.DurationSchema = zod_1.z
+    .string()
+    .refine((value) => {
+    try {
+        const result = (0, ms_1.default)(value);
+        // Ensure ms() returned a non-negative number
+        return typeof result === "number" && result >= 0;
+    }
+    catch {
+        return false; // ms() throws on invalid format
+    }
+}, {
+    message: "Invalid duration format. Must be a string parseable by 'ms' (e.g., '30s', '5m', '1h').",
+})
+    .openapi({
+    description: "Duration as a string parseable by the 'ms' library (e.g., '30 seconds', '5 minutes', '1 day')",
+    example: "5 minutes",
+});
+/**
+ * Factory function to create a Zod schema for duration string with optional min/max bounds.
+ */
+function createBoundedDurationSchema({ min, max, } = {}) {
+    // Pre-parse and validate bounds during schema creation
+    const minMs = min ? durationStringToMs(min) : null;
+    const maxMs = max ? durationStringToMs(max) : null;
+    if (min && minMs === null) {
+        throw new Error(`Invalid minimum duration format: ${min}`);
+    }
+    if (max && maxMs === null) {
+        throw new Error(`Invalid maximum duration format: ${max}`);
+    }
+    if (minMs !== null && maxMs !== null && minMs > maxMs) {
+        throw new Error(`Minimum duration (${min}) cannot be greater than maximum duration (${max})`);
+    }
+    // Refine the base string schema which already guarantees valid format
+    return exports.DurationSchema.refine(value => {
+        const valueMs = durationStringToMs(value);
+        // Format is already valid due to base schema, just check bounds
+        if (valueMs === null)
+            return false; // Should not happen, defensive check
+        if (minMs !== null && valueMs < minMs)
+            return false;
+        if (maxMs !== null && valueMs > maxMs)
+            return false;
+        return true;
+    }, value => {
+        // Constructing the error message based on which bound was violated
+        const valueMs = durationStringToMs(value);
+        let message = "Duration is out of bounds."; // Default/fallback
+        if (minMs !== null && valueMs !== null && valueMs < minMs) {
+            message = `Duration must be at least ${min}.`;
+        }
+        if (maxMs !== null && valueMs !== null && valueMs > maxMs) {
+            message = `Duration must be no more than ${max}.`;
+        }
+        return { message };
+    }).openapi({
+        // Update OpenAPI description for the bounded schema
+        description: `Duration as a string. ${min ? `Min: ${min}.` : ""} ${max ? `Max: ${max}.` : ""}`.trim(),
+        example: min ?? max ?? "30s",
+    });
+}
+//# sourceMappingURL=shared.js.map

package/dist/types/primitives/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../../src/types/primitives/shared.ts"],"names":[],"mappings":"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"}

package/dist/types/results/agent.d.ts

@@ -0,0 +1,156 @@
+import { z } from "zod";
+/**
+ * Schema for the payload sent in the body of an agent request
+ */
+export declare const AgentRequestPayloadSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    iteration: z.ZodNumber;
+    toolCalls: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodString;
+        agentIterationNumber: z.ZodNumber;
+        toolPayload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        allResults: z.ZodObject<{
+            context: z.ZodRecord<z.ZodString, z.ZodAny>;
+            results: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            httpStatuses: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            context: Record<string, any>;
+            results: Record<string, any>;
+            httpStatuses: Record<string, any>;
+        }, {
+            context: Record<string, any>;
+            results?: Record<string, any> | undefined;
+            httpStatuses?: Record<string, any> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        toolId: string;
+        agentIterationNumber: number;
+        toolPayload: Record<string, unknown>;
+        allResults: {
+            context: Record<string, any>;
+            results: Record<string, any>;
+            httpStatuses: Record<string, any>;
+        };
+    }, {
+        toolId: string;
+        agentIterationNumber: number;
+        toolPayload: Record<string, unknown>;
+        allResults: {
+            context: Record<string, any>;
+            results?: Record<string, any> | undefined;
+            httpStatuses?: Record<string, any> | undefined;
+        };
+    }>, "many">;
+    toolResults: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodString;
+        success: z.ZodBoolean;
+        result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        timestamp: z.ZodNumber;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodNumber;
+            message: z.ZodString;
+            details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            code: number;
+            message: string;
+            details: Record<string, unknown>;
+        }, {
+            code: number;
+            message: string;
+            details: Record<string, unknown>;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        toolId: string;
+        success: boolean;
+        result: Record<string, unknown> | null;
+        timestamp: number;
+        error?: {
+            code: number;
+            message: string;
+            details: Record<string, unknown>;
+        } | undefined;
+    }, {
+        toolId: string;
+        success: boolean;
+        result: Record<string, unknown> | null;
+        timestamp: number;
+        error?: {
+            code: number;
+            message: string;
+            details: Record<string, unknown>;
+        } | undefined;
+    }>, "many">;
+    allResults: z.ZodObject<{
+        context: z.ZodRecord<z.ZodString, z.ZodAny>;
+        results: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        httpStatuses: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        context: Record<string, any>;
+        results: Record<string, any>;
+        httpStatuses: Record<string, any>;
+    }, {
+        context: Record<string, any>;
+        results?: Record<string, any> | undefined;
+        httpStatuses?: Record<string, any> | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    agentId: string;
+    iteration: number;
+    allResults: {
+        context: Record<string, any>;
+        results: Record<string, any>;
+        httpStatuses: Record<string, any>;
+    };
+    toolCalls: {
+        toolId: string;
+        agentIterationNumber: number;
+        toolPayload: Record<string, unknown>;
+        allResults: {
+            context: Record<string, any>;
+            results: Record<string, any>;
+            httpStatuses: Record<string, any>;
+        };
+    }[];
+    toolResults: {
+        toolId: string;
+        success: boolean;
+        result: Record<string, unknown> | null;
+        timestamp: number;
+        error?: {
+            code: number;
+            message: string;
+            details: Record<string, unknown>;
+        } | undefined;
+    }[];
+}, {
+    agentId: string;
+    iteration: number;
+    allResults: {
+        context: Record<string, any>;
+        results?: Record<string, any> | undefined;
+        httpStatuses?: Record<string, any> | undefined;
+    };
+    toolCalls: {
+        toolId: string;
+        agentIterationNumber: number;
+        toolPayload: Record<string, unknown>;
+        allResults: {
+            context: Record<string, any>;
+            results?: Record<string, any> | undefined;
+            httpStatuses?: Record<string, any> | undefined;
+        };
+    }[];
+    toolResults: {
+        toolId: string;
+        success: boolean;
+        result: Record<string, unknown> | null;
+        timestamp: number;
+        error?: {
+            code: number;
+            message: string;
+            details: Record<string, unknown>;
+        } | undefined;
+    }[];
+}>;
+export type AgentRequestPayload = z.infer<typeof AgentRequestPayloadSchema>;
+//# sourceMappingURL=agent.d.ts.map

package/dist/types/results/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/types/results/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4ClC,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/types/results/agent.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRequestPayloadSchema = void 0;
+const zod_1 = require("zod");
+const shared_1 = require("./shared");
+const tool_1 = require("./tool");
+/**
+ * Schema for the payload sent in the body of an agent request
+ */
+exports.AgentRequestPayloadSchema = zod_1.z
+    .object({
+    agentId: zod_1.z.string().openapi({
+        description: "The ID of the agent",
+        example: "search_agent",
+    }),
+    iteration: zod_1.z.number().openapi({
+        description: "The number of iterations the agent has performed",
+        example: 3,
+    }),
+    toolCalls: zod_1.z.array(tool_1.ToolHttpRequestSchema).openapi({
+        description: "The tool calls that the agent has made",
+        example: [],
+    }),
+    toolResults: zod_1.z.array(tool_1.ToolResultSchema).openapi({
+        description: "The results of the tools that have been executed so far",
+        example: [],
+    }),
+    allResults: shared_1.WorkflowResultsSchema.openapi({
+        description: "The results of all the nodes and tools that have been executed so far",
+        example: {
+            context: {},
+            results: {},
+            httpStatuses: {},
+        },
+    }),
+})
+    .openapi({
+    title: "Agent Request Payload",
+    description: `Request payload sent to an agent when it is invoked using POST. The agent will use this payload to determine what the next action is to take. 
+    
+    The agent must return a response that matches the AgentResponseContract.`,
+    example: {
+        agentId: "search_agent",
+        iteration: 1,
+        toolCalls: [],
+        toolResults: [],
+        allResults: {
+            context: {},
+            results: {},
+            httpStatuses: {},
+        },
+    },
+});
+//# sourceMappingURL=agent.js.map

package/dist/types/results/agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.js","sourceRoot":"","sources":["../../../src/types/results/agent.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,qCAAiD;AACjD,iCAAiE;AAEjE;;GAEG;AACU,QAAA,yBAAyB,GAAG,OAAC;KACvC,MAAM,CAAC;IACN,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC;QAC1B,WAAW,EAAE,qBAAqB;QAClC,OAAO,EAAE,cAAc;KACxB,CAAC;IACF,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC;QAC5B,WAAW,EAAE,kDAAkD;QAC/D,OAAO,EAAE,CAAC;KACX,CAAC;IACF,SAAS,EAAE,OAAC,CAAC,KAAK,CAAC,4BAAqB,CAAC,CAAC,OAAO,CAAC;QAChD,WAAW,EAAE,wCAAwC;QACrD,OAAO,EAAE,EAAE;KACZ,CAAC;IACF,WAAW,EAAE,OAAC,CAAC,KAAK,CAAC,uBAAgB,CAAC,CAAC,OAAO,CAAC;QAC7C,WAAW,EAAE,yDAAyD;QACtE,OAAO,EAAE,EAAE;KACZ,CAAC;IACF,UAAU,EAAE,8BAAqB,CAAC,OAAO,CAAC;QACxC,WAAW,EACT,uEAAuE;QACzE,OAAO,EAAE;YACP,OAAO,EAAE,EAAE;YACX,OAAO,EAAE,EAAE;YACX,YAAY,EAAE,EAAE;SACjB;KACF,CAAC;CACH,CAAC;KACD,OAAO,CAAC;IACP,KAAK,EAAE,uBAAuB;IAC9B,WAAW,EAAE;;6EAE4D;IACzE,OAAO,EAAE;QACP,OAAO,EAAE,cAAc;QACvB,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,EAAE;QACb,WAAW,EAAE,EAAE;QACf,UAAU,EAAE;YACV,OAAO,EAAE,EAAE;YACX,OAAO,EAAE,EAAE;YACX,YAAY,EAAE,EAAE;SACjB;KACF;CACF,CAAC,CAAC"}

package/dist/types/results/base.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const HTTPNodeResultSchema: z.ZodAny;
+export type HTTPNodeResult = z.infer<typeof HTTPNodeResultSchema>;
+//# sourceMappingURL=base.d.ts.map

package/dist/types/results/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/types/results/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB,UAM/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/types/results/base.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPNodeResultSchema = void 0;
+const zod_1 = require("zod");
+exports.HTTPNodeResultSchema = zod_1.z.any().openapi({
+    description: "The resulting `data` or `text` returned from the HTTP call.",
+    example: {
+        order_id: 123,
+        status: "success",
+    },
+});
+//# sourceMappingURL=base.js.map

package/dist/types/results/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../src/types/results/base.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,oBAAoB,GAAG,OAAC,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC;IAClD,WAAW,EAAE,6DAA6D;IAC1E,OAAO,EAAE;QACP,QAAQ,EAAE,GAAG;QACb,MAAM,EAAE,SAAS;KAClB;CACF,CAAC,CAAC"}

package/dist/types/results/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./agent";
+export * from "./base";
+export * from "./node";
+export * from "./shared";
+export * from "./source";
+export * from "./tool";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/results/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/results/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC"}

package/dist/types/results/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("./agent"), exports);
+__exportStar(require("./base"), exports);
+__exportStar(require("./node"), exports);
+__exportStar(require("./shared"), exports);
+__exportStar(require("./source"), exports);
+__exportStar(require("./tool"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/results/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/results/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,yCAAuB;AACvB,yCAAuB;AACvB,2CAAyB;AACzB,2CAAyB;AACzB,yCAAuB"}

package/dist/types/results/node.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { HTTPNodeResult } from "./base";
+import { AgentResult } from "./shared";
+export declare const NodeResultSchema: z.ZodUnion<[z.ZodAny, z.ZodObject<{
+    iterations: z.ZodNumber;
+    result: z.ZodAny;
+    toolCalls: z.ZodArray<z.ZodAny, "many">;
+    toolResults: z.ZodArray<z.ZodAny, "many">;
+    error: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    error: string | null;
+    iterations: number;
+    toolCalls: any[];
+    toolResults: any[];
+    result?: any;
+}, {
+    error: string | null;
+    iterations: number;
+    toolCalls: any[];
+    toolResults: any[];
+    result?: any;
+}>]>;
+export type NodeResult = {
+    result: HTTPNodeResult | AgentResult;
+    httpStatus: NodeHttpStatus;
+};
+export declare const NodeHttpStatusSchema: z.ZodNullable<z.ZodObject<{
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    statusCode: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    headers: Record<string, string>;
+    statusCode: number;
+}, {
+    headers: Record<string, string>;
+    statusCode: number;
+}>>;
+export type NodeHttpStatus = z.infer<typeof NodeHttpStatusSchema>;
+//# sourceMappingURL=node.d.ts.map

package/dist/types/results/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/types/results/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,cAAc,EAAwB,MAAM,QAAQ,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAqB,MAAM,UAAU,CAAC;AAE1D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;IAG3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,cAAc,GAAG,WAAW,CAAC;IACrC,UAAU,EAAE,cAAc,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;GAcpB,CAAC;AACd,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/types/results/node.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeHttpStatusSchema = exports.NodeResultSchema = void 0;
+const zod_1 = require("zod");
+const base_1 = require("./base");
+const shared_1 = require("./shared");
+exports.NodeResultSchema = zod_1.z.union([
+    base_1.HTTPNodeResultSchema,
+    shared_1.AgentResultSchema,
+]);
+exports.NodeHttpStatusSchema = zod_1.z
+    .object({
+    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).openapi({
+        description: "The HTTP headers returned from the HTTP call.",
+        example: {
+            "Content-Type": "application/json",
+            "X-Request-ID": "1234567890",
+        },
+    }),
+    statusCode: zod_1.z.number().openapi({
+        description: "The HTTP status code returned from the HTTP call.",
+        example: 200,
+    }),
+})
+    .nullable();
+//# sourceMappingURL=node.js.map

package/dist/types/results/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../src/types/results/node.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,iCAA8D;AAC9D,qCAA0D;AAE7C,QAAA,gBAAgB,GAAG,OAAC,CAAC,KAAK,CAAC;IACtC,2BAAoB;IACpB,0BAAiB;CAClB,CAAC,CAAC;AAOU,QAAA,oBAAoB,GAAG,OAAC;KAClC,MAAM,CAAC;IACN,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC;QAChD,WAAW,EAAE,+CAA+C;QAC5D,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB;YAClC,cAAc,EAAE,YAAY;SAC7B;KACF,CAAC;IACF,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC;QAC7B,WAAW,EAAE,mDAAmD;QAChE,OAAO,EAAE,GAAG;KACb,CAAC;CACH,CAAC;KACD,QAAQ,EAAE,CAAC"}