donobu 2.24.1 → 2.25.1

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

@@ -1,288 +1,7 @@
 import { z } from 'zod';
-export declare const CreateDonobuFlowSchema: z.ZodObject<z.objectUtil.extendShape<Pick<{
-    id: z.ZodString;
-    name: z.ZodNullable<z.ZodString>;
-    createdWithDonobuVersion: z.ZodString;
-    browser: 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>;
-                keepAlive: z.ZodOptional<z.ZodBoolean>;
-                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;
-                keepAlive?: boolean | 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;
-                keepAlive?: boolean | 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;
-                keepAlive?: boolean | 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;
-                keepAlive?: boolean | 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;
-                keepAlive?: boolean | 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;
-                keepAlive?: boolean | undefined;
-                proxies?: boolean | undefined;
-                region?: string | undefined;
-                userMetadata?: Record<string, string> | undefined;
-            };
-        };
-        initialState?: import("./BrowserStateFlowReference").BrowserStateReference | undefined;
-        persistState?: boolean | undefined;
-    }>;
-    envVars: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
-    gptConfigName: z.ZodNullable<z.ZodString>;
-    hasGptConfigNameOverride: z.ZodBoolean;
-    customTools: z.ZodNullable<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">>;
-    defaultMessageDuration: z.ZodNullable<z.ZodNumber>;
-    runMode: z.ZodEnum<["AUTONOMOUS", "INSTRUCT", "DETERMINISTIC"]>;
-    isControlPanelEnabled: z.ZodBoolean;
-    callbackUrl: z.ZodNullable<z.ZodString>;
+export declare const CreateDonobuFlowSchema: z.ZodObject<{
     targetWebsite: z.ZodString;
-    overallObjective: z.ZodNullable<z.ZodString>;
-    allowedTools: z.ZodArray<z.ZodString, "many">;
-    resultJsonSchema: z.ZodNullable<z.ZodType<import("json-schema").JSONSchema7, z.ZodTypeDef, import("json-schema").JSONSchema7>>;
-    result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    inputTokensUsed: z.ZodNumber;
-    completionTokensUsed: z.ZodNumber;
-    maxToolCalls: z.ZodNullable<z.ZodNumber>;
-    startedAt: z.ZodNullable<z.ZodNumber>;
-    completedAt: z.ZodNullable<z.ZodNumber>;
-    state: z.ZodEnum<["UNSTARTED", "INITIALIZING", "QUERYING_LLM_FOR_NEXT_ACTION", "WAITING_ON_USER_FOR_NEXT_ACTION", "PAUSED", "RESUMING", "RUNNING_ACTION", "FAILED", "SUCCESS"]>;
-    nextState: z.ZodNullable<z.ZodEnum<["UNSTARTED", "INITIALIZING", "QUERYING_LLM_FOR_NEXT_ACTION", "WAITING_ON_USER_FOR_NEXT_ACTION", "PAUSED", "RESUMING", "RUNNING_ACTION", "FAILED", "SUCCESS"]>>;
-}, "name" | "browser" | "envVars" | "customTools" | "defaultMessageDuration" | "callbackUrl" | "targetWebsite" | "overallObjective" | "allowedTools" | "resultJsonSchema" | "maxToolCalls">, {
+} & {
     name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     browser: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         initialState: z.ZodOptional<z.ZodType<import("./BrowserStateFlowReference").BrowserStateReference, z.ZodTypeDef, import("./BrowserStateFlowReference").BrowserStateReference>>;
@@ -567,7 +286,7 @@ export declare const CreateDonobuFlowSchema: z.ZodObject<z.objectUtil.extendShap
         parameters: Record<string, unknown>;
         toolCallId?: string | null | undefined;
     }>, "many">>>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     targetWebsite: string;
     name?: string | null | undefined;
     browser?: {

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

@@ -1 +1 @@
-{"version":3,"file":"CreateDonobuFlow.d.ts","sourceRoot":"","sources":["../../../src/models/CreateDonobuFlow.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwFhC,CAAC;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"CreateDonobuFlow.d.ts","sourceRoot":"","sources":["../../../src/models/CreateDonobuFlow.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwFhC,CAAC;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/esm/plugin/PluginLoader.d.ts

@@ -0,0 +1,3 @@
+import { Tool } from '../tools/Tool';
+export declare function loadAllCustomToolPlugins(): Promise<Tool<any, any>[]>;
+//# sourceMappingURL=PluginLoader.d.ts.map

package/dist/esm/plugin/PluginLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginLoader.d.ts","sourceRoot":"","sources":["../../../src/plugin/PluginLoader.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAIrC,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,CAqC1E"}

package/dist/esm/plugin/PluginLoader.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAllCustomToolPlugins = loadAllCustomToolPlugins;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const MiscUtils_1 = require("../utils/MiscUtils");
+async function loadAllCustomToolPlugins() {
+    const pluginsDir = node_path_1.default.join(MiscUtils_1.MiscUtils.baseWorkingDirectory(), 'plugins');
+    // Collect candidate *.mjs / *.cjs / *.js / *.ts files (shallow-scan).
+    let entries = [];
+    try {
+        const dirents = await promises_1.default.readdir(pluginsDir, { withFileTypes: true });
+        entries = dirents
+            .filter((d) => d.isFile())
+            .filter((d) => /\.[cm]?js$|\.ts$/i.test(d.name))
+            .map((d) => node_path_1.default.join(pluginsDir, d.name));
+    }
+    catch {
+        // directory missing is not fatal – just return empty plugin list
+        return [];
+    }
+    const tools = [];
+    for (const file of entries) {
+        try {
+            // Dynamic import via file URL keeps Windows & *nix happy.
+            const mod = await import((0, node_url_1.pathToFileURL)(file).href);
+            if (mod &&
+                typeof mod.loadCustomTools === 'function') {
+                const pluginTools = await mod.loadCustomTools();
+                pluginTools.forEach((t) => tools.push(t));
+            }
+        }
+        catch (err) {
+            console.error(`Failed to load plugin "${file}":`, err);
+            // Keep going; a broken plugin should not stop startup.
+        }
+    }
+    return tools;
+}
+//# sourceMappingURL=PluginLoader.js.map

package/dist/esm/plugin/PluginLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginLoader.js","sourceRoot":"","sources":["../../../src/plugin/PluginLoader.ts"],"names":[],"mappings":";;;;;AAOA,4DAqCC;AA5CD,gEAAkC;AAClC,0DAA6B;AAC7B,uCAAyC;AAGzC,kDAA+C;AAExC,KAAK,UAAU,wBAAwB;IAC5C,MAAM,UAAU,GAAG,mBAAI,CAAC,IAAI,CAAC,qBAAS,CAAC,oBAAoB,EAAE,EAAE,SAAS,CAAC,CAAC;IAE1E,sEAAsE;IACtE,IAAI,OAAO,GAAa,EAAE,CAAC;IAC3B,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,kBAAE,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QACtE,OAAO,GAAG,OAAO;aACd,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;aACzB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;aAC/C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/C,CAAC;IAAC,MAAM,CAAC;QACP,iEAAiE;QACjE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,KAAK,GAAqB,EAAE,CAAC;IAEnC,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;QAC3B,IAAI,CAAC;YACH,0DAA0D;YAC1D,MAAM,GAAG,GAAY,MAAM,MAAM,CAAC,IAAA,wBAAa,EAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;YAE5D,IACE,GAAG;gBACH,OAAQ,GAA6B,CAAC,eAAe,KAAK,UAAU,EACpE,CAAC;gBACD,MAAM,WAAW,GAAG,MAAO,GAAoB,CAAC,eAAe,EAAE,CAAC;gBAClE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,0BAA0B,IAAI,IAAI,EAAE,GAAG,CAAC,CAAC;YACvD,uDAAuD;QACzD,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/esm/plugin/PluginModule.d.ts

@@ -0,0 +1,9 @@
+import { Tool } from '../tools/Tool';
+/**
+ * Every plugin must export ONE async function with this exact name.
+ * Donobu will call it on startup.
+ */
+export interface PluginModule {
+    loadCustomTools(): Promise<Tool<any, any>[]>;
+}
+//# sourceMappingURL=PluginModule.d.ts.map

package/dist/esm/plugin/PluginModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginModule.d.ts","sourceRoot":"","sources":["../../../src/plugin/PluginModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;CAC9C"}

package/dist/esm/plugin/PluginModule.js

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

package/dist/esm/plugin/PluginModule.js.map

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

package/dist/esm/tools/AcknowledgeUserInstruction.d.ts

@@ -9,11 +9,11 @@ export declare const AcknowledgeUserInstructionCoreSchema: z.ZodObject<{
 }, {
     userInstruction: string;
 }>;
-export declare const AcknowledgeUserInstructionGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const AcknowledgeUserInstructionGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     userInstruction: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     userInstruction: string;
 }, {

package/dist/esm/tools/AnalyzePageTextTool.d.ts

@@ -12,12 +12,12 @@ export declare const AnalyzePageTextCoreParameters: z.ZodObject<{
     analysisToRun: string;
     additionalRelevantContext: string;
 }>;
-export declare const AnalyzePageTextGptParameters: z.ZodObject<z.objectUtil.extendShape<{
+export declare const AnalyzePageTextGptParameters: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     analysisToRun: z.ZodString;
     additionalRelevantContext: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     analysisToRun: string;
     additionalRelevantContext: string;

package/dist/esm/tools/AssertPageTextTool.d.ts

@@ -9,11 +9,11 @@ export declare const AssertPageTextCoreParameters: z.ZodObject<{
 }, {
     text: string;
 }>;
-export declare const AssertPageTextGptParameters: z.ZodObject<z.objectUtil.extendShape<{
+export declare const AssertPageTextGptParameters: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     text: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     text: string;
     rationale: string;
 }, {

package/dist/esm/tools/AssertPageTool.d.ts

@@ -15,13 +15,13 @@ export declare const AssertPageCoreSchema: z.ZodObject<{
     type: "url" | "title" | "content";
     isRegex?: boolean | undefined;
 }>;
-export declare const AssertPageToolGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const AssertPageToolGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     type: z.ZodEnum<["url", "title", "content"]>;
     expected: z.ZodString;
     isRegex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     expected: string;
     type: "url" | "title" | "content";
     rationale: string;

package/dist/esm/tools/AssertTool.d.ts

@@ -9,11 +9,11 @@ export declare const AssertCoreSchema: z.ZodObject<{
 }, {
     assertionToTestFor: string;
 }>;
-export declare const AssertToolGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const AssertToolGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     assertionToTestFor: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     assertionToTestFor: string;
 }, {

package/dist/esm/tools/ChangeWebBrowserTabTool.d.ts

@@ -9,11 +9,11 @@ export declare const ChangeWebBrowserTabCoreSchema: z.ZodObject<{
 }, {
     tabUrl: string;
 }>;
-export declare const ChangeWebBrowserTabGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const ChangeWebBrowserTabGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     tabUrl: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     tabUrl: string;
 }, {

package/dist/esm/tools/ChooseSelectOptionTool.d.ts

@@ -9,7 +9,7 @@ export declare const ChooseSelectOptionCoreSchema: z.ZodObject<{
 }, {
     optionValues: string[];
 }>;
-export declare const ChooseSelectOptionNonGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const ChooseSelectOptionNonGptSchema: z.ZodObject<{
     selector: z.ZodObject<{
         element: z.ZodArray<z.ZodString, "many">;
         frame: z.ZodNullable<z.ZodString>;
@@ -20,9 +20,9 @@ export declare const ChooseSelectOptionNonGptSchema: z.ZodObject<z.objectUtil.ex
         frame: string | null;
         element: string[];
     }>;
-}, {
+} & {
     optionValues: z.ZodArray<z.ZodString, "many">;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     selector: {
         frame: string | null;
         element: string[];
@@ -35,14 +35,14 @@ export declare const ChooseSelectOptionNonGptSchema: z.ZodObject<z.objectUtil.ex
     };
     optionValues: string[];
 }>;
-export declare const ChooseSelectOptionGptSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+export declare const ChooseSelectOptionGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     whyThisAnnotation: z.ZodString;
     annotation: z.ZodString;
-}>, {
+} & {
     optionValues: z.ZodArray<z.ZodString, "many">;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     annotation: string;
     rationale: string;
     whyThisAnnotation: string;

package/dist/esm/tools/DetectBrokenLinksTool.d.ts

@@ -9,11 +9,11 @@ export declare const DetectBrokenLinksCoreSchema: z.ZodObject<{
 }, {
     captureScreenshots?: boolean | undefined;
 }>;
-export declare const DetectBrokenLinksGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const DetectBrokenLinksGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     captureScreenshots: z.ZodOptional<z.ZodBoolean>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     captureScreenshots?: boolean | undefined;
 }, {

package/dist/esm/tools/DownloadPdfTool.d.ts

@@ -9,11 +9,11 @@ export declare const DownloadPdfCoreSchema: z.ZodObject<{
 }, {
     url: string;
 }>;
-export declare const DownloadPdfGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const DownloadPdfGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     url: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     url: string;
     rationale: string;
 }, {

package/dist/esm/tools/ExtractGoogleStreetviewEntityDataTool.d.ts

@@ -10,11 +10,11 @@ export declare const ExtractGoogleStreetviewEntityDataCoreSchema: z.ZodObject<{
 }, {
     entityName: string;
 }>;
-export declare const ExtractGoogleStreetviewEntityDataGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const ExtractGoogleStreetviewEntityDataGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     entityName: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     entityName: string;
 }, {

package/dist/esm/tools/ExtractPublicFacebookEntityDataTool.d.ts

@@ -12,12 +12,12 @@ export declare const ExtractPublicFacebookEntityDataCoreSchema: z.ZodObject<{
     facebookEntityName?: string | undefined;
     facebookEntityUrl?: string | undefined;
 }>;
-export declare const ExtractPublicFacebookEntityDataGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const ExtractPublicFacebookEntityDataGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     facebookEntityName: z.ZodOptional<z.ZodString>;
     facebookEntityUrl: z.ZodOptional<z.ZodString>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     facebookEntityName?: string | undefined;
     facebookEntityUrl?: string | undefined;

package/dist/esm/tools/GetEntityDataFromGoogleMapResult.d.ts

@@ -3,12 +3,12 @@ import { ToolCallContext } from '../models/ToolCallContext';
 import { ToolCallResult } from '../models/ToolCallResult';
 import { NoArgsSchema } from '../models/ToolSchema';
 import { z } from 'zod';
-export declare const GetEntityDataFromGoogleMapResultGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const GetEntityDataFromGoogleMapResultGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     entityName: z.ZodString;
     entityAddress: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     entityName: string;
     entityAddress: string;

package/dist/esm/tools/GoForwardOrBackTool.d.ts

@@ -9,11 +9,11 @@ export declare const GoForwardOrBackCoreSchema: z.ZodObject<{
 }, {
     direction: "FORWARD" | "BACK";
 }>;
-export declare const GoForwardOrBackGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const GoForwardOrBackGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     direction: z.ZodEnum<["FORWARD", "BACK"]>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     direction: "FORWARD" | "BACK";
 }, {

package/dist/esm/tools/GoToGoogleMapsStreetViewTool.d.ts

@@ -12,12 +12,12 @@ export declare const GoToGoogleMapsStreetViewCoreSchema: z.ZodObject<{
     entityName: string;
     entityLocation: string;
 }>;
-export declare const GoToGoogleMapsStreetViewGptSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const GoToGoogleMapsStreetViewGptSchema: z.ZodObject<{
     rationale: z.ZodString;
-}, {
+} & {
     entityName: z.ZodString;
     entityLocation: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     rationale: string;
     entityName: string;
     entityLocation: string;