donobu 2.20.0 → 2.20.1

package/dist/models/CreateDonobuFlow.d.ts

@@ -1,68 +1,382 @@
-import { CustomTool } from './CustomTool';
 import { ProposedToolCall } from './ProposedToolCall';
-import { RunMode } from './FlowMetadata';
-import { JSONSchema7 } from 'json-schema';
-import { BrowserConfig } from './BrowserConfig';
-/**
- * This is the expected payload for a request to create a new DonobuFlow flow.
- */
-export type CreateDonobuFlow = {
-    /** The initial website to load */
-    readonly targetWebsite: string;
-    /**
-     * The overall objective to pursue; can only be omitted if `initialRunMode`
-     * has an effective value of `INSTRUCT` or `DETEMINISTIC`.
-     */
-    readonly overallObjective?: string;
-    /** The name for this flow; if present, must be fewer than 256 characters. */
-    readonly name?: string;
-    readonly browser?: BrowserConfig;
-    /**
-     * The names of environment variables to make available for use by the flow.
-     */
-    readonly envVars?: string[];
-    /**
-     * The URL to HTTP POST to when the flow completes. The body will contain a
-     * JSON object with single field, "id", of which is the ID of the flow that
-     * completed.
-     */
-    readonly callbackUrl?: string;
-    /**
-     * Custom tools to enable for this flow. Any tools specified here will be
-     * implicitly added to allowedTools.
-     */
-    readonly customTools?: CustomTool[];
-    /**
-     * The maximum number of times to iterate with the underlying GPT.
-     */
-    readonly maxIterations?: number;
-    /**
-     * The name of a specific GPT configuration to use. If the corresponding GPT
-     * configuration is not defined or unresolvable, the default flow agent
-     * configuration will be used.
-     **/
-    readonly gptConfigNameOverride?: string;
-    /** The default amount of time the Donobu flow agent's messaging for the user should show (in milliseconds). */
-    readonly defaultMessageDuration?: number;
-    /**
-     * The initial run mode of the flow. If not specified, defaults to
-     * AUTONOMOUS if gptPlatform is non-null, otherwise, defaults to INSTRUCT.
-     */
-    readonly initialRunMode?: RunMode;
-    /**
-     * Set to true if the in-browser control panel should be enabled.
-     * If the headless parameter is true, then this parameter is ignored.
-     */
-    readonly isControlPanelEnabled?: boolean;
-    /**
-     * If present and non-empty, will constrain the flow to only use these tools (by
-     * Tool.name()). If null or empty, then there are no constraints on the types of
-     * tools used. Note that all tools in customTools are implicitly added here.
-     */
-    readonly allowedTools?: string[];
-    /** An ordered series of tool calls to invoke when starting the flow. */
-    readonly toolCallsOnStart?: ProposedToolCall<any>[];
-    /** If non-null, the Donobu flow will attempt to save its result using this JSON-schema. */
-    readonly resultJsonSchema?: JSONSchema7;
-};
+import { z } from 'zod';
+export declare const CreateDonobuFlowSchema: z.ZodObject<{
+    targetWebsite: z.ZodString;
+    overallObjective: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    browser: z.ZodOptional<z.ZodObject<{
+        initialState: z.ZodOptional<z.ZodType<import("./BrowserStateFlowReference").BrowserStateReference, z.ZodTypeDef, import("./BrowserStateFlowReference").BrowserStateReference>>;
+        persistState: z.ZodOptional<z.ZodBoolean>;
+        using: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"device">;
+            deviceName: z.ZodOptional<z.ZodString>;
+            headless: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "device";
+            deviceName?: string | undefined;
+            headless?: boolean | undefined;
+        }, {
+            type: "device";
+            deviceName?: string | undefined;
+            headless?: boolean | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"remoteInstance">;
+            url: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "remoteInstance";
+            url: string;
+        }, {
+            type: "remoteInstance";
+            url: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"browserBase">;
+            sessionArgs: z.ZodObject<{
+                projectId: z.ZodString;
+                extensionId: z.ZodOptional<z.ZodString>;
+                browserSettings: z.ZodOptional<z.ZodObject<{
+                    context: z.ZodOptional<z.ZodObject<{
+                        id: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        id: string;
+                    }, {
+                        id: string;
+                    }>>;
+                    extensionId: z.ZodOptional<z.ZodString>;
+                    viewport: z.ZodOptional<z.ZodObject<{
+                        width: z.ZodNumber;
+                        height: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        width: number;
+                        height: number;
+                    }, {
+                        width: number;
+                        height: number;
+                    }>>;
+                    blockAds: z.ZodOptional<z.ZodBoolean>;
+                    solveCaptchas: z.ZodOptional<z.ZodBoolean>;
+                    advancedStealth: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                }, {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                }>>;
+                timeout: z.ZodOptional<z.ZodNumber>;
+                proxies: z.ZodOptional<z.ZodBoolean>;
+                region: z.ZodOptional<z.ZodString>;
+                userMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                projectId: string;
+                extensionId?: string | undefined;
+                browserSettings?: {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                } | undefined;
+                timeout?: number | undefined;
+                proxies?: boolean | undefined;
+                region?: string | undefined;
+                userMetadata?: Record<string, string> | undefined;
+            }, {
+                projectId: string;
+                extensionId?: string | undefined;
+                browserSettings?: {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                } | undefined;
+                timeout?: number | undefined;
+                proxies?: boolean | undefined;
+                region?: string | undefined;
+                userMetadata?: Record<string, string> | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "browserBase";
+            sessionArgs: {
+                projectId: string;
+                extensionId?: string | undefined;
+                browserSettings?: {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                } | undefined;
+                timeout?: number | undefined;
+                proxies?: boolean | undefined;
+                region?: string | undefined;
+                userMetadata?: Record<string, string> | undefined;
+            };
+        }, {
+            type: "browserBase";
+            sessionArgs: {
+                projectId: string;
+                extensionId?: string | undefined;
+                browserSettings?: {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                } | undefined;
+                timeout?: number | undefined;
+                proxies?: boolean | undefined;
+                region?: string | undefined;
+                userMetadata?: Record<string, string> | undefined;
+            };
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        using: {
+            type: "device";
+            deviceName?: string | undefined;
+            headless?: boolean | undefined;
+        } | {
+            type: "remoteInstance";
+            url: string;
+        } | {
+            type: "browserBase";
+            sessionArgs: {
+                projectId: string;
+                extensionId?: string | undefined;
+                browserSettings?: {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                } | undefined;
+                timeout?: number | undefined;
+                proxies?: boolean | undefined;
+                region?: string | undefined;
+                userMetadata?: Record<string, string> | undefined;
+            };
+        };
+        initialState?: import("./BrowserStateFlowReference").BrowserStateReference | undefined;
+        persistState?: boolean | undefined;
+    }, {
+        using: {
+            type: "device";
+            deviceName?: string | undefined;
+            headless?: boolean | undefined;
+        } | {
+            type: "remoteInstance";
+            url: string;
+        } | {
+            type: "browserBase";
+            sessionArgs: {
+                projectId: string;
+                extensionId?: string | undefined;
+                browserSettings?: {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                } | undefined;
+                timeout?: number | undefined;
+                proxies?: boolean | undefined;
+                region?: string | undefined;
+                userMetadata?: Record<string, string> | undefined;
+            };
+        };
+        initialState?: import("./BrowserStateFlowReference").BrowserStateReference | undefined;
+        persistState?: boolean | undefined;
+    }>>;
+    envVars: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    callbackUrl: z.ZodOptional<z.ZodString>;
+    customTools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        javascript: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        javascript: string;
+    }, {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        javascript: string;
+    }>, "many">>;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+    gptConfigNameOverride: z.ZodOptional<z.ZodString>;
+    defaultMessageDuration: z.ZodOptional<z.ZodNumber>;
+    initialRunMode: z.ZodOptional<z.ZodEnum<["AUTONOMOUS", "INSTRUCT", "DETERMINISTIC"]>>;
+    isControlPanelEnabled: z.ZodOptional<z.ZodBoolean>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    toolCallsOnStart: z.ZodOptional<z.ZodArray<z.ZodType<ProposedToolCall<any>, z.ZodTypeDef, ProposedToolCall<any>>, "many">>;
+    resultJsonSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    targetWebsite: string;
+    name?: string | undefined;
+    browser?: {
+        using: {
+            type: "device";
+            deviceName?: string | undefined;
+            headless?: boolean | undefined;
+        } | {
+            type: "remoteInstance";
+            url: string;
+        } | {
+            type: "browserBase";
+            sessionArgs: {
+                projectId: string;
+                extensionId?: string | undefined;
+                browserSettings?: {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                } | undefined;
+                timeout?: number | undefined;
+                proxies?: boolean | undefined;
+                region?: string | undefined;
+                userMetadata?: Record<string, string> | undefined;
+            };
+        };
+        initialState?: import("./BrowserStateFlowReference").BrowserStateReference | undefined;
+        persistState?: boolean | undefined;
+    } | undefined;
+    envVars?: string[] | undefined;
+    customTools?: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        javascript: string;
+    }[] | undefined;
+    defaultMessageDuration?: number | undefined;
+    isControlPanelEnabled?: boolean | undefined;
+    callbackUrl?: string | undefined;
+    overallObjective?: string | undefined;
+    allowedTools?: string[] | undefined;
+    resultJsonSchema?: Record<string, any> | undefined;
+    maxIterations?: number | undefined;
+    gptConfigNameOverride?: string | undefined;
+    initialRunMode?: "AUTONOMOUS" | "INSTRUCT" | "DETERMINISTIC" | undefined;
+    toolCallsOnStart?: ProposedToolCall<any>[] | undefined;
+}, {
+    targetWebsite: string;
+    name?: string | undefined;
+    browser?: {
+        using: {
+            type: "device";
+            deviceName?: string | undefined;
+            headless?: boolean | undefined;
+        } | {
+            type: "remoteInstance";
+            url: string;
+        } | {
+            type: "browserBase";
+            sessionArgs: {
+                projectId: string;
+                extensionId?: string | undefined;
+                browserSettings?: {
+                    extensionId?: string | undefined;
+                    context?: {
+                        id: string;
+                    } | undefined;
+                    viewport?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    blockAds?: boolean | undefined;
+                    solveCaptchas?: boolean | undefined;
+                    advancedStealth?: boolean | undefined;
+                } | undefined;
+                timeout?: number | undefined;
+                proxies?: boolean | undefined;
+                region?: string | undefined;
+                userMetadata?: Record<string, string> | undefined;
+            };
+        };
+        initialState?: import("./BrowserStateFlowReference").BrowserStateReference | undefined;
+        persistState?: boolean | undefined;
+    } | undefined;
+    envVars?: string[] | undefined;
+    customTools?: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        javascript: string;
+    }[] | undefined;
+    defaultMessageDuration?: number | undefined;
+    isControlPanelEnabled?: boolean | undefined;
+    callbackUrl?: string | undefined;
+    overallObjective?: string | undefined;
+    allowedTools?: string[] | undefined;
+    resultJsonSchema?: Record<string, any> | undefined;
+    maxIterations?: number | undefined;
+    gptConfigNameOverride?: string | undefined;
+    initialRunMode?: "AUTONOMOUS" | "INSTRUCT" | "DETERMINISTIC" | undefined;
+    toolCallsOnStart?: ProposedToolCall<any>[] | undefined;
+}>;
+export type CreateDonobuFlow = z.infer<typeof CreateDonobuFlowSchema>;
 //# sourceMappingURL=CreateDonobuFlow.d.ts.map

