@getmagical/cli 0.1.16 → 0.1.17

package/dist/index.js

@@ -573,12 +573,12 @@ var require_unreachable_case_error = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.UnreachableCaseError = void 0;
-    var UnreachableCaseError2 = class extends Error {
+    var UnreachableCaseError3 = class extends Error {
       constructor(value) {
         super(`Unreachable case: ${value}`);
       }
     };
-    exports.UnreachableCaseError = UnreachableCaseError2;
+    exports.UnreachableCaseError = UnreachableCaseError3;
   }
 });
 
@@ -736,6 +736,166 @@ var require_dist = __commonJS({
   }
 });
 
+// ../../node_modules/fast-deep-equal/es6/index.js
+var require_es6 = __commonJS({
+  "../../node_modules/fast-deep-equal/es6/index.js"(exports, module) {
+    "use strict";
+    module.exports = function equal(a, b) {
+      if (a === b) return true;
+      if (a && b && typeof a == "object" && typeof b == "object") {
+        if (a.constructor !== b.constructor) return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+          length = a.length;
+          if (length != b.length) return false;
+          for (i = length; i-- !== 0; )
+            if (!equal(a[i], b[i])) return false;
+          return true;
+        }
+        if (a instanceof Map && b instanceof Map) {
+          if (a.size !== b.size) return false;
+          for (i of a.entries())
+            if (!b.has(i[0])) return false;
+          for (i of a.entries())
+            if (!equal(i[1], b.get(i[0]))) return false;
+          return true;
+        }
+        if (a instanceof Set && b instanceof Set) {
+          if (a.size !== b.size) return false;
+          for (i of a.entries())
+            if (!b.has(i[0])) return false;
+          return true;
+        }
+        if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+          length = a.length;
+          if (length != b.length) return false;
+          for (i = length; i-- !== 0; )
+            if (a[i] !== b[i]) return false;
+          return true;
+        }
+        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length) return false;
+        for (i = length; i-- !== 0; )
+          if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+        for (i = length; i-- !== 0; ) {
+          var key = keys[i];
+          if (!equal(a[key], b[key])) return false;
+        }
+        return true;
+      }
+      return a !== a && b !== b;
+    };
+  }
+});
+
+// ../../node_modules/json-stringify-deterministic/lib/defaults.js
+var require_defaults = __commonJS({
+  "../../node_modules/json-stringify-deterministic/lib/defaults.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      space: "",
+      cycles: false,
+      replacer: (k, v) => v,
+      stringify: JSON.stringify
+    };
+  }
+});
+
+// ../../node_modules/json-stringify-deterministic/lib/util.js
+var require_util = __commonJS({
+  "../../node_modules/json-stringify-deterministic/lib/util.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      isArray: Array.isArray,
+      assign: Object.assign,
+      isObject: (v) => typeof v === "object",
+      isFunction: (v) => typeof v === "function",
+      isBoolean: (v) => typeof v === "boolean",
+      isRegex: (v) => v instanceof RegExp,
+      keys: Object.keys
+    };
+  }
+});
+
+// ../../node_modules/json-stringify-deterministic/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/json-stringify-deterministic/lib/index.js"(exports, module) {
+    "use strict";
+    var DEFAULTS = require_defaults();
+    var isFunction = require_util().isFunction;
+    var isBoolean = require_util().isBoolean;
+    var isObject = require_util().isObject;
+    var isArray = require_util().isArray;
+    var isRegex = require_util().isRegex;
+    var assign = require_util().assign;
+    var keys = require_util().keys;
+    function serialize(obj) {
+      if (obj === null || obj === void 0) return obj;
+      if (isRegex(obj)) return obj.toString();
+      return obj.toJSON ? obj.toJSON() : obj;
+    }
+    function stringifyDeterministic(obj, opts) {
+      opts = opts || assign({}, DEFAULTS);
+      if (isFunction(opts)) opts = { compare: opts };
+      const space = opts.space || DEFAULTS.space;
+      const cycles = isBoolean(opts.cycles) ? opts.cycles : DEFAULTS.cycles;
+      const replacer = opts.replacer || DEFAULTS.replacer;
+      const stringify2 = opts.stringify || DEFAULTS.stringify;
+      const compare = opts.compare && /* @__PURE__ */ (function(f) {
+        return function(node) {
+          return function(a, b) {
+            const aobj = { key: a, value: node[a] };
+            const bobj = { key: b, value: node[b] };
+            return f(aobj, bobj);
+          };
+        };
+      })(opts.compare);
+      if (!cycles) stringify2(obj);
+      const seen = [];
+      return (function _deterministic(parent, key, node, level) {
+        const indent2 = space ? "\n" + new Array(level + 1).join(space) : "";
+        const colonSeparator = space ? ": " : ":";
+        node = serialize(node);
+        node = replacer.call(parent, key, node);
+        if (node === void 0) return;
+        if (!isObject(node) || node === null) return stringify2(node);
+        if (isArray(node)) {
+          const out = [];
+          for (let i = 0; i < node.length; i++) {
+            const item = _deterministic(node, i, node[i], level + 1) || stringify2(null);
+            out.push(indent2 + space + item);
+          }
+          return "[" + out.join(",") + indent2 + "]";
+        } else {
+          if (cycles) {
+            if (seen.indexOf(node) !== -1) {
+              return stringify2("[Circular]");
+            } else {
+              seen.push(node);
+            }
+          }
+          const nodeKeys = keys(node).sort(compare && compare(node));
+          const out = [];
+          for (let i = 0; i < nodeKeys.length; i++) {
+            const key2 = nodeKeys[i];
+            const value = _deterministic(node, key2, node[key2], level + 1);
+            if (!value) continue;
+            const keyValue = stringify2(key2) + colonSeparator + value;
+            out.push(indent2 + space + keyValue);
+          }
+          seen.splice(seen.indexOf(node), 1);
+          return "{" + out.join(",") + indent2 + "}";
+        }
+      })({ "": obj }, "", obj, 0);
+    }
+    module.exports = stringifyDeterministic;
+  }
+});
+
 // ../../node_modules/handlebars/dist/cjs/handlebars/utils.js
 var require_utils = __commonJS({
   "../../node_modules/handlebars/dist/cjs/handlebars/utils.js"(exports) {
@@ -3658,7 +3818,7 @@ var require_base64_vlq = __commonJS({
 });
 
 // ../../node_modules/source-map/lib/util.js
-var require_util = __commonJS({
+var require_util2 = __commonJS({
   "../../node_modules/source-map/lib/util.js"(exports) {
     "use strict";
     function getArg(aArgs, aName, aDefaultValue) {
@@ -3806,8 +3966,8 @@ var require_util = __commonJS({
       var obj = /* @__PURE__ */ Object.create(null);
       return !("__proto__" in obj);
     })();
-    function identity(s) {
-      return s;
+    function identity(s2) {
+      return s2;
     }
     function toSetString(aStr) {
       if (isProtoString(aStr)) {
@@ -3823,19 +3983,19 @@ var require_util = __commonJS({
       return aStr;
     }
     exports.fromSetString = supportsNullProto ? identity : fromSetString;
-    function isProtoString(s) {
-      if (!s) {
+    function isProtoString(s2) {
+      if (!s2) {
         return false;
       }
-      var length = s.length;
+      var length = s2.length;
       if (length < 9) {
         return false;
       }
-      if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
+      if (s2.charCodeAt(length - 1) !== 95 || s2.charCodeAt(length - 2) !== 95 || s2.charCodeAt(length - 3) !== 111 || s2.charCodeAt(length - 4) !== 116 || s2.charCodeAt(length - 5) !== 111 || s2.charCodeAt(length - 6) !== 114 || s2.charCodeAt(length - 7) !== 112 || s2.charCodeAt(length - 8) !== 95 || s2.charCodeAt(length - 9) !== 95) {
         return false;
       }
       for (var i = length - 10; i >= 0; i--) {
-        if (s.charCodeAt(i) !== 36) {
+        if (s2.charCodeAt(i) !== 36) {
           return false;
         }
       }
@@ -3963,7 +4123,7 @@ var require_util = __commonJS({
 var require_array_set = __commonJS({
   "../../node_modules/source-map/lib/array-set.js"(exports) {
     "use strict";
-    var util = require_util();
+    var util = require_util2();
     var has = Object.prototype.hasOwnProperty;
     var hasNativeMap = typeof Map !== "undefined";
     function ArraySet() {
@@ -4034,7 +4194,7 @@ var require_array_set = __commonJS({
 var require_mapping_list = __commonJS({
   "../../node_modules/source-map/lib/mapping-list.js"(exports) {
     "use strict";
-    var util = require_util();
+    var util = require_util2();
     function generatedPositionAfter(mappingA, mappingB) {
       var lineA = mappingA.generatedLine;
       var lineB = mappingB.generatedLine;
@@ -4075,7 +4235,7 @@ var require_source_map_generator = __commonJS({
   "../../node_modules/source-map/lib/source-map-generator.js"(exports) {
     "use strict";
     var base64VLQ = require_base64_vlq();
-    var util = require_util();
+    var util = require_util2();
     var ArraySet = require_array_set().ArraySet;
     var MappingList = require_mapping_list().MappingList;
     function SourceMapGenerator(aArgs) {
@@ -4444,7 +4604,7 @@ var require_quick_sort = __commonJS({
 var require_source_map_consumer = __commonJS({
   "../../node_modules/source-map/lib/source-map-consumer.js"(exports) {
     "use strict";
-    var util = require_util();
+    var util = require_util2();
     var binarySearch = require_binary_search();
     var ArraySet = require_array_set().ArraySet;
     var base64VLQ = require_base64_vlq();
@@ -4591,8 +4751,8 @@ var require_source_map_consumer = __commonJS({
       });
       this._names = ArraySet.fromArray(names.map(String), true);
       this._sources = ArraySet.fromArray(sources, true);
-      this._absoluteSources = this._sources.toArray().map(function(s) {
-        return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+      this._absoluteSources = this._sources.toArray().map(function(s2) {
+        return util.computeSourceURL(sourceRoot, s2, aSourceMapURL);
       });
       this.sourceRoot = sourceRoot;
       this.sourcesContent = sourcesContent;
@@ -4629,8 +4789,8 @@ var require_source_map_consumer = __commonJS({
       );
       smc.file = aSourceMap._file;
       smc._sourceMapURL = aSourceMapURL;
-      smc._absoluteSources = smc._sources.toArray().map(function(s) {
-        return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
+      smc._absoluteSources = smc._sources.toArray().map(function(s2) {
+        return util.computeSourceURL(smc.sourceRoot, s2, aSourceMapURL);
       });
       var generatedMappings = aSourceMap._mappings.toArray().slice();
       var destGeneratedMappings = smc.__generatedMappings = [];
@@ -4897,11 +5057,11 @@ var require_source_map_consumer = __commonJS({
         line: -1,
         column: 0
       };
-      this._sections = sections.map(function(s) {
-        if (s.url) {
+      this._sections = sections.map(function(s2) {
+        if (s2.url) {
           throw new Error("Support for url field in sections not implemented.");
         }
-        var offset = util.getArg(s, "offset");
+        var offset = util.getArg(s2, "offset");
         var offsetLine = util.getArg(offset, "line");
         var offsetColumn = util.getArg(offset, "column");
         if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
@@ -4915,7 +5075,7 @@ var require_source_map_consumer = __commonJS({
             generatedLine: offsetLine + 1,
             generatedColumn: offsetColumn + 1
           },
-          consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
+          consumer: new SourceMapConsumer(util.getArg(s2, "map"), aSourceMapURL)
         };
       });
     }
@@ -4965,8 +5125,8 @@ var require_source_map_consumer = __commonJS({
       });
     };
     IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
-      return this._sections.every(function(s) {
-        return s.consumer.hasContentsOfAllSources();
+      return this._sections.every(function(s2) {
+        return s2.consumer.hasContentsOfAllSources();
       });
     };
     IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
@@ -5047,7 +5207,7 @@ var require_source_node = __commonJS({
   "../../node_modules/source-map/lib/source-node.js"(exports) {
     "use strict";
     var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
-    var util = require_util();
+    var util = require_util2();
     var REGEX_NEWLINE = /(\r?\n)/;
     var NEWLINE_CODE = 10;
     var isSourceNode = "$$$isSourceNode$$$";
@@ -6564,7 +6724,7 @@ var require_printer = __commonJS({
 });
 
 // ../../node_modules/handlebars/lib/index.js
-var require_lib = __commonJS({
+var require_lib2 = __commonJS({
   "../../node_modules/handlebars/lib/index.js"(exports, module) {
     "use strict";
     var handlebars = require_handlebars()["default"];
@@ -7476,98 +7636,2350 @@ function safeJsonParse(json) {
   }
 }
 
-// ../mcp-registry/src/operation-specs.ts
-import { z as z2 } from "zod";
+// ../common/dist/src/constants/tool-declarations.js
+import { z as z10 } from "zod";
 
-// ../mcp-registry/src/operation-spec.ts
-function stripLeadingGraphqlComments(document) {
-  return document.replace(/^(?:\s*#.*\n)+/u, "").trimStart();
-}
-function assertDocumentMatchesOperation({
-  document,
-  kind,
-  operationName
-}) {
-  const normalizedDocument = stripLeadingGraphqlComments(document);
-  const match = /^(?<actualKind>query|mutation)\s+(?<actualOperationName>[_A-Za-z][_0-9A-Za-z]*)/u.exec(
-    normalizedDocument
-  );
-  const actualKind = match?.groups?.["actualKind"];
-  const actualOperationName = match?.groups?.["actualOperationName"];
-  if (!actualKind || !actualOperationName) {
-    throw new Error(
-      `Operation "${operationName}" is missing a top-level GraphQL ${kind} definition.`
+// ../common/dist/src/zod-schemas/model-config.schema.js
+import { z as z5 } from "zod";
+
+// ../common/dist/src/utils/zod.util.js
+var import_ts_essentials2 = __toESM(require_dist(), 1);
+import { z as z4, ZodObject } from "zod";
+
+// ../../node_modules/zodex/dist/esm/index.js
+import { z as z2 } from "zod";
+import { z as z22 } from "zod";
+var STRING_KINDS = /* @__PURE__ */ new Set([
+  "url",
+  "emoji",
+  "nanoid",
+  "cuid",
+  "cuid2",
+  "ulid",
+  "date",
+  "duration",
+  "base64",
+  "base64url",
+  "guid",
+  "xid",
+  "ksuid",
+  "json_string",
+  "e164",
+  "jwt",
+  "ipv4",
+  "ipv6",
+  "cidrv4",
+  "cidrv6",
+  "e164"
+  // "uuidv8", // In docs only
+  // "ascii", // In docs only
+  // "utf8", // In docs only
+  // "lowercase", // Doesn't appear to have enough data to serialize
+  // "uppercase", // Doesn't appear to have enough data to serialize
+]);
+var getCustomChecksAndErrors = (def, opts) => {
+  let customChecks = null;
+  if ("checks" in opts && opts.checks) {
+    customChecks = def.checks?.filter((check) => {
+      const chk = check._zod.def.check;
+      return chk == "custom";
+    }).map((check) => {
+      const name = Object.entries(
+        /* c8 ignore next -- TS doesn't catch */
+        opts.checks || {}
+      ).find(([, checkFunc]) => {
+        return checkFunc === check._zod.check;
+      })?.[0];
+      if (name) {
+        return { name };
+      }
+      return null;
+    }).filter(Boolean);
+  }
+  let customError;
+  if ("error" in def) {
+    const key = Object.entries(opts.errors ?? {}).find(([, func]) => {
+      return func === def.error;
+    })?.[0];
+    customError = typeof key == "string" ? { key } : (
+      // Not supplying an issue should not be a problem for regular
+      //   wrapped string errors
+      def.error()
     );
   }
-  if (actualKind !== kind || actualOperationName !== operationName) {
-    throw new Error(
-      `Operation "${operationName}" does not match its GraphQL document (${actualKind} ${actualOperationName}).`
+  return Object.assign(
+    customChecks ? { checks: customChecks } : {},
+    customError ? { error: customError } : {}
+  );
+};
+var s = zerializeRefs;
+var zerializers = {
+  optional: (def, opts) => ({
+    ...s(def.innerType, opts, true),
+    isOptional: true
+  }),
+  nullable: (def, opts) => ({
+    ...s(def.innerType, opts, true),
+    isNullable: true
+  }),
+  default: (def, opts) => ({
+    ...s(def.innerType, opts, true),
+    defaultValue: def.innerType._zod.def.type === "bigint" ? String(def.defaultValue) : def.innerType._zod.def.type === "date" ? def.defaultValue.getTime() : def.defaultValue
+  }),
+  number: (def, opts) => {
+    const checks = def.checks?.reduce((o, check) => {
+      const chk = check._zod.def.check;
+      const format = check._zod.def.format;
+      return {
+        ...o,
+        ...chk == "greater_than" ? {
+          min: check._zod.def.value,
+          ...check._zod.def.inclusive ? { minInclusive: true } : {}
+        } : chk == "less_than" ? {
+          max: check._zod.def.value,
+          ...check._zod.def.inclusive ? { maxInclusive: true } : {}
+        } : chk == "multiple_of" ? {
+          multipleOf: check._zod.def.value
+          /* c8 ignore next 2 -- Guard */
+        } : {}
+      };
+    }, {});
+    return Object.assign(
+      {
+        type: "number",
+        ...checks,
+        ...getCustomChecksAndErrors(def, opts),
+        // Check is on `def` itself
+        ..."check" in def && def.check === "number_format" && "format" in def ? { format: def.format } : {}
+      },
+      def.coerce ? { coerce: true } : {}
+    );
+  },
+  template_literal: (def, opts) => {
+    const parts = def.parts.map((part, idx) => {
+      if (typeof part == "string") {
+        return part;
+      }
+      return s(part, {
+        ...opts,
+        currentPath: [...opts.currentPath, "parts", String(idx)]
+      });
+    });
+    return {
+      type: "templateLiteral",
+      parts,
+      ...def.format ? { format: def.format } : {}
+    };
+  },
+  string: (def, opts) => {
+    const checks = def.checks?.reduce((o, check) => {
+      const chk = check._zod.def.check;
+      const format2 = check._zod.def.format;
+      return {
+        ...o,
+        ...chk == "min_length" ? { min: check._zod.def.minimum } : chk == "max_length" ? { max: check._zod.def.maximum } : chk == "length_equals" ? {
+          length: check._zod.def.length
+        } : (
+          // Any way around this?
+          chk === "overwrite" && check._zod.def.tx.toString() === "(input) => input.toUpperCase()" ? { toUpperCase: true } : chk === "overwrite" && check._zod.def.tx.toString() === "(input) => input.toLowerCase()" ? { toLowerCase: true } : chk === "overwrite" && check._zod.def.tx.toString() === "(input) => input.trim()" ? { trim: true } : (
+            // No apparent check
+            // : chk == "string_format" && format == "trim"
+            // ? { trim: true }
+            chk == "string_format" && format2 == "starts_with" ? {
+              startsWith: check._zod.def.prefix
+            } : chk == "string_format" && format2 == "ends_with" ? {
+              endsWith: check._zod.def.suffix
+            } : chk == "string_format" && format2 == "includes" ? {
+              includes: check._zod.def.includes,
+              position: check._zod.def.position
+            } : chk == "string_format" && format2 == "regex" ? {
+              regex: check._zod.def.pattern.source,
+              ...check._zod.def.pattern.flags ? {
+                flags: check._zod.def.pattern.flags
+              } : {}
+              /* c8 ignore next 2 -- Guard */
+            } : {}
+          )
+        )
+      };
+    }, {});
+    const format = "format" in def && def.format;
+    return Object.assign(
+      {
+        type: "string",
+        ...checks,
+        ...getCustomChecksAndErrors(def, opts),
+        // Check is on `def` itself
+        ...format == "ipv4" ? { kind: "ip", version: "v4" } : format == "ipv6" ? { kind: "ip", version: "v6" } : format == "cidrv4" ? { kind: "cidr", version: "v4" } : format == "cidrv6" ? { kind: "cidr", version: "v6" } : format == "uuid" ? {
+          kind: "uuid",
+          ..."version" in def ? { version: def.version } : {}
+        } : format == "jwt" ? {
+          kind: "jwt",
+          ..."alg" in def ? { algorithm: def.alg } : {}
+        } : format == "email" ? {
+          kind: "email",
+          ..."pattern" in def && def.pattern && typeof def.pattern == "object" && "source" in def.pattern && "flags" in def.pattern && def.pattern.source !== z22.regexes.email.source ? {
+            pattern: def.pattern.source,
+            flags: def.pattern.flags
+          } : {}
+        } : "format" in def && STRING_KINDS.has(format) || format == "datetime" || format == "time" ? {
+          kind: format,
+          ..."precision" in def && def.precision ? {
+            precision: def.precision
+          } : {},
+          ..."offset" in def && def.offset ? {
+            offset: def.offset
+          } : {},
+          ..."local" in def && def.local ? {
+            local: def.local
+          } : {}
+        } : {}
+      },
+      def.coerce ? { coerce: true } : {}
+    );
+  },
+  boolean: (def) => Object.assign({ type: "boolean" }, def.coerce ? { coerce: true } : {}),
+  nan: () => ({ type: "nan" }),
+  symbol: () => ({ type: "symbol" }),
+  bigint: (def, opts) => {
+    const checks = def.checks?.reduce((o, check) => {
+      const chk = check._zod.def.check;
+      return {
+        ...o,
+        ...chk == "greater_than" ? {
+          min: String(
+            check._zod.def.value
+          ),
+          ...check._zod.def.inclusive ? { minInclusive: true } : {}
+        } : chk == "less_than" ? {
+          max: String(
+            check._zod.def.value
+          ),
+          ...check._zod.def.inclusive ? { maxInclusive: true } : {}
+        } : chk == "multiple_of" ? {
+          multipleOf: String(
+            check._zod.def.value
+          )
+          /* c8 ignore next 2 -- Guard */
+        } : {}
+      };
+    }, {});
+    return Object.assign(
+      {
+        type: "bigInt",
+        ...checks,
+        ...getCustomChecksAndErrors(def, opts),
+        // Check is on `def` itself
+        ..."check" in def && def.check === "bigint_format" && "format" in def ? { format: def.format } : {}
+      },
+      def.coerce ? { coerce: true } : {}
+    );
+  },
+  file: (def) => {
+    const checks = def.checks?.reduce((o, check) => {
+      const chk = check._zod.def.check;
+      return {
+        ...o,
+        ...chk == "min_size" ? {
+          min: check._zod.def.minimum
+        } : chk == "max_size" ? {
+          max: check._zod.def.maximum
+        } : chk == "mime_type" ? {
+          mime: check._zod.def.mime
+          /* c8 ignore next 2 -- Guard */
+        } : {}
+      };
+    }, {});
+    return {
+      type: "file",
+      ...checks
+    };
+  },
+  date: (def, opts) => {
+    const checks = def.checks?.reduce((o, check) => {
+      const chk = check._zod.def.check;
+      return {
+        ...o,
+        ...chk == "greater_than" ? {
+          min: check._zod.def.value.getTime()
+          // ...((check as z.core.$ZodCheckLessThan<Date>)._zod.def.inclusive
+          //   ? { minInclusive: true }
+          //   : {}),
+        } : chk == "less_than" ? {
+          max: check._zod.def.value.getTime()
+          // ...((check as z.core.$ZodCheckLessThan<Date>)._zod.def.inclusive
+          //   ? { maxInclusive: true }
+          //   : {}),
+        } : (
+          /* c8 ignore next -- Guard */
+          {}
+        )
+      };
+    }, {});
+    return Object.assign(
+      { type: "date", ...checks, ...getCustomChecksAndErrors(def, opts) },
+      def.coerce ? { coerce: true } : {}
+    );
+  },
+  undefined: () => ({ type: "undefined" }),
+  null: () => ({ type: "null" }),
+  any: () => ({ type: "any" }),
+  unknown: () => ({ type: "unknown" }),
+  never: () => ({ type: "never" }),
+  void: () => ({ type: "void" }),
+  literal: (def) => ({ type: "literal", values: def.values }),
+  tuple: (def, opts) => ({
+    type: "tuple",
+    ...getCustomChecksAndErrors(def, opts),
+    items: def.items.map((item, idx) => {
+      const result = s(item, {
+        ...opts,
+        currentPath: [...opts.currentPath, "items", String(idx)]
+      });
+      return result;
+    }),
+    ...def.rest ? {
+      rest: s(def.rest, {
+        ...opts,
+        currentPath: [...opts.currentPath, "rest"]
+      })
+    } : {}
+  }),
+  set: (def, opts) => {
+    const checks = def.checks?.reduce((o, check) => {
+      const chk = check._zod.def.check;
+      return {
+        ...o,
+        ...chk == "min_size" ? {
+          minSize: check._zod.def.minimum
+        } : chk == "max_size" ? {
+          maxSize: check._zod.def.maximum
+        } : chk == "size_equals" ? {
+          minSize: check._zod.def.size,
+          maxSize: check._zod.def.size
+          /* c8 ignore next 2 -- Guard */
+        } : {}
+      };
+    }, {});
+    return {
+      type: "set",
+      value: s(def.valueType, {
+        ...opts,
+        currentPath: [...opts.currentPath, "value"]
+      }),
+      ...getCustomChecksAndErrors(def, opts),
+      ...checks
+    };
+  },
+  array: (def, opts) => {
+    const checks = def.checks?.reduce((o, check) => {
+      const chk = check._zod.def.check;
+      return {
+        ...o,
+        ...chk == "min_length" ? { minLength: check._zod.def.minimum } : chk == "max_length" ? {
+          maxLength: check._zod.def.maximum
+        } : chk == "length_equals" ? {
+          minLength: check._zod.def.length,
+          maxLength: check._zod.def.length
+          /* c8 ignore next 2 -- Guard */
+        } : {}
+      };
+    }, {});
+    return {
+      type: "array",
+      element: s(def.element, {
+        ...opts,
+        currentPath: [...opts.currentPath, "element"]
+      }),
+      ...getCustomChecksAndErrors(def, opts),
+      ...checks
+    };
+  },
+  object: (def, opts) => {
+    return {
+      type: "object",
+      ...getCustomChecksAndErrors(def, opts),
+      ...!def.catchall ? {} : {
+        catchall: s(def.catchall, {
+          ...opts,
+          currentPath: [...opts.currentPath, "catchall"]
+        })
+      },
+      properties: Object.fromEntries(
+        Object.entries(def.shape).map(([key, schema]) => [
+          key,
+          s(schema, {
+            ...opts,
+            currentPath: [...opts.currentPath, "properties", key]
+          })
+        ])
+      )
+    };
+  },
+  record: (def, opts) => ({
+    type: "record",
+    ...getCustomChecksAndErrors(def, opts),
+    key: s(def.keyType, {
+      ...opts,
+      currentPath: [...opts.currentPath, "key"]
+    }),
+    value: s(def.valueType, {
+      ...opts,
+      currentPath: [...opts.currentPath, "value"]
+    })
+  }),
+  map: (def, opts) => ({
+    type: "map",
+    ...getCustomChecksAndErrors(def, opts),
+    key: s(def.keyType, {
+      ...opts,
+      currentPath: [...opts.currentPath, "key"]
+    }),
+    value: s(def.valueType, {
+      ...opts,
+      currentPath: [...opts.currentPath, "value"]
+    })
+  }),
+  enum: (def) => ({ type: "enum", values: def.entries }),
+  union: (def, opts) => {
+    return {
+      type: "discriminator" in def ? "discriminatedUnion" : "union",
+      ..."discriminator" in def ? {
+        discriminator: def.discriminator
+      } : {},
+      ...getCustomChecksAndErrors(def, opts),
+      options: def.options.map((opt, idx) => {
+        const result = s(opt, {
+          ...opts,
+          currentPath: [...opts.currentPath, "options", String(idx)]
+        });
+        return result;
+      })
+    };
+  },
+  intersection: (def, opts) => ({
+    type: "intersection",
+    ...getCustomChecksAndErrors(def, opts),
+    left: s(def.left, {
+      ...opts,
+      currentPath: [...opts.currentPath, "left"]
+    }),
+    right: s(def.right, {
+      ...opts,
+      currentPath: [...opts.currentPath, "right"]
+    })
+  }),
+  promise: (def, opts) => ({
+    type: "promise",
+    value: s(def.innerType, {
+      ...opts,
+      currentPath: [...opts.currentPath, "value"]
+    })
+  }),
+  lazy: (def, opts) => {
+    const getter = def.getter();
+    return s(
+      getter,
+      opts,
+      // official equivalent for `isOptional`
+      getter.safeParse(void 0).success || // official equivalent for `isNullable`
+      getter.safeParse(null).success
     );
+  },
+  transform: (def, opts) => {
+    let name = null;
+    if ("transforms" in opts && opts.transforms) {
+      for (const [transformName, transformItem] of Object.entries(
+        opts.transforms
+      )) {
+        if (def.type === "transform" && transformItem === def.transform) {
+          name = transformName;
+          break;
+        }
+      }
+    }
+    return {
+      type: "transform",
+      name
+      // inner: s(def.out, {
+      //   ...opts,
+      //   currentPath: [...opts.currentPath, "inner"],
+      // }),
+    };
+  },
+  pipe: (def, opts) => {
+    if (!("transforms" in opts)) {
+      return s(def.out, opts);
+    }
+    return {
+      type: "pipe",
+      ...getCustomChecksAndErrors(def, opts),
+      inner: s(def.in, opts),
+      outer: s(def.out, opts)
+    };
+  },
+  catch: (def, opts) => {
+    const catchValue = def.catchValue({
+      value: null,
+      issues: [],
+      // No errors to report, so just add an empty set
+      /* c8 ignore next 3 -- Unused */
+      get error() {
+        return new z22.ZodError([]);
+      },
+      // We don't have any input yet, so just provide `undefined`
+      input: void 0
+    });
+    return {
+      type: "catch",
+      value: catchValue,
+      innerType: s(def.innerType, opts)
+    };
+  },
+  readonly: (def, opts) => ({
+    ...s(def.innerType, opts, true),
+    readonly: true
+  })
+};
+function zerializeRefs(schema, opts, wrapReferences) {
+  if (opts.seenObjects.has(schema)) {
+    return wrapReferences ? {
+      type: "union",
+      options: [{ $ref: opts.seenObjects.get(schema) }],
+      ...typeof schema.description === "string" ? {
+        description: schema.description
+      } : {}
+    } : { $ref: opts.seenObjects.get(schema) };
   }
+  const {
+    _zod: { def }
+  } = schema;
+  const objectPath = "#" + (opts.currentPath.length ? "/" + opts.currentPath.join("/") : "");
+  opts.seenObjects.set(schema, objectPath);
+  const zer = zerializers[def.type](def, opts);
+  if (typeof schema.description === "string") {
+    zer.description = schema.description;
+  }
+  return zer;
 }
-function createOperationSpec(spec) {
-  assertDocumentMatchesOperation(spec);
-  return spec;
+function zerialize(schema, opts = {}) {
+  if (!opts.currentPath) {
+    opts.currentPath = [];
+  }
+  if (!opts.seenObjects) {
+    opts.seenObjects = /* @__PURE__ */ new WeakMap();
+  }
+  return zerializeRefs(schema, opts);
 }
 
-// ../mcp-registry/src/operation-specs.ts
-function stringOption({
-  description,
-  flagName,
-  inputKey,
-  required = false
-}) {
-  return {
-    description,
-    flagName,
-    inputKey,
-    required,
-    valueType: "string"
-  };
-}
-function numberOption({
-  description,
-  flagName,
-  inputKey,
-  required = false
-}) {
-  return {
-    description,
-    flagName,
-    inputKey,
-    required,
-    valueType: "number"
-  };
+// ../common/dist/src/stdlib/object.util.js
+var import_es6 = __toESM(require_es6(), 1);
+function isDeepEqualAndSameType(a, b) {
+  return (0, import_es6.default)(a, b);
 }
-function booleanOption({
-  description,
-  flagName,
-  inputKey
-}) {
-  return {
-    description,
-    flagName,
-    inputKey,
-    valueType: "boolean"
-  };
+
+// ../common/dist/src/stdlib/string.util.js
+var import_json_stringify_deterministic = __toESM(require_lib(), 1);
+import { z as z3 } from "zod";
+function brandString(value) {
+  return value;
+}
+var entityMap = {
+  /* eslint-disable @typescript-eslint/naming-convention */
+  "&#x27;": "'",
+  "&#39;": "'",
+  "&quot;": '"',
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&nbsp;": " "
+  /* eslint-enable @typescript-eslint/naming-convention */
+};
+var entityRegex = new RegExp(Object.keys(entityMap).join("|"), "gu");
+
+// ../common/dist/src/utils/zod.util.js
+function brandedStringValidator(_brand) {
+  return z4.string().transform((val) => brandString(val));
+}
+var emptySchema = zerialize(z4.object({}));
+
+// ../common/dist/src/zod-schemas/model-config.schema.js
+var magicalBaseModels = [
+  "gemini-2.5-flash",
+  "gemini-3-pro-preview",
+  "o3",
+  "gpt-4o",
+  "gpt-5-mini",
+  "gpt-5.4"
+];
+var DEFAULT_MODEL = "gemini-2.5-flash";
+var modelOptionsSchema = z5.object({
+  reasoningEffort: z5.enum(["low", "medium", "high"]).optional().describe("Reasoning effort level for models that support it (e.g., o1, o3). Higher effort may produce better results but takes longer."),
+  temperature: z5.number().min(0).max(2).optional().describe("Controls randomness in model output. 0 is deterministic, higher values (up to 2) increase creativity and randomness.")
+});
+var modelIdSchema = brandedStringValidator("modelId").or(z5.enum(magicalBaseModels));
+var baseModelConfigSchema = z5.object({
+  id: modelIdSchema.default(DEFAULT_MODEL)
+}).extend(modelOptionsSchema.shape);
+var fallbackModelConfigSchema = z5.object({
+  ...baseModelConfigSchema.shape,
+  useAfterAttempt: z5.number().min(1).describe("Number of failed attempts with the primary model before switching to this fallback model.")
+}).describe("Configuration for a fallback model to use after primary failures.");
+var modelConfigSchema = z5.union([
+  modelIdSchema.default(DEFAULT_MODEL),
+  z5.object({
+    ...baseModelConfigSchema.shape,
+    fallbackModels: z5.array(fallbackModelConfigSchema).optional().describe("List of fallback models to try if the primary model fails. Models are tried in order based on useAfterAttempt.")
+  }).describe("Full model configuration with options and fallbacks.")
+]).describe("LLM model configuration. Can be a simple model ID string or an object with advanced options like temperature, reasoning effort, and fallback models.").transform((data) => {
+  if (typeof data === "string") {
+    return { id: data };
+  }
+  return data;
+});
+var agentSingleModelConfigSchema = z5.object({
+  type: z5.literal("single-model"),
+  ...baseModelConfigSchema.shape,
+  fallbackModels: z5.array(fallbackModelConfigSchema).optional().describe("List of fallback models to try if the primary model fails. Models are tried in order based on useAfterAttempt.")
+}).describe("Agent model configuration for selecting a single model directly.");
+var agentModelPoolConfigSchema = z5.object({
+  type: z5.literal("model-pool"),
+  poolId: brandedStringValidator("resourcePoolId").describe("Resource pool ID containing candidate models. The highest-priority model is primary."),
+  ...modelOptionsSchema.shape,
+  fallbackModels: z5.array(fallbackModelConfigSchema).optional().describe("Optional explicit fallback list. If omitted, fallbacks are derived from remaining models in the pool by priority.")
+}).describe("Agent model configuration for selecting models from a resource pool.");
+var agentModelConfigSchema = z5.preprocess((data) => {
+  if (typeof data === "string") {
+    return {
+      type: "single-model",
+      id: data
+    };
+  }
+  if (typeof data === "object" && data !== null && !("type" in data)) {
+    return {
+      type: "single-model",
+      ...data
+    };
+  }
+  return data;
+}, z5.discriminatedUnion("type", [
+  agentSingleModelConfigSchema,
+  agentModelPoolConfigSchema
+])).default({
+  type: "single-model",
+  id: DEFAULT_MODEL
+}).describe("Agent LLM model configuration. Supports direct model selection (single-model) and model-pool selection with priority-based fallback behavior.");
+
+// ../common/dist/src/zod-schemas/browser-provider-options.schema.js
+import { z as z6 } from "zod";
+var viewportSizeSchema = z6.object({
+  width: z6.number().min(800).max(3840).describe("Viewport width in pixels. Must be between 800 and 3840."),
+  height: z6.number().min(600).max(2160).describe("Viewport height in pixels. Must be between 600 and 2160.")
+}).describe("Viewport dimensions in pixels. A 16:9 aspect ratio is recommended for optimal LLM performance.");
+var BROWSER_DEFAULT_VIEWPORT = {
+  width: 1366,
+  height: 768
+};
+var browserProviderOptionsSchema = z6.object({
+  browserbase: z6.object({
+    advancedStealth: z6.boolean().default(false).optional().describe("Enable advanced stealth mode to better avoid bot detection."),
+    contextId: z6.string().min(1).optional().describe("Browserbase context ID for session persistence across runs."),
+    extensionId: z6.string().min(1).optional().describe("Browser extension ID to load in the session."),
+    enablePdfViewer: z6.boolean().optional().describe("Display PDFs in the browser instead of auto-downloading them."),
+    instanceSize: z6.enum(["small", "medium", "large"]).optional().describe("Browser instance size. Larger instances have more resources but cost more. Beta feature."),
+    blockAds: z6.boolean().optional().describe("Block ads when rendering pages in the session."),
+    solveCaptchas: z6.boolean().default(true).optional().describe("Automatically solve CAPTCHAs in the background when encountered."),
+    viewport: viewportSizeSchema.optional()
+  }).optional().describe("Configuration options specific to the Browserbase provider."),
+  agentCore: z6.object({
+    viewport: viewportSizeSchema.optional(),
+    enableWebBotAuth: z6.boolean().default(false).optional().describe("Enable WebBot authentication flow.")
+  }).optional().describe("Configuration options specific to the AgentCore provider."),
+  local: z6.object({
+    viewport: viewportSizeSchema.optional()
+  }).optional().describe("Configuration options for local browser execution (development only)."),
+  hyperbrowser: z6.object({
+    viewport: viewportSizeSchema.optional()
+  }).optional().describe("Configuration options specific to the Hyperbrowser provider."),
+  steel: z6.object({
+    extensionIds: z6.array(z6.string().min(1)).optional().describe("List of browser extension IDs to load in the session."),
+    region: z6.enum(["iad", "ord", "lax"]).optional().describe("Steel data center region. Options: iad (Virginia), ord (Chicago), lax (Los Angeles)."),
+    solveCaptcha: z6.boolean().default(true).optional().describe("Automatically solve CAPTCHAs when encountered."),
+    viewport: viewportSizeSchema.optional()
+  }).optional().describe("Configuration options specific to the Steel provider.")
+}).describe("Provider-specific browser configuration options. Only the options for the selected browserProvider are used.");
+
+// ../../node_modules/uuid/dist-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// ../../node_modules/uuid/dist-node/rng.js
+var rnds8 = new Uint8Array(16);
+function rng() {
+  return crypto.getRandomValues(rnds8);
+}
+
+// ../../node_modules/uuid/dist-node/v4.js
+function v4(options, buf, offset) {
+  if (!buf && !options && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
+function _v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// ../common/dist/src/stdlib/uuid.utils.js
+function uuidV4Branded() {
+  return v4_default();
 }
-function stringArrayOption({
-  description,
-  flagName,
-  inputKey,
-  required = false
-}) {
-  return {
-    description,
-    flagName,
-    inputKey,
-    required,
-    valueHint: "comma-separated",
-    valueType: "string-array"
-  };
+
+// ../common/dist/src/stdlib/url.utils.js
+var import_handlebars = __toESM(require_lib2(), 1);
+var HANDLEBARS_TEMPLATE_REGEX = /\{\{\{?[\s\S]*?\}\}\}?/u;
+var HANDLEBARS_TEMPLATE_GLOBAL_REGEX = /\{\{\{?[\s\S]*?\}\}\}?/gu;
+var LEADING_HANDLEBARS_TEMPLATE_REGEX = /^(?:\{\{\{?[\s\S]*?\}\}\}?)/u;
+var URL_TEMPLATE_PLACEHOLDER_VALUE = "handlebars-template-value";
+var LEADING_URL_TEMPLATE_PLACEHOLDER_VALUE = "https://handlebars-template.example";
+function safeUrlConstructor(url, baseUrl) {
+  try {
+    return Ok(baseUrl ? new URL(url, baseUrl) : new URL(url));
+  } catch {
+    return Err({
+      type: "invalid-url",
+      message: `Invalid URL`,
+      url
+    });
+  }
 }
-function jsonOption({
-  description,
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isHandlebarsTemplateString(value) {
+  return HANDLEBARS_TEMPLATE_REGEX.test(value);
+}
+function isValidHandlebarsTemplateString(template) {
+  try {
+    import_handlebars.default.parse(template);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidUrlOrHandlebarsTemplateString(value) {
+  if (!isHandlebarsTemplateString(value)) {
+    return isValidUrl(value);
+  }
+  if (!isValidHandlebarsTemplateString(value)) {
+    return false;
+  }
+  if (isValidUrl(replaceHandlebarsTemplates(value))) {
+    return true;
+  }
+  const leadingHandlebarsTemplate = getLeadingHandlebarsTemplate(value);
+  if (!leadingHandlebarsTemplate) {
+    return false;
+  }
+  return isValidUrl(replaceHandlebarsTemplates(value.replace(leadingHandlebarsTemplate, LEADING_URL_TEMPLATE_PLACEHOLDER_VALUE)));
+}
+function getLeadingHandlebarsTemplate(value) {
+  const leadingHandlebarsTemplate = LEADING_HANDLEBARS_TEMPLATE_REGEX.exec(value)?.[0];
+  if (!leadingHandlebarsTemplate) {
+    return void 0;
+  }
+  return leadingHandlebarsTemplate;
+}
+function replaceHandlebarsTemplates(value) {
+  return value.replaceAll(HANDLEBARS_TEMPLATE_GLOBAL_REGEX, URL_TEMPLATE_PLACEHOLDER_VALUE);
+}
+
+// ../common/dist/src/stdlib/state-machine.util.js
+var StateMachine = class {
+  states;
+  forwardTransitions;
+  reverseTransitions;
+  constructor({ states, transitions }) {
+    this.states = Object.freeze([...states]);
+    const forward = {};
+    for (const state of this.states) {
+      const toStates = transitions[state] ?? [];
+      const deduped = dedupePreservingOrder(toStates);
+      forward[state] = Object.freeze(deduped);
+    }
+    this.forwardTransitions = Object.freeze(forward);
+    const reverse = {};
+    for (const s2 of this.states) {
+      const sources = this.states.filter((src) => this.forwardTransitions[src].includes(s2));
+      reverse[s2] = Object.freeze(sources);
+    }
+    this.reverseTransitions = Object.freeze(reverse);
+  }
+  /** Returns the full set of states registered in this machine. */
+  getAllStates() {
+    return this.states;
+  }
+  /** Returns the allowed target states for a given source state. */
+  getAllowedTargets(from) {
+    return this.forwardTransitions[from];
+  }
+  /** Returns the allowed source states for a given target state. */
+  getAllowedSources(to) {
+    return this.reverseTransitions[to];
+  }
+  /** Checks if a transition from `from` to `to` is allowed. */
+  isTransitionAllowed(from, to) {
+    return this.forwardTransitions[from].includes(to);
+  }
+};
+function dedupePreservingOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const v of values) {
+    if (!seen.has(v)) {
+      seen.add(v);
+      result.push(v);
+    }
+  }
+  return result;
+}
+
+// ../common/dist/src/models/websocket/actions/scroll.js
+import { z as z7 } from "zod";
+var scrollDataSchema = z7.object({
+  direction: z7.enum(["UP", "DOWN", "LEFT", "RIGHT"]),
+  length: z7.number().min(1).describe("The number of pixels to scroll by. Must be positive and at least 1.")
+});
+var ScrollEvent;
+(function(ScrollEvent2) {
+  let Request;
+  (function(Request2) {
+    function create({ direction, length, agentId, sessionId }) {
+      return {
+        id: uuidV4Branded(),
+        agentId,
+        sessionId,
+        type: "scroll",
+        direction: "request",
+        data: {
+          direction,
+          length
+        }
+      };
+    }
+    Request2.create = create;
+  })(Request = ScrollEvent2.Request || (ScrollEvent2.Request = {}));
+  let Response;
+  (function(Response2) {
+    function create({ id, agentId, sessionId, response }) {
+      return {
+        id,
+        agentId,
+        sessionId,
+        direction: "response",
+        type: "scroll-response",
+        response
+      };
+    }
+    Response2.create = create;
+  })(Response = ScrollEvent2.Response || (ScrollEvent2.Response = {}));
+})(ScrollEvent || (ScrollEvent = {}));
+
+// ../common/dist/src/models/websocket/actions/press.js
+import { z as z8 } from "zod";
+var PressEvent;
+(function(PressEvent2) {
+  let Request;
+  (function(Request2) {
+    function create({ keys, sessionId, agentId }) {
+      return {
+        id: uuidV4Branded(),
+        agentId,
+        sessionId,
+        type: "press",
+        direction: "request",
+        data: {
+          keys
+        }
+      };
+    }
+    Request2.create = create;
+  })(Request = PressEvent2.Request || (PressEvent2.Request = {}));
+  let Response;
+  (function(Response2) {
+    function create({ id, agentId, sessionId, response }) {
+      return {
+        id,
+        agentId,
+        sessionId,
+        direction: "response",
+        type: "press-response",
+        response
+      };
+    }
+    Response2.create = create;
+  })(Response = PressEvent2.Response || (PressEvent2.Response = {}));
+})(PressEvent || (PressEvent = {}));
+var Keys = [
+  // Modifiers
+  "Alt",
+  "CapsLock",
+  "Control",
+  "Fn",
+  "Shift",
+  "Meta",
+  // Whitespace keys
+  "Enter",
+  "Tab",
+  "Space",
+  // Navigation keys
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  // Editing keys
+  "Backspace",
+  "Delete",
+  // UI keys
+  "Escape",
+  "Pause",
+  "Play",
+  // Function keys
+  "F1",
+  "F2",
+  "F3",
+  "F4",
+  "F5",
+  "F6",
+  "F7",
+  "F8",
+  "F9",
+  "F10",
+  "F11",
+  "F12",
+  "F13",
+  "F14",
+  "F15",
+  "F16",
+  "F17",
+  "F18",
+  "F19",
+  "F20",
+  // Alphanumerics (case-sensitive)
+  "A",
+  "a",
+  "B",
+  "b",
+  "C",
+  "c",
+  "D",
+  "d",
+  "E",
+  "e",
+  "F",
+  "f",
+  "G",
+  "g",
+  "H",
+  "h",
+  "I",
+  "i",
+  "J",
+  "j",
+  "K",
+  "k",
+  "L",
+  "l",
+  "M",
+  "m",
+  "N",
+  "n",
+  "O",
+  "o",
+  "P",
+  "p",
+  "Q",
+  "q",
+  "R",
+  "r",
+  "S",
+  "s",
+  "T",
+  "t",
+  "U",
+  "u",
+  "V",
+  "v",
+  "W",
+  "w",
+  "X",
+  "x",
+  "Y",
+  "y",
+  "Z",
+  "z",
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  // Punctuation
+  "Minus",
+  "Equal",
+  "BracketLeft",
+  "BracketRight",
+  "Backslash",
+  "Semicolon",
+  "Quote",
+  "Comma",
+  "Period",
+  "Slash",
+  "Backquote",
+  // System keys
+  "Insert",
+  "PrintScreen"
+];
+var pressDataSchema = z8.object({
+  keys: z8.array(z8.enum(Keys))
+});
+
+// ../common/dist/src/models/websocket/actions/report-stop.js
+import { z as z9 } from "zod";
+var reportStopDataSchema = z9.object({
+  status: z9.enum(["success", "fail"]).describe("Whether the instructions were completed successfully or not"),
+  output: z9.string().optional().describe('Put the user-requested result content here when asked to return it with reportStop. This is for unstructured results only; do not include statuses ("success", "fail") and do not place results in metadata.reasoning. If the user did not request return content, omit this field.')
+});
+
+// ../common/dist/src/constants/tool-declarations.js
+var COMMON_PARAMETERS_KEY = "metadata";
+var COMMON_PARAMETERS_DESCRIPTION = `REQUIRED metadata object that must be provided with every tool call. This object contains context and tracking information that helps monitor agent progress and decision-making. MUST be provided as a JSON object (not a string) under the 'metadata' parameter for all tool calls.`;
+var DEFAULT_COMMON_PARAMETERS = z10.object({
+  reasoning: z10.string().describe("Explain clearly why this tool is being used at this point. Include the goal it helps achieve and the context behind the decision."),
+  step: z10.coerce.string().regex(/^[\dA-Za-z]+(?:\.[\dA-Za-z]+)*$/u, {
+    message: 'Step must follow the format of numbers separated by periods (e.g., "1", "1.2", "2.3.1")'
+  }).describe(String.raw`Indicate the exact step in the process where this tool is being used. MUST use a hierarchical numbering format like "1", "1.2", or "2.3.1" to reflect the structure of the workflow. MUST match this regex: /^[\dA-Za-z]+(?:\.[\dA-Za-z]+)*$/u`),
+  isRetry: z10.boolean().default(false).describe("Indicates whether this tool call is a retry of the previous step.")
+}).describe(COMMON_PARAMETERS_DESCRIPTION);
+var scrollToTextPositionEnum = z10.enum(["start", "center", "end"]);
+var agentToolSchema = z10.object({
+  agentId: z10.string(),
+  args: z10.unknown().optional()
+});
+var baseToolDeclarations = {
+  clickFill: {
+    id: "clickFill",
+    description: 'ONLY USE FOR TEXT INPUT FIELDS. This tool combines two actions: (1) clicking on a form input field and (2) typing text into it. NEVER use this for buttons, links, checkboxes, radio buttons, or any non-input elements. ONLY use when you need to enter text into a field. If you only want to click something without entering text, use "click" instead.',
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker of the input field to fill."),
+      text: z10.string().describe("The text to fill the marker with")
+    })
+  },
+  click: {
+    id: "click",
+    description: 'ONLY USE FOR CLICKING WITHOUT ENTERING TEXT. This tool clicks on an element but DOES NOT allow entering text. Use for buttons, links, checkboxes, dropdown toggles, tabs, and other clickable elements. NEVER use this when you need to enter text into a field - for text entry, use "clickFill" instead, this tool automatically moves the cursor to the element, no need to use the move tool first.',
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker of the element to click."),
+      clickType: z10.enum(["LEFT", "RIGHT", "MIDDLE", "DOUBLE", "TRIPLE"]).describe("The type of click to perform")
+    })
+  },
+  multiClick: {
+    id: "multiClick",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      markers: z10.array(markerSchema("The marker of the element to click.")).min(1)
+    })
+  },
+  clickAndConfirm: {
+    id: "clickAndConfirm",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker of the element to click."),
+      clickType: z10.enum(["LEFT", "RIGHT", "MIDDLE", "DOUBLE", "TRIPLE"]).describe("The type of click to perform"),
+      promptMessage: z10.string().min(1).describe("The prompt message to respond to.")
+    })
+  },
+  copy: {
+    id: "copy",
+    description: "Copy given text to the clipboard.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      text: z10.string().describe("The text to copy to the clipboard.")
+    })
+  },
+  downloadFile: {
+    id: "downloadFile",
+    description: "Download a file in the browser by clicking on something",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker to click on the page to initiate the download"),
+      clickType: z10.enum(["LEFT", "RIGHT", "MIDDLE", "DOUBLE", "TRIPLE"]).describe("The type of click to perform")
+    })
+  },
+  downloadNextDocumentRequest: {
+    id: "downloadNextDocumentRequest",
+    description: "Download file types that a browser doesn't automatically download (like images) by specifying the file extension and either clicking a marker or navigating to a URL. Must provide either marker or URL parameter.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker of the element that triggers the new page").optional(),
+      clickType: z10.enum(["LEFT", "RIGHT", "MIDDLE", "DOUBLE", "TRIPLE"]).optional().describe("The type of click to perform"),
+      url: z10.url().optional().describe("The url to navigate to that triggers the new page"),
+      extension: z10.string().describe("The extension of the downloaded document")
+    })
+  },
+  downloadNextNetworkRequest: {
+    id: "downloadNextNetworkRequest",
+    description: "Download the next network request by listening for a specific content type and resource type",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      clickType: z10.enum(["LEFT", "RIGHT", "MIDDLE", "DOUBLE", "TRIPLE"]).describe("The type of click to perform"),
+      extension: z10.string().describe("The extension of the downloaded document"),
+      contentType: z10.string().describe("The content type of the network request"),
+      // The actual tool is using an enum for the resourceType
+      resourceType: z10.string().describe("The resource type of the network request"),
+      urlPattern: z10.string().min(1).optional().describe("An optional regular expression pattern to match against the request URL")
+    })
+  },
+  printToPDF: {
+    id: "printToPDF",
+    description: "Print the current page to a PDF file",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  printFrameToPDF: {
+    id: "printFrameToPDF",
+    description: "Print the selected frame to a PDF file",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      frameSelector: z10.string().describe("The selector of the frame to print")
+    })
+  },
+  printFocusedFrameToPDF: {
+    id: "printFocusedFrameToPDF",
+    description: "Print the focused frame to a PDF file",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  capturePrintOutput: {
+    id: "capturePrintOutput",
+    description: "Capture the next printed content triggered by clicking an element, then save it as a PDF",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker of the element that triggers the print request"),
+      clickType: z10.enum(["LEFT", "RIGHT", "MIDDLE", "DOUBLE", "TRIPLE"]).optional().describe("The type of click to perform")
+    })
+  },
+  drag: {
+    id: "drag",
+    description: 'Perform a drag-and-drop operation by clicking at the "from" position, holding the mouse button down, and moving to the "to" position before releasing. Use this for dragging elements, sliders, or selecting text. If "from" is not provided, it will start from the current cursor position.',
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      from: markerSchema("The marker to drag from").optional(),
+      to: markerSchema("The marker to drag to")
+    })
+  },
+  extractInfoFromFile: {
+    id: "extractInfoFromFile",
+    description: "Extract information from a previously downloaded file using specific prompts. Provide the file URL using `s3://{key}` and clearly defined extraction instructions.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      filePath: z10.string().describe("The URI to the file, starting with s3://"),
+      extractions: z10.array(z10.object({
+        name: z10.string().describe("The name of the extraction"),
+        prompt: z10.string().describe("Instructions on how to find")
+      }))
+    })
+  },
+  getDropdownOptions: {
+    id: "getDropdownOptions",
+    description: "Get dropdown option labels of a `<select>` dropdown element",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker of the `<select>` dropdown to get option labels from")
+    })
+  },
+  /**
+   *  Playwright will lose track of this position between workflow activities because we create a
+   *  new Playwright client each time. The webpage will still think the cursor is at the previous
+   *  location but some Playwright methods rely on its own cached last position which will be reset
+   *  to 0,0. See AGT-658 for details.
+   */
+  move: {
+    id: "move",
+    description: `Simply move the cursor to a marker location without clicking. Only use this when you need to position the cursor without performing any action, e.g. to make something appear upon hovering. For most interactions, use click or clickFill which already include cursor movement. Don't use this before "scroll", instead provide a marker to "scroll" that indicates the position to scroll from.`,
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker to move the mouse to")
+    })
+  },
+  paste: {
+    id: "paste",
+    description: "Paste text from the clipboard.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  pressKeys: {
+    id: "pressKeys",
+    description: "Press given keys",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      ...pressDataSchema.shape
+    })
+  },
+  reportStop: {
+    id: "reportStop",
+    description: "Report that you have stopped either because you have succeeded in completing all your assigned tasks, or because you were told to do so. If the user asks to return something with it, put it in output (unstructured). Omit output if there is no extra info to return.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      ...reportStopDataSchema.shape
+    })
+  },
+  scroll: {
+    id: "scroll",
+    description: "Scroll the page in a specified direction by a defined amount at the specified location. Useful for navigating to content that is out of view",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      ...scrollDataSchema.shape,
+      // The previous mouse/cursor position is lost between workflow activities because we create a
+      // new Playwright client each time. See AGT-658 for details.
+      marker: z10.union([
+        markerSchema("The marker to move the cursor to before scrolling. This mark should usually have a scroll-distance-* attribute indicating the maximum distance that can be scrolled in a given direction."),
+        z10.enum(["body"]).describe('Specify the string "body" to scroll the top frame if there is no relevant marker.')
+      ])
+    })
+  },
+  scrollToText: {
+    id: "scrollToText",
+    description: "Scroll the page until the specified text string is visible. Use when you need to locate and bring a certain piece of visible text into view.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      text: z10.string().describe("The text to find and scroll to"),
+      scrollPosition: scrollToTextPositionEnum.optional().describe("The position the text should be relative to its scrollable container."),
+      instance: z10.number().int().min(1).default(1).describe("If there are multiple matching elements, indicate which occurrence the agent should be scrolled to.")
+    })
+  },
+  scrollToPattern: {
+    id: "scrollToPattern",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      pattern: z10.string().min(1).describe("The regular expression to match."),
+      flags: z10.string().regex(/^[dgimsuvy]*$/u, {
+        message: "Flags can only contain valid RegExp flag characters: d, g, i, m, s, u, v, y"
+      }).describe('The flags to use for the regular expression. Defaults to "iu" if not specified.').default("iu"),
+      scrollPosition: scrollToTextPositionEnum.optional().describe("The position the text should be relative to its scrollable container."),
+      instance: z10.number().int().min(1).default(1).describe("If there are multiple matching elements, indicate which occurrence the agent should be scrolled to.")
+    })
+  },
+  selectDropdownOptions: {
+    id: "selectDropdownOptions",
+    description: "Select dropdown options with the given label text, replacing existing selections.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker of the `<select>` dropdown to change"),
+      labels: z10.array(z10.string().describe("The label text of the dropdown option to select"))
+    })
+  },
+  type: {
+    id: "type",
+    description: "Type in the currently focused element with the given text",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      text: z10.string().describe("The text to type")
+    })
+  },
+  getNDCFromMedication: {
+    id: "getNDCFromMedication",
+    description: "Extract the National Drug Code (NDC) for a medication by providing detailed medication information including name, route of administration (roa), supply, quantity, and strength. Returns the standardized NDC identifier.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      roa: z10.string().describe("The route of administration of the medication"),
+      name: z10.string().describe("The name of the medication"),
+      supply: z10.string().describe("The supply of the medication"),
+      quantity: z10.string().describe("The quantity of the medication"),
+      strength: z10.string().describe("The strength of the medication")
+    })
+  },
+  navigateTo: {
+    id: "navigateTo",
+    description: "Navigate the browser to the specified URL. Use this when explicitly instructed to navigate to a URL.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      url: z10.url().describe("The URL to navigate to")
+    })
+  },
+  navigateToLinkFromNewTab: {
+    id: "navigateToLinkFromNewTab",
+    description: "When clicking a link would open content in a new tab, this tool captures the destination URL and loads it in the current tab instead. Useful for links with target='_blank' or JavaScript-triggered new windows.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The item to click on which opens in a new tab.")
+    })
+  },
+  listTabs: {
+    id: "listTabs",
+    description: "List all open tabs in the browser session, including each tab ID, URL, and whether it is active.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  openNewTab: {
+    id: "openNewTab",
+    description: "Open a new browser tab, navigate it to the provided URL, and switch the active tab to it.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      url: z10.url().describe("The URL to open in a new tab and navigate to.")
+    })
+  },
+  switchToTab: {
+    id: "switchToTab",
+    description: "Switch the active browser tab to the tab ID returned by listTabs.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      tabId: z10.string().min(1).describe("The ID of the tab to activate.")
+    })
+  },
+  closeTabs: {
+    id: "closeTabs",
+    description: "Close one or more tabs by ID. At least one tab must remain open after closing.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      tabIds: z10.array(z10.string().min(1)).min(1).describe("A list of tab IDs to close.")
+    })
+  },
+  uploadFile: {
+    id: "uploadFile",
+    description: "Upload a file to a file input element in the browser. The filePath must be an S3 URI like s3://{key}",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      filePath: z10.string().describe("The URI to the file to upload like s3://{key}, it should be a valid URI to a file"),
+      marker: markerSchema("The marker of the element to upload the file to")
+    })
+  },
+  uploadScreenshot: {
+    id: "uploadScreenshot",
+    description: "Take a screenshot of the current view, optionally target a marked element or crop it to a bounding box, upload it to storage, and return a reference to the uploaded screenshot.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      filename: z10.string().regex(/^[\w-]+$/u, "Filename can only contain letters, numbers, underscores, and hyphens").optional().describe("Optional custom filename for the screenshot. If not provided, a unique filename will be generated."),
+      marker: markerSchema("Optional marker of the element to capture instead of the full screenshot.").optional(),
+      boundingBox: z10.object({
+        x: z10.number().int().min(0).describe("The left edge of the bounding box in screenshot coordinates."),
+        y: z10.number().int().min(0).describe("The top edge of the bounding box in screenshot coordinates."),
+        width: z10.number().int().positive().describe("The width of the bounding box in screenshot pixels."),
+        height: z10.number().int().positive().describe("The height of the bounding box in screenshot pixels.")
+      }).optional().describe("Optional bounding box in screenshot coordinates for capturing only part of the current screenshot.")
+    })
+  },
+  wait: {
+    id: "wait",
+    description: "Wait the specified number of seconds before proceeding to the next action. Use when pages, elements, or processes need time to load or complete. No network idle check is performed after this tool.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      seconds: z10.number().min(1).describe("The number of seconds to wait (must be at least 1)")
+    })
+  },
+  notepad: {
+    id: "notepad",
+    description: "Append information to the session's persistent notepad. Each call adds to the end and does not overwrite existing notes. Notes persist between tool calls and can be accessed throughout the entire session.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      text: z10.string().describe("The text to write to the notepad")
+    })
+  },
+  setCheckpointId: {
+    id: "setCheckpointId",
+    description: "Set a context identifier for this agent run that labels all checkpoints within it. This allows filtering and grouping checkpoints by meaningful identifiers like patient ID, email, order number, etc. All iterations marked as checkpoints in this agent run will be associated with this identifier.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      name: z10.string().describe('The identifier name/type (e.g., "patientId", "email", "orderId")'),
+      value: z10.string().describe('The identifier value (e.g., "12345", "user@example.com", "ORD-789")')
+    })
+  },
+  checkpoint: {
+    id: "checkpoint",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  requestHumanIntervention: {
+    id: "requestHumanIntervention",
+    description: "Request intervention from a human. This tool should only be used when you are stuck and need to ask a human for help.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      pauseReason: z10.enum(["UNEXPECTED_BLOCKER", "HUMAN_INPUT_EXPLICITLY_REQUESTED"]).describe("The reason for requesting human intervention. Use UNEXPECTED_BLOCKER when encountering unexpected issues that prevent progress, or HUMAN_INPUT_EXPLICITLY_REQUESTED when pausing was requested in the instructions."),
+      message: z10.string().describe("The message to send to the human. This should be a clear and concise message that describes the problem you are facing.")
+    })
+  },
+  /**
+   * Should only be used in cases where markers are not being chosen correctly.
+   * Updating the system and user prompts should be the first resort.
+   */
+  somFilter: {
+    id: "somFilter",
+    description: "IMPORTANT: DO NOT USE THIS TOOL. You are only allowed to use this tool if user specifically asks you to use it.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      includeMarks: z10.object({
+        tagNames: z10.array(z10.string()),
+        additionalLegendAttributes: z10.array(z10.string()).optional()
+      }).describe("The marker tagNames to include").optional(),
+      excludeMarks: z10.object({
+        tagNames: z10.array(z10.string())
+      }).describe("The marker tagNames to exclude").optional(),
+      clearFilters: z10.boolean().default(false).describe("Whether to clear current som filter")
+    })
+  },
+  fillCredential: {
+    id: "fillCredential",
+    description: "Enter a saved credential (e.g., username, password, or code) into the specified input field marked by a given marker. **You are only allowed to use this tool if user specifically asks you to use it.**",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      marker: markerSchema("The marker to fill the credential into"),
+      credential: z10.object({
+        id: z10.string(),
+        type: z10.enum([
+          "email",
+          "username",
+          "password",
+          "authenticatorCode",
+          "phoneAuthenticatorCode"
+        ]),
+        args: z10.record(z10.string(), z10.unknown())
+      })
+    })
+  },
+  readRemoteFile: {
+    id: "readRemoteFile",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  listRemoteFiles: {
+    id: "listRemoteFiles",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  writeRemoteFile: {
+    id: "writeRemoteFile",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  writeRemoteFileFromStorage: {
+    id: "writeRemoteFileFromStorage",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  reloadPage: {
+    id: "experimental_reloadPage",
+    description: "Reload the current page.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  navigateBack: {
+    id: "navigateBack",
+    description: "Navigate the browser to the previous page in the history.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  getCurrentUrl: {
+    id: "getCurrentUrl",
+    description: "Get the current URL of the web page. Returns the full URL including protocol, domain, path, and query parameters.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  getSelectedText: {
+    id: "getSelectedText",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  notify: {
+    id: "notify",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  readDownloadedFile: {
+    id: "readDownloadedFile",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  fillCredentialsAndSubmit: {
+    id: "fillCredentialsAndSubmit",
+    description: "This object is deprecated, only adding here to satisfy the DB type check",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
+    })
+  },
+  callSpecializedAgent: {
+    id: "callSpecializedAgent",
+    description: "Call a specialized agent to complete a task.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      agent: agentToolSchema
+    })
+  },
+  queueAgents: {
+    id: "queueAgents",
+    description: "ONLY USE THIS IF EXPLICITLY MENTIONED IN THE INSTRUCTIONS. Queue a list of agents. When waitUponQueueing is true, this waits for every queued workflow in the call and returns their outputs.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      idempotencyKey: z10.string().optional(),
+      waitUponQueueing: z10.boolean().optional().describe("Applies to every queued agent in this call. If true, wait for all queued workflows to finish and return their outputs before continuing."),
+      queueItems: z10.array(agentToolSchema)
+    })
+  },
+  callAPI: {
+    id: "callAPI",
+    description: "Call an API to complete a task.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      api: z10.unknown()
+    })
+  },
+  generateObject: {
+    id: "generateObject",
+    description: "Generate an object using the AI.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      model: modelConfigSchema,
+      prompt: z10.string().describe("The prompt to use for the generation."),
+      successMessage: z10.string().optional().describe("The success message to use for the generation."),
+      schema: z10.custom().describe("The output schema to use for the generation."),
+      fileAssets: z10.array(z10.string()).optional().describe("The file assets to use for the generation.")
+    })
+  }
+};
+var triggerAgentToolDeclarations = {
+  queueAgents: {
+    id: "queueAgents",
+    description: "ONLY USE THIS IF EXPLICITLY MENTIONED IN THE INSTRUCTIONS. Queue a list of agents. When waitUponQueueing is true, this waits for every queued workflow in the call and returns their outputs.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      idempotencyKey: z10.string().optional().describe("ONLY CALL THIS IF EXPLICITLY CALLED OUT, OTHERWISE LEAVE EMPTY. A unique identifier for this specific agent run to ensure exactly-once execution. If provided, the system guarantees that multiple queue operations with the same ID will only be executed once."),
+      runTime: z10.string().datetime({
+        local: false
+      }).optional().describe("When should this run? ONLY CALL THIS IF EXPLICITLY CALLED OUT, OTHERWISE LEAVE EMPTY. Date time is in UTC and is a JS date string."),
+      waitUponQueueing: z10.boolean().optional().describe("Applies to every queued agent in this call. If true, wait for all queued workflows to finish and return their outputs before continuing."),
+      queueItems: z10.array(agentToolSchema)
+    })
+  },
+  callSpecializedAgent: {
+    id: "callSpecializedAgent",
+    description: "Call a specialized agent to complete a task.",
+    parameters: z10.object({
+      [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
+      agent: agentToolSchema
+    })
+  }
+};
+var baseToolNames = Object.keys(baseToolDeclarations);
+var triggerAgentToolNames = Object.keys(triggerAgentToolDeclarations);
+var allToolNames = [
+  ...baseToolNames,
+  ...triggerAgentToolNames
+];
+function markerSchema(description) {
+  return z10.string().describe(`${description}
+ MUST match this regex: /^[A-NP-Z][1-9]$/`);
+}
+
+// ../common/dist/src/zod-schemas/agent-config.schema.js
+import { z as z15 } from "zod";
+
+// ../common/dist/src/zod-schemas/api-request-body.schema.js
+import { z as z11 } from "zod";
+var ApiRequestBodyTypes = [
+  "json",
+  "multipartFormData",
+  "formUrlEncoded"
+];
+var ApiMethodsWithBody = ["POST", "PUT", "PATCH", "DELETE"];
+var ApiMultipartFormDataFieldTypes = ["text", "file"];
+var apiMultipartFormDataFieldSchema = z11.object({
+  key: z11.string().describe("Form field name."),
+  type: z11.enum(ApiMultipartFormDataFieldTypes).optional().describe("Form field type. Defaults to text when omitted. Use file to upload a file asset selected from available inputs."),
+  value: z11.string().describe("Form field value.")
+}).describe("A multipart form-data field. Defaults to a text field when type is omitted.");
+var apiMultipartFormDataBodySchema = z11.array(apiMultipartFormDataFieldSchema).describe("Multipart form-data body represented as an array of typed form-data fields.");
+var apiFormUrlEncodedFieldSchema = z11.object({
+  key: z11.string().describe("Form field name."),
+  value: z11.string().describe("Form field value.")
+}).describe("A form URL-encoded field.");
+var apiFormUrlEncodedBodySchema = z11.array(apiFormUrlEncodedFieldSchema).describe("Form URL-encoded body represented as an array of key/value fields.");
+function isValidApiMultipartFormDataBody({ bodyType, body }) {
+  if (bodyType !== "multipartFormData" || body === void 0) {
+    return true;
+  }
+  return apiMultipartFormDataBodySchema.safeParse(body).success;
+}
+function isValidApiFormUrlEncodedBody({ bodyType, body }) {
+  if (bodyType !== "formUrlEncoded" || body === void 0) {
+    return true;
+  }
+  return apiFormUrlEncodedBodySchema.safeParse(body).success;
+}
+
+// ../common/dist/src/zod-schemas/api-tool.schema.js
+import { z as z12 } from "zod";
+
+// ../common/dist/src/zod-schemas/enums.js
+var IdentifierTypes = {
+  password: "password",
+  username: "username",
+  email: "email",
+  authenticatorCode: "authenticatorCode",
+  otp: "otp"
+};
+var RunStatuses = {
+  queued: "QUEUED",
+  running: "RUNNING",
+  complete: "COMPLETE",
+  pausedAsInstructed: "PAUSED_AS_INSTRUCTED",
+  // Deprecated: use PAUSED status
+  pausedForTestConfirmation: "PAUSED_FOR_TEST_CONFIRMATION",
+  incompleteDueToError: "INCOMPLETE_DUE_TO_ERROR",
+  manuallyStopped: "MANUALLY_STOPPED",
+  pausedDueToUnforeseenBlocker: "PAUSED_DUE_TO_UNFORESEEN_BLOCKER",
+  inconsistentResults: "INCONSISTENT_RESULTS",
+  paused: "PAUSED"
+};
+var RUNNING_STATUSES = /* @__PURE__ */ new Set([
+  RunStatuses.queued,
+  RunStatuses.running,
+  RunStatuses.pausedAsInstructed,
+  RunStatuses.pausedDueToUnforeseenBlocker,
+  RunStatuses.paused
+]);
+var PAUSED_STATUSES = /* @__PURE__ */ new Set([
+  RunStatuses.pausedAsInstructed,
+  RunStatuses.pausedDueToUnforeseenBlocker,
+  RunStatuses.paused
+]);
+var STOPPED_STATUSES = /* @__PURE__ */ new Set([
+  RunStatuses.complete,
+  RunStatuses.incompleteDueToError,
+  RunStatuses.manuallyStopped,
+  RunStatuses.inconsistentResults
+]);
+var RunStatusStateMachine = new StateMachine({
+  states: Object.values(RunStatuses),
+  transitions: {
+    [RunStatuses.queued]: [
+      RunStatuses.running,
+      RunStatuses.incompleteDueToError,
+      RunStatuses.manuallyStopped
+    ],
+    [RunStatuses.running]: [
+      RunStatuses.pausedAsInstructed,
+      RunStatuses.pausedDueToUnforeseenBlocker,
+      RunStatuses.paused,
+      RunStatuses.incompleteDueToError,
+      RunStatuses.manuallyStopped,
+      RunStatuses.complete,
+      RunStatuses.inconsistentResults
+    ],
+    [RunStatuses.pausedAsInstructed]: [
+      RunStatuses.running,
+      RunStatuses.incompleteDueToError,
+      RunStatuses.manuallyStopped,
+      /*
+       * Handles race condition: If agent tries to pause at the same time (i.e. before we handle the
+       * user set pause in the DB) we want to show the agent's pause message over the
+       * non-descriptive one given when the automation is paused by the user.
+       */
+      RunStatuses.pausedDueToUnforeseenBlocker,
+      /*
+       * Handles race condition: If agent requests confirmation while user pauses, allow the agent
+       * to set PAUSED status (with statusDetail) to provide context about what needs confirmation.
+       */
+      RunStatuses.paused,
+      /*
+       * The agent will complete its current action before it is paused, that action could be
+       * reportStop, which would cause the automation to be marked as complete.
+       */
+      RunStatuses.complete
+    ],
+    [RunStatuses.pausedDueToUnforeseenBlocker]: [
+      RunStatuses.running,
+      RunStatuses.incompleteDueToError,
+      RunStatuses.manuallyStopped
+    ],
+    [RunStatuses.paused]: [
+      RunStatuses.running,
+      RunStatuses.incompleteDueToError,
+      RunStatuses.manuallyStopped
+    ],
+    [RunStatuses.incompleteDueToError]: [],
+    [RunStatuses.manuallyStopped]: [],
+    [RunStatuses.complete]: [],
+    [RunStatuses.inconsistentResults]: []
+  }
+});
+var BrowserProviderNames = {
+  local: "local",
+  browserbase: "browserbase",
+  agentcore: "agentcore",
+  hyperbrowser: "hyperbrowser",
+  steel: "steel"
+};
+var VoiceProviderNames = {
+  vapi: "vapi"
+};
+var EvalRunStatuses = {
+  queued: "QUEUED",
+  running: "RUNNING",
+  complete: "COMPLETE",
+  failed: "FAILED",
+  cancelled: "CANCELLED"
+};
+var EVAL_RUNNING_STATUSES = /* @__PURE__ */ new Set([
+  EvalRunStatuses.queued,
+  EvalRunStatuses.running
+]);
+var EVAL_STOPPED_STATUSES = /* @__PURE__ */ new Set([
+  EvalRunStatuses.complete,
+  EvalRunStatuses.failed,
+  EvalRunStatuses.cancelled
+]);
+var EvalRunStatusStateMachine = new StateMachine({
+  states: Object.values(EvalRunStatuses),
+  transitions: {
+    [EvalRunStatuses.queued]: [
+      EvalRunStatuses.running,
+      EvalRunStatuses.failed,
+      EvalRunStatuses.cancelled
+    ],
+    [EvalRunStatuses.running]: [
+      EvalRunStatuses.complete,
+      EvalRunStatuses.failed,
+      EvalRunStatuses.cancelled
+    ],
+    [EvalRunStatuses.complete]: [],
+    [EvalRunStatuses.failed]: [],
+    [EvalRunStatuses.cancelled]: []
+  }
+});
+var ErrorCategorizations = {
+  toolCallFailed: "TOOL_CALL_FAILED",
+  noToolInStep: "NO_TOOL_IN_STEP",
+  pageLoadingIssue: "PAGE_LOADING_ISSUE",
+  captchaBlocker: "CAPTCHA_BLOCKER",
+  loginCredentialsRequired: "LOGIN_CREDENTIALS_REQUIRED",
+  serverError: "SERVER_ERROR",
+  elementNotFound: "ELEMENT_NOT_FOUND",
+  sessionError: "SESSION_ERROR",
+  dataExtractionIssue: "DATA_EXTRACTION_ISSUE",
+  authenticationFailed: "AUTHENTICATION_FAILED",
+  navigationIssue: "NAVIGATION_ISSUE",
+  unstablePageState: "UNSTABLE_PAGE_STATE",
+  other: "OTHER",
+  // Step-following analysis categories
+  repeatAction: "REPEAT_ACTION",
+  stepSkipped: "STEP_SKIPPED",
+  unexpectedDeviation: "UNEXPECTED_DEVIATION",
+  attemptedRecovery: "ATTEMPTED_RECOVERY",
+  unusualPath: "UNUSUAL_PATH"
+};
+var STEP_FOLLOWING_CATEGORIZATIONS = /* @__PURE__ */ new Set([
+  ErrorCategorizations.repeatAction,
+  ErrorCategorizations.stepSkipped,
+  ErrorCategorizations.unexpectedDeviation,
+  ErrorCategorizations.attemptedRecovery,
+  ErrorCategorizations.unusualPath
+]);
+var ERROR_CATEGORIZATION_LIST = [
+  ...Object.values(ErrorCategorizations).filter((category) => category !== ErrorCategorizations.other && category !== ErrorCategorizations.attemptedRecovery && category !== ErrorCategorizations.unusualPath),
+  ErrorCategorizations.other
+];
+var ERROR_CATEGORIZATION_DESCRIPTIONS = {
+  [ErrorCategorizations.toolCallFailed]: "A tool failed but the specific reason is unclear or does not fit other categories. Only use this as a fallback when none of the other categories clearly apply.",
+  [ErrorCategorizations.noToolInStep]: 'No tool is mentioned in the instructions for this step. Common phrases: "no tool", "missing tool", "tool not specified".',
+  [ErrorCategorizations.pageLoadingIssue]: 'Page is blank, not loading, taking too long to load, or requires waiting for loading to complete. Common phrases: "blank page", "not loading", "loading timeout", "page timeout", "still loading".',
+  [ErrorCategorizations.captchaBlocker]: 'CAPTCHA or reCAPTCHA challenge appeared and requires human intervention to solve. Common phrases: "CAPTCHA", "reCAPTCHA", "challenge", "verification required".',
+  [ErrorCategorizations.loginCredentialsRequired]: 'Login page appeared, credentials are required, password/username fields need to be filled, or login instructions are needed. Common phrases: "login page", "credentials required", "missing password", "missing username", "authentication required".',
+  [ErrorCategorizations.serverError]: 'Server or service errors. Common: "500", "502", "503", "504", "service unavailable", "internal server error".',
+  [ErrorCategorizations.sessionError]: 'Browser/remote session or connection failures Common: "browserType.connectOverCDP", "connection timeout", "browserbase", "session disconnected".',
+  [ErrorCategorizations.elementNotFound]: 'Unable to locate or find a required element on the page. Common phrases: "cannot find", "unable to find", "element not found", "button not found", "field not found" (button, field, dropdown, link, etc.).',
+  [ErrorCategorizations.dataExtractionIssue]: 'Issue extracting, finding, or reading required data from the page. Common phrases: "cannot extract", "unable to read", "data not found", "cannot find data" (tables, text, values, forms).',
+  [ErrorCategorizations.authenticationFailed]: 'Authentication or login attempt failed. Common phrases: "authentication failed", "login failed", "invalid credentials", "locked account", "expired session", "2FA required".',
+  [ErrorCategorizations.navigationIssue]: 'Navigation problem. Common phrases: "wrong page", "redirect issue", "URL error", "cannot reach site", "SSL error", "navigation failed".',
+  [ErrorCategorizations.unstablePageState]: 'Page changed unexpectedly between decision and execution. Common: "markers moved", "page state changed", "unstable session state", "screenshot inconsistency".',
+  [ErrorCategorizations.other]: "Other types of errors not covered above",
+  [ErrorCategorizations.repeatAction]: "Agent repeated an action that caused critical real-world side effects (e.g., duplicate submissions, repeated sends).",
+  [ErrorCategorizations.stepSkipped]: "Agent skipped a required step, causing missed real-world effects or derailing positioning for future steps.",
+  [ErrorCategorizations.unexpectedDeviation]: "Agent performed an unauthorized action that caused critical impact (e.g., submitted unplanned data, took destructive actions).",
+  [ErrorCategorizations.attemptedRecovery]: "Agent deviated from instructions but was performing valid recovery (e.g., navigating back, re-logging in, retracing steps).",
+  [ErrorCategorizations.unusualPath]: "Agent took a different path than instructed but with no critical impact and no clear recovery intent."
+};
+var ERROR_CATEGORIZATION_LABEL = {
+  [ErrorCategorizations.toolCallFailed]: "Tool call failed",
+  [ErrorCategorizations.noToolInStep]: "No tool in step",
+  [ErrorCategorizations.pageLoadingIssue]: "Page loading issue",
+  [ErrorCategorizations.captchaBlocker]: "Captcha blocker",
+  [ErrorCategorizations.loginCredentialsRequired]: "Login credentials required",
+  [ErrorCategorizations.serverError]: "Server error",
+  [ErrorCategorizations.sessionError]: "Session error",
+  [ErrorCategorizations.unstablePageState]: "Unstable page state",
+  [ErrorCategorizations.elementNotFound]: "Element not found",
+  [ErrorCategorizations.dataExtractionIssue]: "Data extraction issue",
+  [ErrorCategorizations.authenticationFailed]: "Authentication failed",
+  [ErrorCategorizations.navigationIssue]: "Navigation issue",
+  [ErrorCategorizations.other]: "Other",
+  [ErrorCategorizations.repeatAction]: "Repeat action",
+  [ErrorCategorizations.stepSkipped]: "Step skipped",
+  [ErrorCategorizations.unexpectedDeviation]: "Unexpected deviation",
+  [ErrorCategorizations.attemptedRecovery]: "Attempted recovery",
+  [ErrorCategorizations.unusualPath]: "Unusual path"
+};
+
+// ../common/dist/src/zod-schemas/api-tool.schema.js
+var methodsWithBody = new Set(ApiMethodsWithBody);
+var SECONDS_PER_DAY = 24 * 60 * 60;
+var API_RESPONSE_CACHE_DEFAULT_TTL_DAYS = 7;
+var API_RESPONSE_CACHE_DEFAULT_TTL_SECONDS = API_RESPONSE_CACHE_DEFAULT_TTL_DAYS * SECONDS_PER_DAY;
+var defaultApiResponseCacheConfig = {
+  enabled: false,
+  ttl: API_RESPONSE_CACHE_DEFAULT_TTL_SECONDS
+};
+var apiResponseCacheConfigObjectSchema = z12.object({
+  enabled: z12.boolean().default(defaultApiResponseCacheConfig.enabled).describe("Whether API response caching is enabled for this request."),
+  ttl: z12.number().int().positive().default(defaultApiResponseCacheConfig.ttl).describe("Time-to-live for cached successful API responses, measured in seconds.")
+});
+var apiResponseCacheConfigSchema = apiResponseCacheConfigObjectSchema.optional().describe("Response cache configuration. Successful API responses can be reused across runs for identical rendered requests, with TTL measured in seconds.");
+var apiToolSchema = z12.object({
+  name: z12.string().describe("Unique name for the API tool."),
+  description: z12.string().describe("Description of what the API tool does. Shown to the agent to help it decide when to use this tool."),
+  inputSchema: z12.custom().optional().describe("JSON schema (in serialized Zod format) defining the input parameters for the API call."),
+  authInputs: z12.array(z12.object({
+    key: z12.string().describe("Parameter key where the auth value will be injected."),
+    value: z12.object({
+      authId: z12.string().describe("ID of the authentication credential to use."),
+      factor: z12.enum(IdentifierTypes).optional().describe("Type of authentication factor.")
+    })
+  })).optional().describe("Authentication inputs to inject into the API call. Maps parameter keys to saved credentials."),
+  type: z12.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method for the API call."),
+  url: z12.string().describe("URL template for the API endpoint. Can include placeholders like {paramName} for dynamic values."),
+  headers: z12.record(z12.string(), z12.string()).optional().describe("HTTP headers to include in the request. Values can include placeholders."),
+  queryParams: z12.record(z12.string(), z12.string()).optional().describe("Query parameters to include in the URL. Values can include placeholders."),
+  body: z12.unknown().optional().describe("Request body template. Can include placeholders for dynamic values."),
+  bodyType: z12.enum(ApiRequestBodyTypes).optional().describe("Request body encoding mode. Defaults to JSON when omitted. Use multipartFormData for typed form-data fields and formUrlEncoded for application/x-www-form-urlencoded payloads."),
+  outputJmesPath: z12.string().optional().describe("JMESPath expression to extract specific data from the API response before returning it to the agent."),
+  cacheResponse: apiResponseCacheConfigSchema
+}).refine((data) => !(data.bodyType !== void 0 && !methodsWithBody.has(data.type)), {
+  message: "Body type is not supported for this method",
+  path: ["bodyType"]
+}).refine((data) => isValidApiMultipartFormDataBody({
+  bodyType: data.bodyType,
+  body: data.body
+}), {
+  message: "Multipart form-data body must be an array of { key, type?, value } fields",
+  path: ["body"]
+}).refine((data) => isValidApiFormUrlEncodedBody({
+  bodyType: data.bodyType,
+  body: data.body
+}), {
+  message: "Form URL-encoded body must be an array of { key, value } fields",
+  path: ["body"]
+}).describe("Custom API tool definition. Allows agents to make HTTP requests to external APIs.");
+
+// ../common/dist/src/zod-schemas/run-limitation.schema.js
+import { z as z13 } from "zod";
+var MAX_BROWSER_SESSION_DURATION_SECONDS = 6 * 60 * 60;
+var BROWSER_TERMINATION_BUFFER_SECONDS = 60;
+var MAX_AUTOMATION_DURATION_SECONDS = MAX_BROWSER_SESSION_DURATION_SECONDS - BROWSER_TERMINATION_BUFFER_SECONDS;
+var MAX_AUTOMATION_TOOL_CALLS = 500;
+var MAX_AGENT_TOOL_CALLS = 50;
+var maxDurationSecondsSchema = z13.number().min(1).max(MAX_AUTOMATION_DURATION_SECONDS).optional().default(MAX_AUTOMATION_DURATION_SECONDS).describe("Maximum execution duration in seconds. The run will be terminated if it exceeds this limit.");
+var baseRunLimitationSchema = z13.object({
+  maxDurationSeconds: maxDurationSecondsSchema,
+  maxToolCalls: z13.number().optional().describe("Maximum number of tool calls allowed. The run will pause with MAX_TOOL_CALLS_REACHED when exceeded."),
+  allowedUrlRegexes: z13.array(z13.string()).optional().describe("Array of regex patterns for URLs the agent is allowed to navigate to. If specified, navigation to non-matching URLs will be blocked.")
+});
+var automationRunLimitationSchema = baseRunLimitationSchema.extend({
+  maxToolCalls: z13.number().optional().default(MAX_AUTOMATION_TOOL_CALLS).describe("Maximum number of tool calls allowed across all agents in the automation.")
+}).optional().default({
+  maxDurationSeconds: MAX_AUTOMATION_DURATION_SECONDS,
+  maxToolCalls: MAX_AUTOMATION_TOOL_CALLS
+}).describe("Resource limits for the automation run.");
+var agentRunLimitationSchema = baseRunLimitationSchema.extend({
+  maxToolCalls: z13.number().optional().default(MAX_AGENT_TOOL_CALLS).describe("Maximum number of tool calls allowed for this agent.")
+}).optional().default({
+  maxDurationSeconds: MAX_AUTOMATION_DURATION_SECONDS,
+  maxToolCalls: MAX_AGENT_TOOL_CALLS
+}).describe("Resource limits for the agent run.");
+
+// ../common/dist/src/zod-schemas/voice-provider-options.schema.js
+import { z as z14 } from "zod";
+var voiceParticipantSchema = z14.object({
+  number: z14.string().min(1).optional().describe("Default phone number or endpoint to use for this call participant. Accepts a literal value or a Handlebars template with agent, shared, and context inputs."),
+  name: z14.string().min(1).optional().describe("Display name to associate with this call participant.")
+}).describe("Default voice call participant settings.");
+var vapiVoiceProviderOptionsSchema = z14.object({
+  assistantId: z14.string().min(1).optional().describe("Existing Vapi assistant ID to start or hand off the call to."),
+  assistant: z14.record(z14.string(), z14.unknown()).optional().describe("Inline Vapi assistant definition used when an explicit assistantId is not provided."),
+  assistantOverrides: z14.record(z14.string(), z14.unknown()).optional().describe("Runtime assistant override payload forwarded to Vapi when starting or handing off a call."),
+  caller: voiceParticipantSchema.optional().describe("Default caller settings for outbound calls."),
+  callee: voiceParticipantSchema.optional().describe("Default callee settings for outbound calls."),
+  phoneNumberId: z14.string().min(1).optional().describe("Vapi phone number ID used to originate outbound calls."),
+  enableDtmf: z14.boolean().optional().describe("Whether the call should support DTMF input.")
+}).describe("Configuration options specific to the Vapi voice provider.");
+var voiceProviderOptionsSchema = z14.object({
+  vapi: vapiVoiceProviderOptionsSchema.optional().describe("Configuration options specific to the Vapi provider.")
+}).describe("Provider-specific voice configuration options. Only the options for the selected voiceProvider are used.");
+
+// ../common/dist/src/zod-schemas/agent-config.schema.js
+var NangoSupportedMethods = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE"
+];
+var startingUrlSchema = z15.string().refine(isValidUrlOrHandlebarsTemplateString, {
+  message: "Starting URL must be a valid URL or Handlebars template"
+}).optional();
+var browserSOMEnvironmentOptionsSchema = z15.object({
+  environment: z15.literal("browser").describe("Browser environment using Set of Marks (SOM) for element identification."),
+  maxMediaToIncludeInMemory: z15.number().min(1).optional().describe("Maximum number of screenshots/media items to keep in the agent memory context."),
+  saveAuthCookiesAfterRun: z15.boolean().optional().describe("Whether to save authentication cookies after the run completes for reuse in future runs."),
+  startingUrl: startingUrlSchema.describe("Initial URL to navigate to when the agent starts. Accepts a valid URL or a Handlebars template with agent inputs. If not provided, uses the current URL of the browser; if this is the first agent, it will be a blank page."),
+  browserProvider: z15.nativeEnum(BrowserProviderNames).default(BrowserProviderNames.browserbase).describe("Browser provider to use if this agent is the first in a run to create a browser."),
+  browserProviderOptions: browserProviderOptionsSchema.optional().describe("Provider-specific configuration options for the browser.")
+}).describe("Browser environment configuration using Set of Marks (SOM) for element identification. This is the recommended browser mode for most use cases.");
+var browserCoordinatesEnvironmentOptionsSchema = z15.object({
+  environment: z15.literal("browserCoordinates").describe("Browser environment using coordinate-based interactions instead of SOM."),
+  maxMediaToIncludeInMemory: z15.number().min(1).optional().describe("Maximum number of screenshots/media items to keep in the agent memory context."),
+  saveAuthCookiesAfterRun: z15.boolean().optional().describe("Whether to save authentication cookies after the run completes for reuse in future runs."),
+  startingUrl: startingUrlSchema.describe("Initial URL to navigate to when the agent starts. Accepts a valid URL or a Handlebars template with agent inputs. If not provided, uses the current URL of the browser; if this is the first agent, it will be a blank page."),
+  browserProvider: z15.nativeEnum(BrowserProviderNames).default(BrowserProviderNames.browserbase).describe("Browser provider to use if this agent is the first in a run to create a browser."),
+  browserProviderOptions: browserProviderOptionsSchema.optional().describe("Provider-specific configuration options for the browser.")
+}).describe("Browser environment configuration using coordinate-based interactions. Use for scenarios where SOM-based identification is insufficient.");
+var guacamoleEnvironmentOptionsSchema = z15.object({
+  environment: z15.literal("desktop").describe("Desktop environment using Guacamole for remote desktop access."),
+  browserProvider: z15.nativeEnum(BrowserProviderNames).default(BrowserProviderNames.browserbase).describe("Browser provider to use to connect to Guacamole."),
+  browserProviderOptions: browserProviderOptionsSchema.optional().describe("Provider-specific configuration options."),
+  maxMediaToIncludeInMemory: z15.number().min(1).optional().describe("Maximum number of screenshots/media items to keep in the agent memory context."),
+  startingUrl: startingUrlSchema.describe("Initial URL for the Guacamole connection. Accepts a valid URL or a Handlebars template with agent inputs."),
+  useCopyPasteForTyping: z15.boolean().default(false).optional().describe("Use copy-paste instead of keystroke simulation for text input. Can improve reliability in some desktop applications.")
+}).describe("Desktop environment configuration using Guacamole for remote desktop automation.");
+var desktopAppEnvironmentOptionsSchema = z15.object({
+  environment: z15.literal("desktopApp").describe("Native application environment for mobile or desktop app automation."),
+  maxMediaToIncludeInMemory: z15.number().min(1).optional().describe("Maximum number of screenshots/media items to keep in the agent memory context."),
+  viewport: viewportSizeSchema.optional().describe(`Target viewport dimensions for screenshots and coordinate-based actions. Defaults to ${BROWSER_DEFAULT_VIEWPORT.width}x${BROWSER_DEFAULT_VIEWPORT.height} when omitted.`)
+}).describe("Native application environment configuration for automating mobile or desktop applications.");
+var minimalEnvironmentOptionsSchema = z15.object({
+  environment: z15.literal("minimal").describe("Minimal environment without browser or desktop capabilities. Use for non-UI agents.")
+}).describe("Minimal environment configuration for agents that do not require browser or desktop access (e.g., API-only agents).");
+var voiceEnvironmentOptionsSchema = z15.object({
+  environment: z15.literal("voice").describe("Hosted voice environment for live phone or audio conversations."),
+  voiceProvider: z15.nativeEnum(VoiceProviderNames).default(VoiceProviderNames.vapi).describe("Voice provider to use if this agent is the first in a run to create or attach to a live call."),
+  voiceProviderOptions: voiceProviderOptionsSchema.optional().describe("Provider-specific configuration options for voice runtime.")
+}).describe("Voice environment configuration for hosted conversational runtimes such as Vapi.");
+var environmentOptionsSchema = z15.discriminatedUnion("environment", [
+  browserSOMEnvironmentOptionsSchema,
+  browserCoordinatesEnvironmentOptionsSchema,
+  guacamoleEnvironmentOptionsSchema,
+  desktopAppEnvironmentOptionsSchema,
+  voiceEnvironmentOptionsSchema,
+  minimalEnvironmentOptionsSchema
+]).describe("Environment configuration for the agent. Determines the execution context.");
+var environmentNames = [
+  "browser",
+  "browserCoordinates",
+  "desktop",
+  "desktopApp",
+  "voice",
+  "minimal"
+];
+var environmentNamesSchema = z15.enum(environmentNames).describe("Available environment types: browser (SOM-based), browserCoordinates (coordinate-based), desktop (Guacamole), desktopApp, voice, or minimal.");
+var DEFAULT_ENVIRONMENT_OPTION = environmentOptionsSchema.parse({
+  environment: "browser"
+});
+var resourcePoolReferenceSchema = z15.object({
+  id: z15.string().uuid().describe("Unique identifier of the resource pool."),
+  type: z15.enum([
+    "commandGenerated",
+    "proxy",
+    "apiAuthentication",
+    "desktopAppAuthentication"
+  ]).nullable().optional().describe("Resource pool type: commandGenerated (dynamic resources), proxy (proxy pool for browser sessions), apiAuthentication (authentication pool for API agents), or desktopAppAuthentication (desktop app pool for native desktop sessions).")
+});
+var resourcePoolsSchema = z15.array(resourcePoolReferenceSchema).max(5, "Only five resource pools per starting agent are currently supported").optional();
+var agentRunSettingsSchema = z15.object({
+  environmentOptions: environmentOptionsSchema.optional().describe("Canonical run-level browser/session settings used when this agent is selected as the run settings source. Agent-owned fields such as startingUrl and maxMediaToIncludeInMemory are intentionally ignored at runtime even if present here."),
+  resourcePools: resourcePoolsSchema.describe("Managed resource pools used when this agent is selected as the run settings source. These may be persisted on any agent even when that agent is not currently a top-level run settings source."),
+  skipBrowserDebuggerPauses: z15.boolean().optional().describe("Run-level browser session startup setting. When run settings mode is active, this value is snapshotted from runSettings and legacy agent-local values are ignored.")
+});
+var remoteFileConnectionSchema = z15.object({
+  description: z15.string().describe("Human-readable description of this remote file connection."),
+  host: z15.string().describe("Hostname or IP address of the remote server."),
+  port: z15.number().describe("Port number for the connection (e.g., 22 for SFTP)."),
+  protocol: z15.enum(["sftp"]).describe("Protocol to use for the connection. Currently only SFTP is supported."),
+  opItemId: z15.string().describe("1Password item ID containing the credentials."),
+  opVaultId: z15.string().describe("1Password vault ID containing the item.")
+}).describe("Remote file connection configuration for SFTP access. Credentials are stored securely in 1Password.");
+var workflowIdReusePolicySchema = z15.enum(["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY"]).describe("Controls Temporal workflow ID reuse. ALLOW_DUPLICATE allows rerunning with the same ID. ALLOW_DUPLICATE_FAILED_ONLY only allows reuse if the previous run failed.");
+var codeLanguages = ["typescript"];
+var windowsAbsolutePathPattern = /^[A-Za-z]:[\\/]/u;
+function hasControlCharacter(value) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint !== void 0 && (codePoint <= 31 || codePoint === 127)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isNormalizedRepoPath(path7) {
+  if (path7 === "/") {
+    return true;
+  }
+  if (path7.length === 0 || path7.startsWith("/") || path7.startsWith("\\") || path7.includes("\\") || hasControlCharacter(path7) || windowsAbsolutePathPattern.test(path7)) {
+    return false;
+  }
+  return path7.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== ".." && segment !== ".git");
+}
+var knowledgeBasePluginPermissionSchema = z15.object({
+  path: z15.string().min(1).refine(isNormalizedRepoPath, {
+    message: "Path must be a normalized repository-relative path."
+  }).describe("Repository path the knowledge base plugin can access."),
+  access: z15.enum(["read", "write"]).describe("Access level for the path. Write access also grants reads.")
+}).describe("Path-scoped permission for the knowledge base runtime plugin.");
+var knowledgeBaseConfigSchema = z15.object({
+  enabled: z15.boolean().default(false).describe("Explicit rollout switch for the knowledge base runtime plugin."),
+  permissions: z15.array(knowledgeBasePluginPermissionSchema).min(1).describe("Repository paths the knowledge base plugin can access. Write grants read and write access.")
+}).describe("Configuration for the knowledge base runtime plugin.");
+var agentPluginsConfigSchema = z15.object({
+  knowledgeBase: knowledgeBaseConfigSchema.optional().describe("Enables the knowledge base runtime plugin.")
+}).optional().describe("Runtime plugins enabled for this agent. Plugin tools are not controlled by the built-in tools allow-list.");
+var baseAgentConfigFieldsSchema = z15.object({
+  apiTools: z15.array(apiToolSchema).optional().describe("Custom API tools available to this agent. Each tool defines an HTTP endpoint the agent can call."),
+  remoteFileConnections: z15.array(remoteFileConnectionSchema).optional().describe("Remote file server connections for SFTP operations. Enables agents to read/write files on remote servers."),
+  resourcePools: resourcePoolsSchema.describe("Deprecated compatibility shadow of runSettings.resourcePools. Keep mirrored with runSettings.resourcePools during the migration. New runtime logic should prefer runSettings.resourcePools. Maximum 5 pools per starting agent."),
+  tools: z15.array(z15.enum(baseToolNames)).optional().default(() => []).describe("List of built-in tools enabled for this agent (e.g., click, clickFill, scroll, navigateTo). Note: reportStop is always included by default, callSpecializedAgent is included if the agent has child agents, and queueAgents is included if queueableAgentIds is configured. An empty array will still have these automatically included tools."),
+  knowledgeBase: z15.object({
+    namespace: z15.string().describe("Vector database namespace for knowledge retrieval."),
+    k: z15.number().describe("Number of results to retrieve from the knowledge base per query.")
+  }).optional().describe("Knowledge base configuration for RAG (Retrieval-Augmented Generation). Enables the agent to query a vector database."),
+  plugins: agentPluginsConfigSchema,
+  maxSessionMessages: z15.number().optional().describe("Maximum number of messages to keep in the agent session memory. Older messages are pruned to stay within this limit."),
+  environmentOptions: environmentOptionsSchema.optional().default(DEFAULT_ENVIRONMENT_OPTION).describe("Environment configuration for the agent. Default is browser with SOM."),
+  runSettings: agentRunSettingsSchema.optional().describe("Run settings persisted on the agent and used when this agent is selected as the settings source for a run while the run-settings rollout is enabled. This is the canonical runtime source for resource pools during the migration. It intentionally mirrors a subset of agent config so settings survive topology changes and can be stored on any agent regardless of that agent's own execution environment. Writers may populate this before the rollout flag is enabled, but runtime snapshotting must keep using legacy fields while the flag is disabled."),
+  skipBrowserDebuggerPauses: z15.boolean().optional().describe("Legacy agent-local browser session startup setting. Used only when a run is in legacy config mode; canonical run settings mode reads runSettings.skipBrowserDebuggerPauses instead."),
+  limitations: agentRunLimitationSchema.describe("Resource limits for this agent, including maximum duration and tool call limits."),
+  commonParametersSchema: z15.custom().optional().describe("Custom schema defining metadata the agent must provide with every tool call. By default, agents provide reasoning and step information. If specified, this schema replaces the default metadata schema entirely."),
+  idempotencySettings: z15.object({
+    include: z15.array(z15.string()).optional().describe("Input field names to include in the idempotency key. If specified, only these fields are used."),
+    exclude: z15.array(z15.string()).optional().describe("Input field names to exclude from the idempotency key. Ignored if include is specified."),
+    workflowIdReusePolicy: workflowIdReusePolicySchema.optional().default("ALLOW_DUPLICATE").describe("Policy for reusing Temporal workflow IDs.")
+  }).optional().describe("Idempotency settings for preventing duplicate runs. Controls which input fields contribute to the unique run identifier."),
+  taskQueue: z15.string().optional().describe("Temporal task queue name for this agent. If specified, queued child agents run on this queue instead of the parent queue."),
+  waitUponQueueing: z15.boolean().optional().default(false).describe("If true, wait for queued child agents to complete before proceeding."),
+  queueableAgentIds: z15.array(brandedStringValidator("agentId")).optional().default(() => []).describe("List of agent IDs that this agent can queue using the queueAgents tool. Enables the agent to run a new automation with a different agent as the starting point."),
+  checkpoint: z15.object({
+    name: z15.string().describe("Name for the checkpoint, used for filtering and identification."),
+    screenshot: z15.boolean().optional().default(false).describe("Whether to capture a screenshot when creating the checkpoint.")
+  }).optional().describe("Checkpoint configuration. When set, agent iterations are recorded as checkpoints for auditing and debugging."),
+  systemPrompt: z15.string().optional().describe("Custom system prompt that replaces the default system prompt for this agent. Combined with automation-level and agent-level additionalSystemPrompt values."),
+  additionalSystemPrompt: z15.string().optional().describe("Additional instructions appended to the system prompt for this agent. Combined with automation-level additionalSystemPrompt."),
+  // Backlinking metadata for imported agents
+  importedFrom: z15.object({
+    automationId: brandedStringValidator("draftAutomationId").describe("ID of the source automation from which this agent was imported."),
+    originalAgentId: brandedStringValidator("agentId").describe("Original agent ID in the source automation.")
+  }).optional().describe("Metadata for agents imported from another automation. Used for traceability and updates."),
+  ignoreUnstableSessionState: z15.boolean().optional().describe("When true, skips screenshot consistency checks before tool execution. Overrides the automation-level ignoreUnstableSessionState setting.")
+}).superRefine((config, ctx) => {
+  if (config.resourcePools !== void 0 && config.runSettings?.resourcePools !== void 0 && !isDeepEqualAndSameType(config.resourcePools, config.runSettings.resourcePools)) {
+    ctx.addIssue({
+      code: z15.ZodIssueCode.custom,
+      path: ["runSettings", "resourcePools"],
+      message: "runSettings.resourcePools must match resourcePools when both are provided"
+    });
+  }
+});
+var agenticAgentConfigSchema = baseAgentConfigFieldsSchema.safeExtend({
+  type: z15.literal("agentic").describe("Agentic agent type - autonomous AI agent with tool calling capabilities."),
+  model: agentModelConfigSchema.describe("LLM model configuration for this agentic agent.")
+}).describe("Agentic agent configuration. Uses an LLM to autonomously decide which tools to call to accomplish tasks.");
+var codeAgentConfigSchema = baseAgentConfigFieldsSchema.safeExtend({
+  type: z15.literal("code").describe("Code agent type - executes predefined code instead of LLM-driven decisions."),
+  language: z15.enum(codeLanguages).default("typescript").describe("Programming language for the agent code. Currently only TypeScript is supported.")
+}).describe("Code agent configuration. Executes predefined TypeScript code instead of using LLM-driven decision making.");
+var extractAgentConfigSchema = baseAgentConfigFieldsSchema.safeExtend({
+  type: z15.literal("extract").describe("Extract agent type - specialized for structured data extraction."),
+  model: agentModelConfigSchema.describe("LLM model configuration for this extract agent.")
+}).describe("Extract agent configuration. Specialized for extracting structured data from files according to a defined output schema.");
+var OutcomePayloadSchema = z15.object({
+  id: z15.string().min(1).describe("Unique identifier for the outcome."),
+  input: z15.record(z15.string(), z15.unknown()).describe("Input data for the outcome. Maps parameter keys to values."),
+  preview: z15.string().describe("Rendered text representation of the outcome.")
+});
+var branchAgentConfigSchema = baseAgentConfigFieldsSchema.safeExtend({
+  type: z15.literal("branch").describe("Branch agent type - makes decisions to route to different agents."),
+  model: agentModelConfigSchema.describe("LLM model configuration for this branch agent."),
+  conditionsAndOutcomes: z15.object({
+    if: z15.array(z15.object({
+      caseName: z15.string().describe("Name of the condition case."),
+      condition: z15.string().min(1).describe("Condition to evaluate."),
+      outcome: z15.array(OutcomePayloadSchema).describe("Outcomes to return if the condition is met.")
+    })).min(1).describe("Conditions and outcomes for the branch agent."),
+    else: z15.array(OutcomePayloadSchema).min(1).describe("Outcomes to return if the condition is not met.")
+  }).describe("Conditions and outcomes for the branch agent, including a fallback outcome.")
+}).describe("Branch agent configuration. Makes decisions about which agent to call next based on the current context.");
+var draftBranchAgentConfigSchema = baseAgentConfigFieldsSchema.safeExtend({
+  type: z15.literal("branch").describe("Branch agent draft configuration. Allows incomplete conditions and outcomes while the agent is still being authored."),
+  model: agentModelConfigSchema.describe("LLM model configuration for this branch agent."),
+  conditionsAndOutcomes: z15.object({
+    if: z15.array(z15.object({
+      caseName: z15.string().describe("Name of the condition case."),
+      condition: z15.string().describe("Condition to evaluate. Draft saves may include an empty placeholder while the user is still editing."),
+      outcome: z15.array(OutcomePayloadSchema).describe("Outcomes to return if the condition is met.")
+    })).describe("Draft branch conditions and outcomes."),
+    else: z15.array(OutcomePayloadSchema).describe("Draft fallback outcomes for the branch agent. May be empty while the branch is still being configured.")
+  }).describe("Draft conditions and outcomes for the branch agent, including an optional fallback outcome while editing.")
+}).describe("Branch agent draft configuration. More permissive than the authored branch schema so incomplete draft branches can be saved.");
+var METHODS_WITH_BODY = new Set(ApiMethodsWithBody);
+var apiAgentConfigSchema = baseAgentConfigFieldsSchema.safeExtend({
+  type: z15.literal("api").describe("API agent type - makes HTTP requests to external APIs."),
+  method: z15.enum(NangoSupportedMethods).describe("HTTP method for the API request (GET, POST, PUT, PATCH, DELETE)."),
+  url: z15.string().describe("URL for the API endpoint. Can include placeholders like {paramName} for dynamic values from inputs."),
+  headers: z15.array(z15.object({ key: z15.string(), value: z15.string() })).optional().describe("HTTP headers to include in the request. Values can include placeholders."),
+  queryParams: z15.array(z15.object({ key: z15.string(), value: z15.string() })).optional().describe("Query parameters to append to the URL. Values can include placeholders."),
+  body: z15.unknown().optional().describe("Request body for POST/PUT/PATCH requests. Can include placeholders for dynamic values."),
+  bodyType: z15.enum(ApiRequestBodyTypes).optional().describe("Request body encoding mode. Defaults to JSON when omitted. Use multipartFormData for typed form-data fields and formUrlEncoded for application/x-www-form-urlencoded payloads."),
+  outputJmesPath: z15.string().optional().describe("JMESPath expression to extract specific data from the API response before returning it."),
+  cacheResponse: apiResponseCacheConfigSchema.describe("Response cache configuration for this API agent. TTL is measured in seconds."),
+  authentication: z15.discriminatedUnion("type", [
+    z15.object({
+      type: z15.literal("nangoConnection").describe("Authentication via Nango integration."),
+      providerConfigKey: z15.string().describe('The provider config key for the integration (e.g., "github", "slack").'),
+      poolId: brandedStringValidator("resourcePoolId").optional().describe("ID of the resource pool containing authentication credentials.")
+    }),
+    z15.object({
+      type: z15.literal("customHost").describe("Authentication via 1Password credentials for custom host."),
+      poolId: brandedStringValidator("resourcePoolId").optional().describe("ID of the resource pool containing 1Password authentication.")
+    })
+  ]).optional().describe("Authentication configuration for the API request. Uses credentials from a resource pool.")
+}).refine((data) => !(data.body !== void 0 && !METHODS_WITH_BODY.has(data.method)), {
+  message: "Body is not supported for this method",
+  path: ["body"]
+}).refine((data) => !(data.bodyType !== void 0 && !METHODS_WITH_BODY.has(data.method)), {
+  message: "Body type is not supported for this method",
+  path: ["bodyType"]
+}).refine((data) => isValidApiMultipartFormDataBody({
+  bodyType: data.bodyType,
+  body: data.body
+}), {
+  message: "Multipart form-data body must be an array of { key, type?, value } fields",
+  path: ["body"]
+}).refine((data) => isValidApiFormUrlEncodedBody({
+  bodyType: data.bodyType,
+  body: data.body
+}), {
+  message: "Form URL-encoded body must be an array of { key, value } fields",
+  path: ["body"]
+}).describe("API agent configuration. Makes HTTP requests to external APIs without LLM decision making. Supports authentication via Nango connections.");
+var agentConfigSchemaUnion = z15.discriminatedUnion("type", [
+  agenticAgentConfigSchema,
+  codeAgentConfigSchema,
+  extractAgentConfigSchema,
+  branchAgentConfigSchema,
+  apiAgentConfigSchema
+]).describe("Agent configuration discriminated by type. Types: agentic (LLM-driven), code (predefined code), extract (data extraction), branch (routing decisions), api (HTTP requests).");
+var agentConfigSchema = z15.preprocess((data) => {
+  if (typeof data === "object" && data !== null && !("type" in data)) {
+    return { ...data, type: "agentic" };
+  }
+  return data;
+}, agentConfigSchemaUnion).describe("Agent configuration. Defines the agent type, environment, available tools, model settings, and behavior options. If type is omitted, defaults to agentic.");
+var draftAgentConfigSchemaUnion = z15.discriminatedUnion("type", [
+  agenticAgentConfigSchema,
+  codeAgentConfigSchema,
+  extractAgentConfigSchema,
+  draftBranchAgentConfigSchema,
+  apiAgentConfigSchema
+]).describe("Draft agent configuration discriminated by type. Uses a more permissive branch schema so incomplete branches can be saved before publish-time validation.");
+var draftAgentConfigSchema = z15.preprocess((data) => {
+  if (typeof data === "object" && data !== null && !("type" in data)) {
+    return { ...data, type: "agentic" };
+  }
+  return data;
+}, draftAgentConfigSchemaUnion).describe("Draft agent configuration. Matches authored validation for most agent types, but allows incomplete branch agents during draft saves.");
+var DEFAULT_AGENT_CONFIG = agentConfigSchema.parse({});
+
+// ../common/dist/src/zod-schemas/automation-run-config.schema.js
+import { z as z16 } from "zod";
+var automationRunResolvedRunSettingsSchema = z16.object({
+  environmentOptions: environmentOptionsSchema.describe("Canonical run-settings-owned environment settings snapshotted onto the automation run when it starts in runSettings mode. Agent-owned fields such as startingUrl and maxMediaToIncludeInMemory are intentionally ignored at runtime."),
+  resourcePools: resourcePoolsSchema.describe("Canonical run-settings-owned resource pools snapshotted onto the automation run when it starts in runSettings mode. Slot assignment and queue status use this only when resolvedRunSettingsSource is runSettings."),
+  skipBrowserDebuggerPauses: z16.boolean().optional().describe("Canonical run-settings-owned browser session startup setting snapshotted onto the automation run when it starts in runSettings mode.")
+});
+var CONSISTENCY_CHECK_COUNT_MAX = 50;
+var automationRunConfigSchema = z16.object({
+  approvalMode: z16.enum(["HUMAN_APPROVAL", "OFF"]).default("OFF"),
+  consistencyCheckCount: z16.number().int().nonnegative().max(CONSISTENCY_CHECK_COUNT_MAX).nullable().default(null),
+  settingsSourceAgentId: z16.uuid().nullable().optional().describe("Optional provenance/debug field recording which top-level agent supplied canonical run settings when the run started. Runtime consumers must not use this as a live pointer once resolvedRunSettingsSource has been decided."),
+  startInTakeOverMode: z16.boolean().default(false).describe("When true, create and prepare the remote session, then pause until a human manually starts the agent."),
+  resolvedRunSettings: automationRunResolvedRunSettingsSchema.optional().describe("Canonical run settings snapshotted onto the automation run at creation time. Present only for runSettings mode; legacyConfig mode intentionally resolves runtime settings from each current agent config instead of storing a misleading snapshot."),
+  resolvedRunSettingsSource: z16.enum(["runSettings", "legacyConfig"]).optional().describe("Runtime mode decided at run creation. runSettings means resolvedRunSettings is canonical for browser/session/resource-pool behaviour; legacyConfig means runtime consumers must use current agent legacy config fields.")
+});
+var automationRunStartConfigSchema = automationRunConfigSchema.omit({
+  resolvedRunSettings: true,
+  resolvedRunSettingsSource: true
+});
+
+// ../mcp-registry/src/operation-specs.ts
+import { z as z17 } from "zod";
+
+// ../mcp-registry/src/operation-spec.ts
+function stripLeadingGraphqlComments(document) {
+  return document.replace(/^(?:\s*#.*\n)+/u, "").trimStart();
+}
+function assertDocumentMatchesOperation({
+  document,
+  kind,
+  operationName
+}) {
+  const normalizedDocument = stripLeadingGraphqlComments(document);
+  const match = /^(?<actualKind>query|mutation)\s+(?<actualOperationName>[_A-Za-z][_0-9A-Za-z]*)/u.exec(
+    normalizedDocument
+  );
+  const actualKind = match?.groups?.["actualKind"];
+  const actualOperationName = match?.groups?.["actualOperationName"];
+  if (!actualKind || !actualOperationName) {
+    throw new Error(
+      `Operation "${operationName}" is missing a top-level GraphQL ${kind} definition.`
+    );
+  }
+  if (actualKind !== kind || actualOperationName !== operationName) {
+    throw new Error(
+      `Operation "${operationName}" does not match its GraphQL document (${actualKind} ${actualOperationName}).`
+    );
+  }
+}
+function createOperationSpec(spec) {
+  assertDocumentMatchesOperation(spec);
+  return spec;
+}
+
+// ../mcp-registry/src/operation-specs.ts
+function stringOption({
+  description,
+  flagName,
+  inputKey,
+  required = false
+}) {
+  return {
+    description,
+    flagName,
+    inputKey,
+    required,
+    valueType: "string"
+  };
+}
+function numberOption({
+  description,
+  flagName,
+  inputKey,
+  required = false
+}) {
+  return {
+    description,
+    flagName,
+    inputKey,
+    required,
+    valueType: "number"
+  };
+}
+function booleanOption({
+  description,
+  flagName,
+  inputKey
+}) {
+  return {
+    description,
+    flagName,
+    inputKey,
+    valueType: "boolean"
+  };
+}
+function stringArrayOption({
+  description,
+  flagName,
+  inputKey,
+  required = false
+}) {
+  return {
+    description,
+    flagName,
+    inputKey,
+    required,
+    valueHint: "comma-separated",
+    valueType: "string-array"
+  };
+}
+function jsonOption({
+  description,
   flagName,
   inputKey,
   required = false
@@ -7581,11 +9993,12 @@ function jsonOption({
     valueType: "json"
   };
 }
-var jsonObjectSchema = z2.record(z2.string(), z2.unknown());
+var jsonObjectSchema = z17.record(z17.string(), z17.unknown());
 var agentBrowserProviderOptionsSelection = `            browserbase {
               advancedStealth
               contextId
               extensionId
+              enablePdfViewer
               instanceSize
               blockAds
               solveCaptchas
@@ -7671,8 +10084,8 @@ var operationSpecs = [
   createOperationSpec({
     operationName: "GetAgents",
     kind: "query",
-    inputSchema: z2.object({
-      ids: z2.array(z2.string().min(1)).min(1)
+    inputSchema: z17.object({
+      ids: z17.array(z17.string().min(1)).min(1)
     }),
     cli: {
       name: "get-agents",
@@ -7720,6 +10133,10 @@ ${agentLimitationsSelection}
       systemPrompt
       additionalSystemPrompt
       ignoreUnstableSessionState
+      resourcePools {
+        id
+        type
+      }
     }
     childAgentIds
     }
@@ -7728,9 +10145,9 @@ ${agentLimitationsSelection}
   createOperationSpec({
     operationName: "GetAgentVersion",
     kind: "query",
-    inputSchema: z2.object({
-      agentId: z2.string().min(1),
-      versionId: z2.string().min(1)
+    inputSchema: z17.object({
+      agentId: z17.string().min(1),
+      versionId: z17.string().min(1)
     }),
     cli: {
       name: "get-agent-version",
@@ -7792,8 +10209,8 @@ ${agentLimitationsSelection}
   createOperationSpec({
     operationName: "GetAgentVersions",
     kind: "query",
-    inputSchema: z2.object({
-      agentId: z2.string().min(1)
+    inputSchema: z17.object({
+      agentId: z17.string().min(1)
     }),
     cli: {
       name: "get-agent-versions",
@@ -7827,10 +10244,10 @@ query GetAgentVersions($agentId: ID!) {
   createOperationSpec({
     operationName: "DiffAgentVersion",
     kind: "query",
-    inputSchema: z2.object({
-      agentId: z2.string().min(1),
-      versionId: z2.string().min(1),
-      compareVersionId: z2.string().min(1).optional()
+    inputSchema: z17.object({
+      agentId: z17.string().min(1),
+      versionId: z17.string().min(1),
+      compareVersionId: z17.string().min(1).optional()
     }),
     cli: {
       name: "diff-agent-version",
@@ -7884,8 +10301,8 @@ query DiffAgentVersion(
   createOperationSpec({
     operationName: "GetAgentRun",
     kind: "query",
-    inputSchema: z2.object({
-      id: z2.string().min(1)
+    inputSchema: z17.object({
+      id: z17.string().min(1)
     }),
     cli: {
       name: "get-agent-run",
@@ -7921,8 +10338,8 @@ query GetAgentRun($id: ID!) {
   createOperationSpec({
     operationName: "GetAutomationAgents",
     kind: "query",
-    inputSchema: z2.object({
-      ids: z2.array(z2.string().min(1)).min(1)
+    inputSchema: z17.object({
+      ids: z17.array(z17.string().min(1)).min(1)
     }),
     cli: {
       name: "get-automation-agents",
@@ -7960,13 +10377,67 @@ query GetAutomationAgents($ids: [ID!]!) {
       childAgentIds
     }
   }
+}`
+  }),
+  createOperationSpec({
+    operationName: "GetAutomationDiffFromPublished",
+    kind: "query",
+    inputSchema: z17.object({
+      automationId: z17.string().min(1),
+      draftVersionId: z17.string().min(1).optional(),
+      publishedVersionId: z17.string().min(1).optional()
+    }),
+    cli: {
+      name: "get-automation-diff-from-published",
+      path: ["automations", "diff-from-published"],
+      description: "Fetch draft-vs-published automation change scope.",
+      resultKey: "automationDiffFromPublished",
+      options: [
+        stringOption({
+          inputKey: "automationId",
+          flagName: "automation-id",
+          description: "Automation ID.",
+          required: true
+        }),
+        stringOption({
+          inputKey: "draftVersionId",
+          flagName: "draft-version-id",
+          description: "Draft automation version ID to compare from."
+        }),
+        stringOption({
+          inputKey: "publishedVersionId",
+          flagName: "published-version-id",
+          description: "Published automation version ID to compare against."
+        })
+      ]
+    },
+    mcp: { fileName: "automationDiffFromPublished.graphql" },
+    document: `# Query deterministic draft-vs-published agent and field changes
+query GetAutomationDiffFromPublished($automationId: ID!, $draftVersionId: ID, $publishedVersionId: ID) {
+  automationDiffFromPublished(automationId: $automationId, draftVersionId: $draftVersionId, publishedVersionId: $publishedVersionId) {
+    automationId
+    automationName
+    mode
+    publishedAutomationId
+    hasChanges
+    changedAgents {
+      agentId
+      agentName
+      changeTypes
+      changedFields
+      changes {
+        type
+        field
+      }
+    }
+  }
 }`
   }),
   createOperationSpec({
     operationName: "GetAutomationRun",
     kind: "query",
-    inputSchema: z2.object({
-      id: z2.string().min(1)
+    inputSchema: z17.object({
+      id: z17.string().min(1)
     }),
     cli: {
       name: "get-automation-run",
@@ -8006,8 +10477,8 @@ query GetAutomationRun($id: ID!) {
   createOperationSpec({
     operationName: "GetAutomationRunAgentRuns",
     kind: "query",
-    inputSchema: z2.object({
-      automationRunId: z2.string().min(1)
+    inputSchema: z17.object({
+      automationRunId: z17.string().min(1)
     }),
     cli: {
       name: "get-automation-run-agent-runs",
@@ -8043,11 +10514,11 @@ query GetAutomationRunAgentRuns($automationRunId: ID!) {
   createOperationSpec({
     operationName: "GetAutomationRunIterations",
     kind: "query",
-    inputSchema: z2.object({
-      automationRunId: z2.string().min(1),
-      agentRunId: z2.string().min(1).optional(),
-      limit: z2.number().int().positive().optional(),
-      reverse: z2.boolean().optional()
+    inputSchema: z17.object({
+      automationRunId: z17.string().min(1),
+      agentRunId: z17.string().min(1).optional(),
+      limit: z17.number().int().positive().optional(),
+      reverse: z17.boolean().optional()
     }),
     cli: {
       name: "get-automation-run-iterations",
@@ -8116,12 +10587,12 @@ query GetAutomationRunIterations(
   createOperationSpec({
     operationName: "GetAutomationRuns",
     kind: "query",
-    inputSchema: z2.object({
-      automationId: z2.string().min(1),
-      status: z2.array(z2.string().min(1)).optional(),
-      invocationType: z2.array(z2.string().min(1)).optional(),
-      limit: z2.number().int().positive().optional(),
-      page: z2.number().int().positive().optional()
+    inputSchema: z17.object({
+      automationId: z17.string().min(1),
+      status: z17.array(z17.string().min(1)).optional(),
+      invocationType: z17.array(z17.string().min(1)).optional(),
+      limit: z17.number().int().positive().optional(),
+      page: z17.number().int().positive().optional()
     }),
     cli: {
       name: "get-automation-runs",
@@ -8190,8 +10661,8 @@ query GetAutomationRuns(
   createOperationSpec({
     operationName: "ListAutomations",
     kind: "query",
-    inputSchema: z2.object({
-      limit: z2.number().positive().optional(),
+    inputSchema: z17.object({
+      limit: z17.number().positive().optional(),
       order: jsonObjectSchema.optional(),
       where: jsonObjectSchema.optional()
     }),
@@ -8242,8 +10713,8 @@ query ListAutomations(
   createOperationSpec({
     operationName: "GetAutomations",
     kind: "query",
-    inputSchema: z2.object({
-      ids: z2.array(z2.string().min(1)).min(1)
+    inputSchema: z17.object({
+      ids: z17.array(z17.string().min(1)).min(1)
     }),
     cli: {
       name: "get-automations",
@@ -8260,8 +10731,10 @@ query ListAutomations(
       ]
     },
     mcp: { fileName: "automations.graphql" },
-    document: `# Query to fetch automations with flat fields only (no nested objects)
-# Excludes config and agents for MCP tool simplicity
+    document: `# Query to fetch automations with flat fields + sharedInputSchema.
+# sharedInputSchema is critical for cloning/migration and can't be inferred
+# from agents alone, so it's included by default in the composite read.
+# Other config fields (schedules, proxies, auth) stay excluded for simplicity.
 query GetAutomations($ids: [ID!]!) {
   automations(ids: $ids) {
     id
@@ -8273,124 +10746,628 @@ query GetAutomations($ids: [ID!]!) {
     lastSavedAt
     publishedVersionId
     draftVersionId
+    config {
+      sharedInputSchema {
+        key
+        value {
+          schema
+          sourceAgentId
+          sourceLocation
+        }
+      }
+    }
+  }
+}`
+  }),
+  createOperationSpec({
+    operationName: "GetAvailableCommands",
+    kind: "query",
+    inputSchema: z17.object({
+      env: z17.string().min(1)
+    }),
+    cli: {
+      name: "get-available-commands",
+      path: ["catalog", "commands"],
+      description: "Fetch available command definitions by environment.",
+      resultKey: "availableCommands",
+      options: [
+        stringOption({
+          inputKey: "env",
+          flagName: "env",
+          description: "Environment name.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "availableCommands.graphql" },
+    document: `# Query to fetch available command definitions by environment
+query GetAvailableCommands($env: AvailableCommandsEnv!) {
+  availableCommands(env: $env) {
+    id
+    description
+    inputSchema
+  }
+}`
+  }),
+  createOperationSpec({
+    operationName: "GetAvailableModels",
+    kind: "query",
+    inputSchema: z17.object({
+      agentId: z17.string().min(1)
+    }),
+    cli: {
+      name: "get-available-models",
+      path: ["catalog", "models"],
+      description: "Fetch available model definitions for an agent.",
+      resultKey: "availableModels",
+      options: [
+        stringOption({
+          inputKey: "agentId",
+          flagName: "agent-id",
+          description: "Agent ID.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "availableModels.graphql" },
+    document: `# Query to fetch available model definitions and pools for a specific agent
+query GetAvailableModels($agentId: String!) {
+  availableModels(agentId: $agentId) {
+    availableModelPools {
+      name
+      poolId
+      models {
+        id
+        name
+        description
+        status
+        provider
+      }
+    }
+    allAvailableModels {
+      id
+      name
+      description
+      status
+      provider
+    }
+  }
+}`
+  }),
+  createOperationSpec({
+    operationName: "GetAvailableTools",
+    kind: "query",
+    inputSchema: z17.object({
+      env: z17.string().min(1),
+      automationId: z17.string().min(1).optional()
+    }),
+    cli: {
+      name: "get-available-tools",
+      path: ["catalog", "tools"],
+      description: "Fetch available tool definitions by environment.",
+      resultKey: "availableTools",
+      options: [
+        stringOption({
+          inputKey: "env",
+          flagName: "env",
+          description: "Environment name.",
+          required: true
+        }),
+        stringOption({
+          inputKey: "automationId",
+          flagName: "automation-id",
+          description: "Optional automation ID."
+        })
+      ]
+    },
+    mcp: { fileName: "availableTools.graphql" },
+    document: `# Query to fetch available tool definitions by environment
+query GetAvailableTools($env: AvailableCommandsEnv!, $automationId: String) {
+  availableTools(env: $env, automationId: $automationId) {
+    id
+    description
+    inputSchema
+  }
+}`
+  }),
+  createOperationSpec({
+    operationName: "GetFeatureFlagsContext",
+    kind: "query",
+    inputSchema: z17.object({
+      flagKeys: z17.array(z17.string().min(1)).min(1).max(100).optional()
+    }),
+    cli: {
+      name: "get-feature-flags-context",
+      path: ["feature-flags", "context"],
+      description: "Fetch current LaunchDarkly feature flag values for the selected org and current user.",
+      resultKey: "featureFlagsContext",
+      options: [
+        stringArrayOption({
+          inputKey: "flagKeys",
+          flagName: "flag-keys",
+          description: "Optional feature flag keys."
+        })
+      ]
+    },
+    mcp: { fileName: "featureFlagsContext.graphql" },
+    document: `# Query to fetch current LaunchDarkly feature flag context
+query GetFeatureFlagsContext($flagKeys: [String!]) {
+  featureFlagsContext(flagKeys: $flagKeys) {
+    evaluatedAt
+    organizationId
+    contexts {
+      organization {
+        flags
+      }
+      user {
+        id
+        email
+        flags
+      }
+    }
+  }
+}`
+  }),
+  createOperationSpec({
+    operationName: "GetAutomationWorkbenchCredentials",
+    kind: "query",
+    inputSchema: z17.object({}),
+    cli: {
+      name: "get-automation-workbench-credentials",
+      path: ["workbench", "credentials"],
+      description: "Fetch organization credential metadata for automation authoring. Secret values are never returned.",
+      resultKey: "automationWorkbenchCredentials",
+      options: []
+    },
+    mcp: { fileName: "automationWorkbenchCredentials.graphql" },
+    document: `# Query organization credential metadata for automation authoring.
+# Secret values are never returned.
+query GetAutomationWorkbenchCredentials {
+  automationWorkbenchCredentials {
+    id
+    type
+    description
+    hostname
+    providerConfigKey
+    availableFactors
+  }
+}`
+  }),
+  createOperationSpec({
+    operationName: "GetAutomationWorkbenchDiagnostics",
+    kind: "query",
+    inputSchema: z17.object({
+      draftAutomationId: z17.string().min(1)
+    }),
+    cli: {
+      name: "get-automation-workbench-diagnostics",
+      path: ["workbench", "diagnostics"],
+      description: "Fetch a compact draft automation graph plus workbench diagnostics.",
+      resultKey: "automationWorkbenchDiagnostics",
+      options: [
+        stringOption({
+          inputKey: "draftAutomationId",
+          flagName: "draft-automation-id",
+          description: "Draft automation ID.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "automationWorkbenchDiagnostics.graphql" },
+    document: `# Query automation workbench diagnostics for a draft automation.
+query GetAutomationWorkbenchDiagnostics($draftAutomationId: ID!) {
+  automationWorkbenchDiagnostics(draftAutomationId: $draftAutomationId) {
+    summary {
+      draftAutomationId
+      name
+      agentCount
+      authenticationCount
+      edgeCount
+      rootAgentIds
+      agents {
+        id
+        name
+        type
+        kind
+        description
+        instructions
+        isTrigger
+        childAgentIds
+        parentAgentIds
+        tools
+        sharedInputKeys
+        sharedOutputKeys
+        referencedAgentIds
+      }
+      sharedInputSourceByKey {
+        key
+        sourceAgentId
+        sourceLocation
+      }
+    }
+    issues {
+      severity
+      code
+      message
+      agentId
+      path
+      relatedAgentIds
+    }
   }
 }`
   }),
   createOperationSpec({
-    operationName: "GetAvailableCommands",
+    operationName: "GetAutomationWorkbenchRunTrace",
     kind: "query",
-    inputSchema: z2.object({
-      env: z2.string().min(1)
+    inputSchema: z17.object({
+      automationRunId: z17.string().min(1),
+      agentRunId: z17.string().min(1).optional(),
+      limit: z17.number().int().positive().optional(),
+      reverse: z17.boolean().optional()
     }),
     cli: {
-      name: "get-available-commands",
-      path: ["catalog", "commands"],
-      description: "Fetch available command definitions by environment.",
-      resultKey: "availableCommands",
+      name: "get-automation-workbench-run-trace",
+      path: ["workbench", "run-trace"],
+      description: "Fetch a projected run trace with agent runs, child runs, iterations, and terminal blame.",
+      resultKey: "automationWorkbenchRunTrace",
       options: [
         stringOption({
-          inputKey: "env",
-          flagName: "env",
-          description: "Environment name.",
+          inputKey: "automationRunId",
+          flagName: "automation-run-id",
+          description: "Automation run ID.",
           required: true
+        }),
+        stringOption({
+          inputKey: "agentRunId",
+          flagName: "agent-run-id",
+          description: "Optional agent run ID to focus iterations."
+        }),
+        numberOption({
+          inputKey: "limit",
+          flagName: "limit",
+          description: "Maximum number of iterations to return."
+        }),
+        booleanOption({
+          inputKey: "reverse",
+          flagName: "reverse",
+          description: "Return newest iterations first."
         })
       ]
     },
-    mcp: { fileName: "availableCommands.graphql" },
-    document: `# Query to fetch available command definitions by environment
-query GetAvailableCommands($env: AvailableCommandsEnv!) {
-  availableCommands(env: $env) {
+    mcp: { fileName: "automationWorkbenchRunTrace.graphql" },
+    document: `# Query a compact run trace for workbench debug loops.
+query GetAutomationWorkbenchRunTrace(
+  $automationRunId: ID!
+  $agentRunId: ID
+  $limit: Int
+  $reverse: Boolean
+) {
+  automationWorkbenchRunTrace(
+    automationRunId: $automationRunId
+    agentRunId: $agentRunId
+    limit: $limit
+    reverse: $reverse
+  ) {
     id
-    description
-    inputSchema
+    automationId
+    status
+    statusDetail
+    summary
+    debugUrl
+    startedAt
+    finishedAt
+    truncated
+    terminal {
+      status
+      detail
+      lastNodeId
+      blameNodeId
+    }
+    agentRuns {
+      id
+      agentId
+      agentVersionId
+      agentName
+      parentAgentRunId
+      status
+      statusDetail
+      iterations {
+        id
+        sequence
+        agentRunId
+        tMs
+        durationMs
+        llmDurationMs
+        reasoning
+        reasoningStatus
+        toolCall {
+          toolCallId
+          toolName
+          targetAgentId
+          targetAgentName
+          targetAgentIds
+          targetAgentNames
+        }
+        toolResult {
+          status
+          message
+        }
+        screenshotUrl
+        errorMessage
+      }
+      childRuns {
+        id
+        agentId
+        agentVersionId
+        agentName
+        parentAgentRunId
+        status
+        statusDetail
+        iterations {
+          id
+          sequence
+          agentRunId
+          tMs
+          durationMs
+          llmDurationMs
+          reasoning
+          reasoningStatus
+          toolCall {
+            toolCallId
+            toolName
+            targetAgentId
+            targetAgentName
+            targetAgentIds
+            targetAgentNames
+          }
+          toolResult {
+            status
+            message
+          }
+          screenshotUrl
+          errorMessage
+        }
+      }
+    }
   }
 }`
   }),
   createOperationSpec({
-    operationName: "GetAvailableModels",
+    operationName: "GetAutomationWorkbenchAwaitRunCompletion",
     kind: "query",
-    inputSchema: z2.object({
-      agentId: z2.string().min(1)
+    inputSchema: z17.object({
+      automationRunId: z17.string().min(1),
+      timeoutMs: z17.number().int().min(1e3).max(6e4).optional(),
+      sinceSequence: z17.number().int().min(0).optional(),
+      agentRunId: z17.string().min(1).optional(),
+      limit: z17.number().int().positive().optional(),
+      reverse: z17.boolean().optional()
     }),
     cli: {
-      name: "get-available-models",
-      path: ["catalog", "models"],
-      description: "Fetch available model definitions for an agent.",
-      resultKey: "availableModels",
+      name: "await-automation-workbench-run-completion",
+      path: ["workbench", "await"],
+      description: "Long-poll: block until the run is terminal/paused or timeout elapses, then return the projected trace plus poll stats.",
+      resultKey: "automationWorkbenchAwaitRunCompletion",
       options: [
         stringOption({
-          inputKey: "agentId",
-          flagName: "agent-id",
-          description: "Agent ID.",
+          inputKey: "automationRunId",
+          flagName: "automation-run-id",
+          description: "Automation run ID to wait on.",
           required: true
+        }),
+        numberOption({
+          inputKey: "timeoutMs",
+          flagName: "timeout-ms",
+          description: "Server-side wait cap, in ms. Clamped to [1000, 60000]. Defaults to 30000."
+        }),
+        numberOption({
+          inputKey: "sinceSequence",
+          flagName: "since-sequence",
+          description: "Wake also when any iteration with sequence > sinceSequence appears (incremental polling)."
+        }),
+        stringOption({
+          inputKey: "agentRunId",
+          flagName: "agent-run-id",
+          description: "Optional agent run ID to focus iterations."
+        }),
+        numberOption({
+          inputKey: "limit",
+          flagName: "limit",
+          description: "Maximum iterations to return per agent run."
+        }),
+        booleanOption({
+          inputKey: "reverse",
+          flagName: "reverse",
+          description: "Return newest iterations first."
         })
       ]
     },
-    mcp: { fileName: "availableModels.graphql" },
-    document: `# Query to fetch available model definitions and pools for a specific agent
-query GetAvailableModels($agentId: String!) {
-  availableModels(agentId: $agentId) {
-    availableModelPools {
-      name
-      poolId
-      models {
+    mcp: { fileName: "automationWorkbenchAwaitRunCompletion.graphql" },
+    document: `# Long-poll for run completion. Server holds the request open until the run
+# reaches a terminal/paused state or timeout elapses, then returns the same
+# projected trace shape as automationWorkbenchRunTrace plus poll stats.
+query GetAutomationWorkbenchAwaitRunCompletion(
+  $automationRunId: ID!
+  $timeoutMs: Int
+  $sinceSequence: Int
+  $agentRunId: ID
+  $limit: Int
+  $reverse: Boolean
+) {
+  automationWorkbenchAwaitRunCompletion(
+    automationRunId: $automationRunId
+    timeoutMs: $timeoutMs
+    sinceSequence: $sinceSequence
+    agentRunId: $agentRunId
+    limit: $limit
+    reverse: $reverse
+  ) {
+    reachedTerminal
+    reachedSinceSequence
+    pollCount
+    elapsedMs
+    trace {
+      id
+      automationId
+      status
+      statusDetail
+      summary
+      debugUrl
+      startedAt
+      finishedAt
+      truncated
+      terminal {
+        status
+        detail
+        lastNodeId
+        blameNodeId
+      }
+      agentRuns {
         id
-        name
-        description
+        agentId
+        agentVersionId
+        agentName
+        parentAgentRunId
         status
-        provider
+        statusDetail
+        iterations {
+          id
+          sequence
+          agentRunId
+          tMs
+          durationMs
+          llmDurationMs
+          reasoning
+          reasoningStatus
+          toolCall {
+            toolCallId
+            toolName
+            targetAgentId
+            targetAgentName
+            targetAgentIds
+            targetAgentNames
+          }
+          toolResult {
+            status
+            message
+          }
+          screenshotUrl
+          errorMessage
+        }
+        childRuns {
+          id
+          agentId
+          agentVersionId
+          agentName
+          parentAgentRunId
+          status
+          statusDetail
+          iterations {
+            id
+            sequence
+            agentRunId
+            tMs
+            durationMs
+            llmDurationMs
+            reasoning
+            reasoningStatus
+            toolCall {
+              toolCallId
+              toolName
+              targetAgentId
+              targetAgentName
+              targetAgentIds
+              targetAgentNames
+            }
+            toolResult {
+              status
+              message
+            }
+            screenshotUrl
+            errorMessage
+          }
+        }
       }
     }
-    allAvailableModels {
-      id
-      name
-      description
-      status
-      provider
-    }
   }
 }`
   }),
   createOperationSpec({
-    operationName: "GetAvailableTools",
+    operationName: "GetAutomationWorkbenchSchemaSuggestions",
     kind: "query",
-    inputSchema: z2.object({
-      env: z2.string().min(1),
-      automationId: z2.string().min(1).optional()
+    inputSchema: z17.object({
+      automationRunId: z17.string().min(1),
+      draftAutomationId: z17.string().min(1).optional(),
+      minConfidence: z17.number().min(0).max(1).optional(),
+      includeSensitive: z17.boolean().optional()
     }),
     cli: {
-      name: "get-available-tools",
-      path: ["catalog", "tools"],
-      description: "Fetch available tool definitions by environment.",
-      resultKey: "availableTools",
+      name: "get-automation-workbench-schema-suggestions",
+      path: ["workbench", "schema-suggestions"],
+      description: "Heuristic suggestions for schema fields the agent observed on browser pages but were not declared in the input schema.",
+      resultKey: "automationWorkbenchSchemaSuggestions",
       options: [
         stringOption({
-          inputKey: "env",
-          flagName: "env",
-          description: "Environment name.",
+          inputKey: "automationRunId",
+          flagName: "automation-run-id",
+          description: "Automation run to analyze.",
           required: true
         }),
         stringOption({
-          inputKey: "automationId",
-          flagName: "automation-id",
-          description: "Optional automation ID."
+          inputKey: "draftAutomationId",
+          flagName: "draft-automation-id",
+          description: "Optional draft automation ID. Defaults to the run's automationId."
+        }),
+        numberOption({
+          inputKey: "minConfidence",
+          flagName: "min-confidence",
+          description: "Suggestions below this 0..1 confidence score are filtered out. Default 0.6."
+        }),
+        booleanOption({
+          inputKey: "includeSensitive",
+          flagName: "include-sensitive",
+          description: "Include suggestions for fields whose label looks like PII (SSN, password, card number). Default false."
         })
       ]
     },
-    mcp: { fileName: "availableTools.graphql" },
-    document: `# Query to fetch available tool definitions by environment
-query GetAvailableTools($env: AvailableCommandsEnv!, $automationId: String) {
-  availableTools(env: $env, automationId: $automationId) {
-    id
-    description
-    inputSchema
+    mcp: { fileName: "automationWorkbenchSchemaSuggestions.graphql" },
+    document: `# Heuristic schema-coverage suggestions: form fields observed on the page that
+# are not declared in any input schema, returned with evidence for verification.
+query GetAutomationWorkbenchSchemaSuggestions(
+  $automationRunId: ID!
+  $draftAutomationId: ID
+  $minConfidence: Float
+  $includeSensitive: Boolean
+) {
+  automationWorkbenchSchemaSuggestions(
+    automationRunId: $automationRunId
+    draftAutomationId: $draftAutomationId
+    minConfidence: $minConfidence
+    includeSensitive: $includeSensitive
+  ) {
+    kind
+    fieldName
+    fieldLabel
+    fieldType
+    fieldDescription
+    required
+    confidence
+    reason
+    evidence {
+      iterationId
+      agentRunId
+      agentName
+      markId
+      fieldText
+      screenshotUrl
+    }
   }
 }`
   }),
   createOperationSpec({
     operationName: "CreateAutomation",
     kind: "mutation",
-    inputSchema: z2.object({
+    inputSchema: z17.object({
       input: jsonObjectSchema
     }),
     cli: {
@@ -8427,7 +11404,7 @@ mutation CreateAutomation($input: CreateAutomationInput!) {
   createOperationSpec({
     operationName: "GetGraphqlSchema",
     kind: "query",
-    inputSchema: z2.object({}),
+    inputSchema: z17.object({}),
     cli: {
       name: "get-graphql-schema",
       path: ["graphql", "schema"],
@@ -8448,8 +11425,8 @@ query GetGraphqlSchema {
   createOperationSpec({
     operationName: "PauseAutomationRun",
     kind: "mutation",
-    inputSchema: z2.object({
-      automationRunId: z2.string().min(1)
+    inputSchema: z17.object({
+      automationRunId: z17.string().min(1)
     }),
     cli: {
       name: "pause-automation-run",
@@ -8474,10 +11451,10 @@ mutation PauseAutomationRun($automationRunId: ID!) {
   createOperationSpec({
     operationName: "RerunAutomation",
     kind: "mutation",
-    inputSchema: z2.object({
-      automationRunId: z2.string().min(1),
-      additionalPrompt: z2.string().min(1).optional(),
-      idempotencyKey: z2.string().min(1)
+    inputSchema: z17.object({
+      automationRunId: z17.string().min(1),
+      additionalPrompt: z17.string().min(1).optional(),
+      idempotencyKey: z17.string().min(1)
     }),
     cli: {
       name: "rerun-automation",
@@ -8525,9 +11502,9 @@ mutation RerunAutomation(
   createOperationSpec({
     operationName: "ResumeAutomationRun",
     kind: "mutation",
-    inputSchema: z2.object({
-      automationRunId: z2.string().min(1),
-      message: z2.string().min(1).optional()
+    inputSchema: z17.object({
+      automationRunId: z17.string().min(1),
+      message: z17.string().min(1).optional()
     }),
     cli: {
       name: "resume-automation-run",
@@ -8557,12 +11534,14 @@ mutation ResumeAutomationRun($automationRunId: ID!, $message: String) {
   createOperationSpec({
     operationName: "RunDraftAutomation",
     kind: "mutation",
-    inputSchema: z2.object({
-      draftAutomationId: z2.string().min(1),
-      agentId: z2.string().min(1),
-      idempotencyKey: z2.string().min(1),
-      input: z2.unknown().optional(),
-      additionalPrompt: z2.string().min(1).optional()
+    inputSchema: z17.object({
+      draftAutomationId: z17.string().min(1),
+      agentId: z17.string().min(1),
+      idempotencyKey: z17.string().min(1),
+      input: z17.unknown().optional(),
+      config: automationRunStartConfigSchema.partial().passthrough().optional(),
+      additionalPrompt: z17.string().min(1).optional(),
+      consistencyCheckCount: z17.number().int().optional()
     }),
     cli: {
       name: "run-draft-automation",
@@ -8593,10 +11572,20 @@ mutation ResumeAutomationRun($automationRunId: ID!, $message: String) {
           flagName: "input-json",
           description: "Optional JSON input payload."
         }),
+        jsonOption({
+          inputKey: "config",
+          flagName: "config-json",
+          description: 'Optional run config payload, for example {"startInTakeOverMode":true,"approvalMode":"HUMAN_APPROVAL","consistencyCheckCount":3}.'
+        }),
         stringOption({
           inputKey: "additionalPrompt",
           flagName: "additional-prompt",
           description: "Optional prompt appended to the run."
+        }),
+        numberOption({
+          inputKey: "consistencyCheckCount",
+          flagName: "consistency-check-count",
+          description: "Optional consistency-check copy count for draft iteration runs."
         })
       ]
     },
@@ -8608,14 +11597,18 @@ mutation RunDraftAutomation(
   $agentId: ID!
   $idempotencyKey: String!
   $input: JSON
+  $config: AutomationRunConfigInput
   $additionalPrompt: String
+  $consistencyCheckCount: Int
 ) {
   runDraftAutomation(
     draftAutomationId: $draftAutomationId
     agentId: $agentId
     idempotencyKey: $idempotencyKey
     input: $input
+    config: $config
     additionalPrompt: $additionalPrompt
+    consistencyCheckCount: $consistencyCheckCount
   ) {
     automationRunId
     workflowId
@@ -8626,8 +11619,8 @@ mutation RunDraftAutomation(
   createOperationSpec({
     operationName: "StopAutomationRun",
     kind: "mutation",
-    inputSchema: z2.object({
-      automationRunId: z2.string().min(1)
+    inputSchema: z17.object({
+      automationRunId: z17.string().min(1)
     }),
     cli: {
       name: "stop-automation-run",
@@ -8647,13 +11640,211 @@ mutation RunDraftAutomation(
     document: `# Mutation to stop an automation run
 mutation StopAutomationRun($automationRunId: ID!) {
   stopAutomationRun(automationRunId: $automationRunId)
+}`
+  }),
+  createOperationSpec({
+    operationName: "PreviewAutomationPatch",
+    kind: "mutation",
+    inputSchema: z17.object({
+      draftAutomationId: z17.string().min(1),
+      expectedLastSavedAt: z17.string().optional(),
+      operations: z17.array(z17.unknown()).min(1)
+    }),
+    cli: {
+      name: "preview-automation-patch",
+      path: ["workbench", "patch", "preview"],
+      description: "Preview semantic workbench patch operations without saving the draft.",
+      resultKey: "previewAutomationPatch",
+      options: [
+        stringOption({
+          inputKey: "draftAutomationId",
+          flagName: "draft-automation-id",
+          description: "Draft automation ID.",
+          required: true
+        }),
+        jsonOption({
+          inputKey: "operations",
+          flagName: "operations-json",
+          description: "Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "previewAutomationPatch.graphql" },
+    document: `# Preview semantic automation patch operations without writing.
+mutation PreviewAutomationPatch(
+  $draftAutomationId: ID!
+  $operations: [AutomationWorkbenchPatchOperationInput!]!
+) {
+  previewAutomationPatch(
+    draftAutomationId: $draftAutomationId
+    operations: $operations
+  ) {
+    draftAutomationId
+    applied
+    updateInput
+    before {
+      name
+      agentCount
+      edgeCount
+      rootAgentIds
+      agents {
+        id
+        name
+        type
+        kind
+        tools
+        childAgentIds
+        parentAgentIds
+        sharedInputKeys
+        sharedOutputKeys
+      }
+      sharedInputSourceByKey {
+        key
+        sourceAgentId
+        sourceLocation
+      }
+    }
+    after {
+      name
+      agentCount
+      edgeCount
+      rootAgentIds
+      agents {
+        id
+        name
+        type
+        kind
+        tools
+        childAgentIds
+        parentAgentIds
+        sharedInputKeys
+        sharedOutputKeys
+      }
+      sharedInputSourceByKey {
+        key
+        sourceAgentId
+        sourceLocation
+      }
+    }
+    issues {
+      severity
+      code
+      message
+      agentId
+      path
+      relatedAgentIds
+    }
+  }
+}`
+  }),
+  createOperationSpec({
+    operationName: "ApplyAutomationPatch",
+    kind: "mutation",
+    inputSchema: z17.object({
+      draftAutomationId: z17.string().min(1),
+      operations: z17.array(z17.unknown()).min(1)
+    }),
+    cli: {
+      name: "apply-automation-patch",
+      path: ["workbench", "patch", "apply"],
+      description: "Apply semantic workbench patch operations through the versioned save path.",
+      resultKey: "applyAutomationPatch",
+      options: [
+        stringOption({
+          inputKey: "draftAutomationId",
+          flagName: "draft-automation-id",
+          description: "Draft automation ID.",
+          required: true
+        }),
+        jsonOption({
+          inputKey: "operations",
+          flagName: "operations-json",
+          description: "Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape.",
+          required: true
+        }),
+        stringOption({
+          inputKey: "expectedLastSavedAt",
+          flagName: "expected-last-saved-at",
+          description: "Optional optimistic concurrency guard timestamp."
+        })
+      ]
+    },
+    mcp: { fileName: "applyAutomationPatch.graphql" },
+    document: `# Apply semantic automation patch operations through the versioned save path.
+mutation ApplyAutomationPatch(
+  $draftAutomationId: ID!
+  $operations: [AutomationWorkbenchPatchOperationInput!]!
+  $expectedLastSavedAt: String
+) {
+  applyAutomationPatch(
+    draftAutomationId: $draftAutomationId
+    operations: $operations
+    expectedLastSavedAt: $expectedLastSavedAt
+  ) {
+    draftAutomationId
+    applied
+    updateInput
+    before {
+      name
+      agentCount
+      edgeCount
+      rootAgentIds
+      agents {
+        id
+        name
+        type
+        kind
+        tools
+        childAgentIds
+        parentAgentIds
+        sharedInputKeys
+        sharedOutputKeys
+      }
+      sharedInputSourceByKey {
+        key
+        sourceAgentId
+        sourceLocation
+      }
+    }
+    after {
+      name
+      agentCount
+      edgeCount
+      rootAgentIds
+      agents {
+        id
+        name
+        type
+        kind
+        tools
+        childAgentIds
+        parentAgentIds
+        sharedInputKeys
+        sharedOutputKeys
+      }
+      sharedInputSourceByKey {
+        key
+        sourceAgentId
+        sourceLocation
+      }
+    }
+    issues {
+      severity
+      code
+      message
+      agentId
+      path
+      relatedAgentIds
+    }
+  }
 }`
   }),
   createOperationSpec({
     operationName: "UpdateAutomationById",
     kind: "mutation",
-    inputSchema: z2.object({
-      id: z2.string().min(1),
+    inputSchema: z17.object({
+      id: z17.string().min(1),
       input: jsonObjectSchema
     }),
     cli: {
@@ -8694,58 +11885,58 @@ mutation UpdateAutomationById($id: ID!, $input: UpdateAutomationInput!) {
 import { Command as Command2, InvalidArgumentError as InvalidArgumentError2, Option as Option2 } from "commander";
 
 // src/api.ts
-import { z as z3 } from "zod";
+import { z as z18 } from "zod";
 var OTTO_AUTHORIZATION_HEADER_NAME = "X-Otto-Authorization";
 var OTTO_AUTHORIZATION_ISSUER = "magical:otto";
-var workosOrganizationsResponseSchema = z3.object({
-  organizations: z3.array(
-    z3.object({
-      id: z3.string().min(1),
-      name: z3.string().min(1),
-      primaryDomain: z3.string().nullable().optional()
+var workosOrganizationsResponseSchema = z18.object({
+  organizations: z18.array(
+    z18.object({
+      id: z18.string().min(1),
+      name: z18.string().min(1),
+      primaryDomain: z18.string().nullable().optional()
     })
   ),
-  success: z3.boolean()
+  success: z18.boolean()
 });
-var workosUserSchema = z3.object({
-  email: z3.string().nullable(),
-  id: z3.string().min(1)
+var workosUserSchema = z18.object({
+  email: z18.string().nullable(),
+  id: z18.string().min(1)
 });
-var nangoIntegrationWireSchema = z3.object({
+var nangoIntegrationWireSchema = z18.object({
   // eslint-disable-next-line @typescript-eslint/naming-convention -- mirrors Nango REST payload
-  unique_key: z3.string().min(1)
+  unique_key: z18.string().min(1)
 }).passthrough().transform((data) => ({
   ...data,
   uniqueKey: data.unique_key
 }));
-var nangoIntegrationsResponseSchema = z3.array(nangoIntegrationWireSchema);
-var organizationAuthenticationSchema = z3.object({
-  id: z3.string().min(1),
-  type: z3.string().min(1),
-  connectionId: z3.string().nullable().optional(),
-  providerConfigKey: z3.string().nullable().optional(),
-  description: z3.string().nullable().optional(),
-  hostname: z3.string().nullable().optional()
+var nangoIntegrationsResponseSchema = z18.array(nangoIntegrationWireSchema);
+var organizationAuthenticationSchema = z18.object({
+  id: z18.string().min(1),
+  type: z18.string().min(1),
+  connectionId: z18.string().nullable().optional(),
+  providerConfigKey: z18.string().nullable().optional(),
+  description: z18.string().nullable().optional(),
+  hostname: z18.string().nullable().optional()
 }).passthrough();
-var organizationAuthenticationsResponseSchema = z3.object({
-  authentications: z3.array(organizationAuthenticationSchema),
-  success: z3.boolean()
-});
-var graphQlResponseSchema = z3.object({
-  data: z3.record(z3.string(), z3.unknown()).optional(),
-  errors: z3.array(
-    z3.object({
-      message: z3.string().min(1)
+var organizationAuthenticationsResponseSchema = z18.object({
+  authentications: z18.array(organizationAuthenticationSchema),
+  success: z18.boolean()
+});
+var graphQlResponseSchema = z18.object({
+  data: z18.record(z18.string(), z18.unknown()).optional(),
+  errors: z18.array(
+    z18.object({
+      message: z18.string().min(1)
     })
   ).optional()
 });
-var apiErrorResponseSchema = z3.object({
-  errors: z3.array(
-    z3.object({
-      message: z3.string().min(1)
+var apiErrorResponseSchema = z18.object({
+  errors: z18.array(
+    z18.object({
+      message: z18.string().min(1)
     })
   ).optional(),
-  message: z3.string().min(1).optional()
+  message: z18.string().min(1).optional()
 });
 function getApiErrorDetail(responseBody) {
   const parsedResponse = apiErrorResponseSchema.safeParse(responseBody);
@@ -9032,10 +12223,10 @@ function requireWorkosClientId(config) {
 // src/settings.ts
 import { mkdir, readFile, rm, writeFile } from "fs/promises";
 import path2 from "path";
-import { z as z4 } from "zod";
-var cliSettingsSchema = z4.object({
-  env: z4.object({
-    baseUrl: z4.url().optional()
+import { z as z19 } from "zod";
+var cliSettingsSchema = z19.object({
+  env: z19.object({
+    baseUrl: z19.url().optional()
   }).default({})
 });
 function createEmptyCliSettings() {
@@ -9278,22 +12469,6 @@ function resolveOpenCommand(url) {
 
 // src/program-session.ts
 import { readFile as readFile2, rm as rm2 } from "fs/promises";
-
-// ../common/dist/src/stdlib/url.utils.js
-var import_handlebars = __toESM(require_lib(), 1);
-function safeUrlConstructor(url, baseUrl) {
-  try {
-    return Ok(baseUrl ? new URL(url, baseUrl) : new URL(url));
-  } catch {
-    return Err({
-      type: "invalid-url",
-      message: `Invalid URL`,
-      url
-    });
-  }
-}
-
-// src/program-session.ts
 async function withOrgScopedAccessToken({
   dependencies,
   organizationId,
@@ -9653,24 +12828,24 @@ ${formatExamples("Examples", [
 // src/state.ts
 import { mkdir as mkdir2, readFile as readFile3, rm as rm3, writeFile as writeFile2 } from "fs/promises";
 import path4 from "path";
-import { z as z5 } from "zod";
-var cliAccountSchema = z5.object({
-  clientId: z5.string().min(1),
-  email: z5.string().nullable(),
-  userId: z5.string().min(1)
-});
-var cliOrganizationSchema = z5.object({
-  id: z5.string().min(1),
-  name: z5.string().min(1),
-  primaryDomain: z5.string().nullable().default(null)
-});
-var cliStateSchema = z5.object({
+import { z as z20 } from "zod";
+var cliAccountSchema = z20.object({
+  clientId: z20.string().min(1),
+  email: z20.string().nullable(),
+  userId: z20.string().min(1)
+});
+var cliOrganizationSchema = z20.object({
+  id: z20.string().min(1),
+  name: z20.string().min(1),
+  primaryDomain: z20.string().nullable().default(null)
+});
+var cliStateSchema = z20.object({
   account: cliAccountSchema,
-  defaultOrgId: z5.string().nullable(),
-  lastUsedOrgId: z5.string().nullable(),
-  organizations: z5.array(cliOrganizationSchema)
+  defaultOrgId: z20.string().nullable(),
+  lastUsedOrgId: z20.string().nullable(),
+  organizations: z20.array(cliOrganizationSchema)
 });
-var refreshTokenFileSchema = z5.record(z5.string(), z5.string());
+var refreshTokenFileSchema = z20.record(z20.string(), z20.string());
 function createFileStateStore(stateFilePath) {
   return {
     async clear() {
@@ -9783,37 +12958,37 @@ if (typeof cliPackageVersion !== "string" || cliPackageVersion.length === 0) {
 var CLI_VERSION = cliPackageVersion;
 
 // src/workos-auth.ts
-import { z as z6 } from "zod";
+import { z as z21 } from "zod";
 var DEFAULT_DEVICE_POLL_INTERVAL_SECONDS = 5;
 function buildFormHeaders() {
   const headers = new Headers();
   headers.set("content-type", "application/x-www-form-urlencoded");
   return headers;
 }
-var deviceAuthorizationSchema = z6.object({
-  device_code: z6.string().min(1),
-  expires_in: z6.number().int().positive().optional(),
-  interval: z6.number().int().positive().optional(),
-  user_code: z6.string().min(1),
-  verification_uri: z6.url(),
-  verification_uri_complete: z6.url().optional()
-});
-var tokenResponseSchema = z6.object({
-  access_token: z6.string().min(1),
-  expires_in: z6.number().int().positive().optional(),
-  refresh_token: z6.string().min(1),
-  token_type: z6.string().optional()
-});
-var tokenErrorSchema = z6.object({
-  error: z6.string().min(1),
-  error_description: z6.string().optional()
-});
-var accessTokenClaimsSchema = z6.object({
-  exp: z6.number().int().positive().optional(),
-  iss: z6.string().min(1).optional(),
-  org_id: z6.string().min(1).optional(),
-  sid: z6.string().min(1).optional(),
-  sub: z6.string().min(1)
+var deviceAuthorizationSchema = z21.object({
+  device_code: z21.string().min(1),
+  expires_in: z21.number().int().positive().optional(),
+  interval: z21.number().int().positive().optional(),
+  user_code: z21.string().min(1),
+  verification_uri: z21.url(),
+  verification_uri_complete: z21.url().optional()
+});
+var tokenResponseSchema = z21.object({
+  access_token: z21.string().min(1),
+  expires_in: z21.number().int().positive().optional(),
+  refresh_token: z21.string().min(1),
+  token_type: z21.string().optional()
+});
+var tokenErrorSchema = z21.object({
+  error: z21.string().min(1),
+  error_description: z21.string().optional()
+});
+var accessTokenClaimsSchema = z21.object({
+  exp: z21.number().int().positive().optional(),
+  iss: z21.string().min(1).optional(),
+  org_id: z21.string().min(1).optional(),
+  sid: z21.string().min(1).optional(),
+  sub: z21.string().min(1)
 });
 function createWorkosAuthClient({
   fetchFn = fetch,