package/dist/models/CreateDonobuFlow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CreateDonobuFlow.d.ts","sourceRoot":"","sources":["../../src/models/CreateDonobuFlow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAEnC,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEvB,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;IAEjC;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC;;;;QAII;IACJ,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAExC,+GAA+G;IAC/G,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAEzC;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAElC;;;OAGG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEzC;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAEjC,wEAAwE;IACxE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC;IAEpD,2FAA2F;IAC3F,QAAQ,CAAC,gBAAgB,CAAC,EAAE,WAAW,CAAC;CACzC,CAAC"}
+{"version":3,"file":"CreateDonobuFlow.d.ts","sourceRoot":"","sources":["../../src/models/CreateDonobuFlow.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmGhC,CAAC;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/models/CreateDonobuFlow.js

@@ -1,3 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDonobuFlowSchema = void 0;
+const CustomTool_1 = require("./CustomTool");
+const FlowMetadata_1 = require("./FlowMetadata");
+const BrowserConfig_1 = require("./BrowserConfig");
+const zod_1 = require("zod");
+exports.CreateDonobuFlowSchema = zod_1.z
+    .object({
+    targetWebsite: zod_1.z.string().describe('The initial website to load'),
+    overallObjective: zod_1.z
+        .string()
+        .optional()
+        .describe('The overall objective to pursue; can only be omitted if initialRunMode has an effective value of INSTRUCT or DETERMINISTIC'),
+    name: zod_1.z
+        .string()
+        .max(256)
+        .optional()
+        .describe('The name for this flow; if present, must be fewer than 256 characters'),
+    browser: BrowserConfig_1.BrowserConfigSchema.optional().describe('Browser configuration for the flow'),
+    envVars: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe('The names of environment variables to make available for use by the flow'),
+    callbackUrl: zod_1.z
+        .string()
+        .optional()
+        .describe('The URL to HTTP POST to when the flow completes. The body will contain a JSON object with single field, "id", of which is the ID of the flow that completed'),
+    customTools: zod_1.z
+        .array(CustomTool_1.CustomToolSchema)
+        .optional()
+        .describe('Custom tools to enable for this flow. Any tools specified here will be implicitly added to allowedTools'),
+    maxIterations: zod_1.z
+        .number()
+        .optional()
+        .describe('The maximum number of times to iterate with the underlying GPT'),
+    gptConfigNameOverride: zod_1.z
+        .string()
+        .optional()
+        .describe('The name of a specific GPT configuration to use. If the corresponding GPT configuration is not defined or unresolvable, the default flow agent configuration will be used'),
+    defaultMessageDuration: zod_1.z
+        .number()
+        .optional()
+        .describe("The default amount of time the Donobu flow agent's messaging for the user should show (in milliseconds)"),
+    initialRunMode: FlowMetadata_1.RunModeSchema.optional().describe('The initial run mode of the flow. If not specified, defaults to AUTONOMOUS if gptPlatform is non-null, otherwise, defaults to INSTRUCT'),
+    isControlPanelEnabled: zod_1.z
+        .boolean()
+        .optional()
+        .describe('Set to true if the in-browser control panel should be enabled. If the headless parameter is true, then this parameter is ignored'),
+    allowedTools: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe('If present and non-empty, will constrain the flow to only use these tools (by name). If null or empty, then there are no constraints on the types of tools used. Note that all tools in customTools are implicitly added here'),
+    toolCallsOnStart: zod_1.z
+        .array(zod_1.z.custom())
+        .optional()
+        .describe('An ordered series of tool calls to invoke when starting the flow'),
+    resultJsonSchema: zod_1.z
+        .record(zod_1.z.any())
+        .optional()
+        .describe('If non-null, the Donobu flow will attempt to save its result using this JSON-schema'),
+})
+    .describe('This is the expected payload for a request to create a new DonobuFlow flow');
 //# sourceMappingURL=CreateDonobuFlow.js.map

package/dist/models/CreateDonobuFlow.js.map

@@ -1 +1 @@
-{"version":3,"file":"CreateDonobuFlow.js","sourceRoot":"","sources":["../../src/models/CreateDonobuFlow.ts"],"names":[],"mappings":""}
+{"version":3,"file":"CreateDonobuFlow.js","sourceRoot":"","sources":["../../src/models/CreateDonobuFlow.ts"],"names":[],"mappings":";;;AAAA,6CAAgD;AAEhD,iDAA+C;AAC/C,mDAAsD;AACtD,6BAAwB;AAEX,QAAA,sBAAsB,GAAG,OAAC;KACpC,MAAM,CAAC;IACN,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,6BAA6B,CAAC;IAEjE,gBAAgB,EAAE,OAAC;SAChB,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,4HAA4H,CAC7H;IAEH,IAAI,EAAE,OAAC;SACJ,MAAM,EAAE;SACR,GAAG,CAAC,GAAG,CAAC;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,uEAAuE,CACxE;IAEH,OAAO,EAAE,mCAAmB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAC9C,oCAAoC,CACrC;IAED,OAAO,EAAE,OAAC;SACP,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;SACjB,QAAQ,EAAE;SACV,QAAQ,CACP,0EAA0E,CAC3E;IAEH,WAAW,EAAE,OAAC;SACX,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,6JAA6J,CAC9J;IAEH,WAAW,EAAE,OAAC;SACX,KAAK,CAAC,6BAAgB,CAAC;SACvB,QAAQ,EAAE;SACV,QAAQ,CACP,yGAAyG,CAC1G;IAEH,aAAa,EAAE,OAAC;SACb,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,gEAAgE,CACjE;IAEH,qBAAqB,EAAE,OAAC;SACrB,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,2KAA2K,CAC5K;IAEH,sBAAsB,EAAE,OAAC;SACtB,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,yGAAyG,CAC1G;IAEH,cAAc,EAAE,4BAAa,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAC/C,wIAAwI,CACzI;IAED,qBAAqB,EAAE,OAAC;SACrB,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CACP,kIAAkI,CACnI;IAEH,YAAY,EAAE,OAAC;SACZ,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;SACjB,QAAQ,EAAE;SACV,QAAQ,CACP,+NAA+N,CAChO;IAEH,gBAAgB,EAAE,OAAC;SAChB,KAAK,CAAC,OAAC,CAAC,MAAM,EAAyB,CAAC;SACxC,QAAQ,EAAE;SACV,QAAQ,CACP,kEAAkE,CACnE;IAEH,gBAAgB,EAAE,OAAC;SAChB,MAAM,CAAC,OAAC,CAAC,GAAG,EAAE,CAAC;SACf,QAAQ,EAAE;SACV,QAAQ,CACP,qFAAqF,CACtF;CACJ,CAAC;KACD,QAAQ,CACP,4EAA4E,CAC7E,CAAC"}

package/dist/models/CustomTool.d.ts

@@ -1,10 +1,19 @@
-/**
- * A definition of a user-defined tool to use for a DonobuFlow.
- */
-export type CustomTool = {
-    readonly name: string;
-    readonly description: string;
-    readonly inputSchema: Record<string, unknown>;
-    readonly javascript: string;
-};
+import { z } from 'zod';
+export declare const CustomToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    javascript: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    javascript: string;
+}, {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    javascript: string;
+}>;
+export type CustomTool = z.infer<typeof CustomToolSchema>;
 //# sourceMappingURL=CustomTool.d.ts.map

package/dist/models/CustomTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CustomTool.d.ts","sourceRoot":"","sources":["../../src/models/CustomTool.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,CAAC"}
+{"version":3,"file":"CustomTool.d.ts","sourceRoot":"","sources":["../../src/models/CustomTool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAW6C,CAAC;AAE3E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/models/CustomTool.js

@@ -1,3 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomToolSchema = void 0;
+const zod_1 = require("zod");
+exports.CustomToolSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().describe('The name of the user-defined tool'),
+    description: zod_1.z.string().describe('A description of what the tool does'),
+    inputSchema: zod_1.z
+        .record(zod_1.z.unknown())
+        .describe('The input schema definition for the tool as a JSON object'),
+    javascript: zod_1.z
+        .string()
+        .describe('The JavaScript code that implements the tool functionality'),
+})
+    .describe('A definition of a user-defined tool to use for a DonobuFlow');
 //# sourceMappingURL=CustomTool.js.map

package/dist/models/CustomTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"CustomTool.js","sourceRoot":"","sources":["../../src/models/CustomTool.ts"],"names":[],"mappings":""}
+{"version":3,"file":"CustomTool.js","sourceRoot":"","sources":["../../src/models/CustomTool.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,gBAAgB,GAAG,OAAC;KAC9B,MAAM,CAAC;IACN,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,mCAAmC,CAAC;IAC9D,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,qCAAqC,CAAC;IACvE,WAAW,EAAE,OAAC;SACX,MAAM,CAAC,OAAC,CAAC,OAAO,EAAE,CAAC;SACnB,QAAQ,CAAC,2DAA2D,CAAC;IACxE,UAAU,EAAE,OAAC;SACV,MAAM,EAAE;SACR,QAAQ,CAAC,4DAA4D,CAAC;CAC1E,CAAC;KACD,QAAQ,CAAC,6DAA6D,CAAC,CAAC"}

package/dist/models/DonobuToolPlugin.d.ts

@@ -0,0 +1,5 @@
+import { Tool } from '../tools/Tool';
+export interface DonobuToolPlugin {
+    loadTools(): Promise<Tool<any, any>[]>;
+}
+//# sourceMappingURL=DonobuToolPlugin.d.ts.map

package/dist/models/DonobuToolPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DonobuToolPlugin.d.ts","sourceRoot":"","sources":["../../src/models/DonobuToolPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,MAAM,WAAW,gBAAgB;IAC/B,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;CACxC"}

package/dist/models/DonobuToolPlugin.js

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

package/dist/models/DonobuToolPlugin.js.map

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

package/dist/models/ElementSelector.d.ts

@@ -1,17 +1,13 @@
-/**
- * A query structure used to resolve specific a HTML element in a webpage.
- */
-export type ElementSelector = {
-    /**
-     * An prioritized list of element selectors to use to attempt to resolve the
-     * desired element, going from most specific to least specific. The first
-     * element selector that is successfully used, wins, and the rest are ignored.
-     */
-    readonly element: string[];
-    /**
-     * A selector for the corresponding frame of the element to select.
-     * If null, this means the primary frame of the page is used.
-     */
-    readonly frame: string | null;
-};
+import { z } from 'zod';
+export declare const ElementSelectorSchema: z.ZodObject<{
+    element: z.ZodArray<z.ZodString, "many">;
+    frame: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    frame: string | null;
+    element: string[];
+}, {
+    frame: string | null;
+    element: string[];
+}>;
+export type ElementSelector = z.infer<typeof ElementSelectorSchema>;
 //# sourceMappingURL=ElementSelector.d.ts.map

package/dist/models/ElementSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ElementSelector.d.ts","sourceRoot":"","sources":["../../src/models/ElementSelector.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAE3B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC"}
+{"version":3,"file":"ElementSelector.d.ts","sourceRoot":"","sources":["../../src/models/ElementSelector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;;;;;;;EAgB/B,CAAC;AAEJ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}