@desplega.ai/agent-swarm 1.152.2 → 1.154.0

package/dist/cli-4k7jazkq.js

@@ -0,0 +1,3339 @@
+import {
+  MAX_PROFILE_FILE_LENGTH,
+  init_constants
+} from "./cli-dv6cdjs2.js";
+import {
+  exports_zod,
+  init_zod
+} from "./cli-sd0mxa3c.js";
+import {
+  __esm
+} from "./cli-bc05qbss.js";
+
+// src/assets/key.ts
+function normalizeAssetKey(input) {
+  if (typeof input !== "string")
+    throw new AssetKeyError("Asset key must be a string");
+  if (input.includes("\x00"))
+    throw new AssetKeyError("Asset key cannot contain NUL bytes");
+  if (input.includes("\\"))
+    throw new AssetKeyError("Asset key must use forward slashes");
+  const normalized = input.trim().normalize("NFKC").toLowerCase();
+  if (!normalized)
+    throw new AssetKeyError("Asset key cannot be empty");
+  if (normalized.startsWith("/"))
+    throw new AssetKeyError("Asset key must be relative");
+  const withTrailingSlash = normalized.endsWith("/") ? normalized : `${normalized}/`;
+  if (withTrailingSlash.length > ASSET_KEY_MAX_LENGTH) {
+    throw new AssetKeyError(`Asset key cannot exceed ${ASSET_KEY_MAX_LENGTH} characters`);
+  }
+  const segments = withTrailingSlash.slice(0, -1).split("/");
+  if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new AssetKeyError("Asset key contains an empty or traversal segment");
+  }
+  const root = segments[0];
+  if (root !== "shared" && root !== "personal") {
+    throw new AssetKeyError("Asset key root must be shared or personal");
+  }
+  if (root === "personal" && !segments[1]) {
+    throw new AssetKeyError("Personal asset keys require a canonical user ID");
+  }
+  return withTrailingSlash;
+}
+function defaultAssetKey(resource, id) {
+  if (!id.trim())
+    throw new AssetKeyError("Asset key resource ID cannot be empty");
+  return normalizeAssetKey(`shared/${resource}:${id}/`);
+}
+function parseAssetKey(input) {
+  const key = normalizeAssetKey(input);
+  const segments = key.slice(0, -1).split("/");
+  if (segments[0] === "personal") {
+    return {
+      root: "personal",
+      key,
+      segments,
+      userId: segments[1],
+      relativeSegments: segments.slice(2)
+    };
+  }
+  return {
+    root: "shared",
+    key,
+    segments,
+    relativeSegments: segments.slice(1)
+  };
+}
+function isCanonicalAssetKey(input) {
+  try {
+    return normalizeAssetKey(input) === input;
+  } catch {
+    return false;
+  }
+}
+function canWriteAssetKey(input, trustedUserId) {
+  const parsed = parseAssetKey(input);
+  return parsed.root === "shared" || !!trustedUserId && parsed.userId === trustedUserId;
+}
+var ASSET_KEY_MAX_LENGTH = 255, AssetKeyError;
+var init_key = __esm(() => {
+  AssetKeyError = class AssetKeyError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "AssetKeyError";
+    }
+  };
+});
+
+// src/extensions/bundle-path.ts
+function isSafeBundlePath(path) {
+  return path.length > 0 && path.length <= 256 && !path.startsWith("/") && !path.includes("\\") && !path.includes("\x00") && path.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+var init_bundle_path = () => {};
+
+// node_modules/@asteasolutions/zod-to-openapi/dist/index.cjs
+function __rest(s, e) {
+  var t = {};
+  for (var p in s)
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+      t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s);i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}
+function isZodType(schema, typeNames) {
+  const typeNamesArray = Array.isArray(typeNames) ? typeNames : [typeNames];
+  return typeNamesArray.some((typeName) => {
+    var _a;
+    const typeNameMatch = ((_a = schema === null || schema === undefined ? undefined : schema.def) === null || _a === undefined ? undefined : _a.type) === ZodTypeKeys[typeName];
+    if (typeName === "ZodDiscriminatedUnion") {
+      return typeNameMatch && "discriminator" in schema.def;
+    }
+    return typeNameMatch;
+  });
+}
+function isAnyZodType(schema) {
+  return schema && "def" in schema;
+}
+function isNullableSchema(schema) {
+  return schema.safeParse(null).success;
+}
+function isOptionalSchema(schema) {
+  return schema.safeParse(undefined).success;
+}
+
+class $ZodRegistry {
+  constructor() {
+    this._map = new Map;
+    this._idmap = new Map;
+  }
+  add(schema, ..._meta) {
+    const meta = _meta[0];
+    this._map.set(schema, meta);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      if (this._idmap.has(meta.id)) {
+        throw new Error(`ID ${meta.id} already exists in the registry`);
+      }
+      this._idmap.set(meta.id, schema);
+    }
+    return this;
+  }
+  clear() {
+    this._map = new Map;
+    this._idmap = new Map;
+    return this;
+  }
+  remove(schema) {
+    const meta = this._map.get(schema);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      this._idmap.delete(meta.id);
+    }
+    this._map.delete(schema);
+    return this;
+  }
+  get(schema) {
+    const p = schema._zod.parent;
+    if (p) {
+      const pm = { ...this.get(p) ?? {} };
+      delete pm.id;
+      return { ...pm, ...this._map.get(schema) };
+    }
+    return this._map.get(schema);
+  }
+  has(schema) {
+    return this._map.has(schema);
+  }
+}
+function registry() {
+  return new $ZodRegistry;
+}
+function isEqual(x, y) {
+  if (x === null || x === undefined || y === null || y === undefined) {
+    return x === y;
+  }
+  if (x === y || x.valueOf() === y.valueOf()) {
+    return true;
+  }
+  if (Array.isArray(x)) {
+    if (!Array.isArray(y)) {
+      return false;
+    }
+    if (x.length !== y.length) {
+      return false;
+    }
+  }
+  if (!(x instanceof Object) || !(y instanceof Object)) {
+    return false;
+  }
+  const keysX = Object.keys(x);
+  return Object.keys(y).every((keyY) => keysX.indexOf(keyY) !== -1) && keysX.every((key) => isEqual(x[key], y[key]));
+}
+
+class ObjectSet {
+  constructor() {
+    this.buckets = new Map;
+  }
+  put(value) {
+    const hashCode = this.hashCodeOf(value);
+    const itemsByCode = this.buckets.get(hashCode);
+    if (!itemsByCode) {
+      this.buckets.set(hashCode, [value]);
+      return;
+    }
+    const alreadyHasItem = itemsByCode.some((_) => isEqual(_, value));
+    if (!alreadyHasItem) {
+      itemsByCode.push(value);
+    }
+  }
+  contains(value) {
+    const hashCode = this.hashCodeOf(value);
+    const itemsByCode = this.buckets.get(hashCode);
+    if (!itemsByCode) {
+      return false;
+    }
+    return itemsByCode.some((_) => isEqual(_, value));
+  }
+  values() {
+    return [...this.buckets.values()].flat();
+  }
+  stats() {
+    let totalBuckets = 0;
+    let totalValues = 0;
+    let collisions = 0;
+    for (const bucket of this.buckets.values()) {
+      totalBuckets += 1;
+      totalValues += bucket.length;
+      if (bucket.length > 1) {
+        collisions += 1;
+      }
+    }
+    const hashEffectiveness = totalBuckets / totalValues;
+    return { totalBuckets, collisions, totalValues, hashEffectiveness };
+  }
+  hashCodeOf(object) {
+    let hashCode = 0;
+    if (Array.isArray(object)) {
+      for (let i = 0;i < object.length; i++) {
+        hashCode ^= this.hashCodeOf(object[i]) * i;
+      }
+      return hashCode;
+    }
+    if (typeof object === "string") {
+      for (let i = 0;i < object.length; i++) {
+        hashCode ^= object.charCodeAt(i) * i;
+      }
+      return hashCode;
+    }
+    if (typeof object === "number") {
+      return object;
+    }
+    if (typeof object === "object") {
+      for (const [key, value] of Object.entries(object)) {
+        hashCode ^= this.hashCodeOf(key) + this.hashCodeOf(value !== null && value !== undefined ? value : "");
+      }
+    }
+    return hashCode;
+  }
+}
+function isUndefined(value) {
+  return value === undefined;
+}
+function mapValues(object, mapper) {
+  const result = {};
+  Object.entries(object).forEach(([key, value]) => {
+    result[key] = mapper(value);
+  });
+  return result;
+}
+function omit(object, keys) {
+  const result = {};
+  Object.entries(object).forEach(([key, value]) => {
+    if (!keys.some((keyToOmit) => keyToOmit === key)) {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+function omitBy(object, predicate) {
+  const result = {};
+  Object.entries(object).forEach(([key, value]) => {
+    if (!predicate(value, key)) {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+function compact(arr) {
+  return arr.filter((elem) => !isUndefined(elem));
+}
+function uniq(values) {
+  const set = new ObjectSet;
+  values.forEach((value) => set.put(value));
+  return [...set.values()];
+}
+function isString(val) {
+  return typeof val === "string";
+}
+function sortObjectByKeys(obj) {
+  return Object.fromEntries(Object.entries(obj).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)));
+}
+
+class Metadata {
+  static collectMetadata(schema, metadata) {
+    const currentMetadata = this.getMetadataFromRegistry(schema);
+    const _internal = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === undefined ? undefined : currentMetadata._internal), metadata === null || metadata === undefined ? undefined : metadata._internal);
+    const param = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === undefined ? undefined : currentMetadata.param), metadata === null || metadata === undefined ? undefined : metadata.param);
+    const totalMetadata = Object.assign(Object.assign(Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : {}), currentMetadata), metadata), Object.keys(param).length > 0 ? { param } : {});
+    if (isZodType(schema, [
+      "ZodOptional",
+      "ZodNullable",
+      "ZodDefault",
+      "ZodPrefault",
+      "ZodReadonly",
+      "ZodNonOptional"
+    ]) && isAnyZodType(schema._zod.def.innerType)) {
+      return this.collectMetadata(schema._zod.def.innerType, totalMetadata);
+    }
+    if (isZodType(schema, "ZodPipe")) {
+      const inSchema = schema._zod.def.in;
+      const outSchema = schema._zod.def.out;
+      if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) {
+        return this.collectMetadata(outSchema, totalMetadata);
+      }
+      if (isAnyZodType(inSchema)) {
+        return this.collectMetadata(inSchema, totalMetadata);
+      }
+    }
+    return totalMetadata;
+  }
+  static getMetadata(zodSchema) {
+    return this.collectMetadata(zodSchema);
+  }
+  static getOpenApiMetadata(zodSchema) {
+    const metadata = this.collectMetadata(zodSchema);
+    const _a = metadata !== null && metadata !== undefined ? metadata : {}, { _internal } = _a, rest = __rest(_a, ["_internal"]);
+    return rest;
+  }
+  static getInternalMetadata(zodSchema) {
+    var _a;
+    return (_a = this.collectMetadata(zodSchema)) === null || _a === undefined ? undefined : _a._internal;
+  }
+  static getParamMetadata(zodSchema) {
+    const metadata = this.collectMetadata(zodSchema);
+    return Object.assign(Object.assign({}, metadata), {
+      param: Object.assign(Object.assign({}, (metadata === null || metadata === undefined ? undefined : metadata.description) ? { description: metadata.description } : {}), metadata === null || metadata === undefined ? undefined : metadata.param)
+    });
+  }
+  static buildSchemaMetadata(metadata) {
+    return omitBy(omit(metadata, ["param", "_internal"]), isUndefined);
+  }
+  static buildParameterMetadata(metadata) {
+    return omitBy(metadata, isUndefined);
+  }
+  static applySchemaMetadata(initialData, metadata) {
+    return omitBy(Object.assign(Object.assign({}, initialData), this.buildSchemaMetadata(metadata)), isUndefined);
+  }
+  static getRefId(zodSchema) {
+    var _a;
+    return (_a = this.getInternalMetadata(zodSchema)) === null || _a === undefined ? undefined : _a.refId;
+  }
+  static unwrapChained(schema) {
+    return this.unwrapUntil(schema);
+  }
+  static getDefaultValue(zodSchema) {
+    var _a;
+    const unwrapped = (_a = this.unwrapUntil(zodSchema, "ZodDefault")) !== null && _a !== undefined ? _a : this.unwrapUntil(zodSchema, "ZodPrefault");
+    return unwrapped === null || unwrapped === undefined ? undefined : unwrapped._zod.def.defaultValue;
+  }
+  static unwrapUntil(schema, typeName) {
+    if (typeName && isZodType(schema, typeName)) {
+      return schema;
+    }
+    if (isZodType(schema, [
+      "ZodOptional",
+      "ZodNullable",
+      "ZodDefault",
+      "ZodPrefault",
+      "ZodReadonly",
+      "ZodNonOptional"
+    ]) && isAnyZodType(schema._zod.def.innerType)) {
+      return this.unwrapUntil(schema._zod.def.innerType, typeName);
+    }
+    if (isZodType(schema, "ZodPipe")) {
+      const inSchema = schema._zod.def.in;
+      const outSchema = schema._zod.def.out;
+      if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) {
+        return this.unwrapUntil(outSchema, typeName);
+      }
+      if (isAnyZodType(inSchema)) {
+        return this.unwrapUntil(inSchema, typeName);
+      }
+    }
+    return typeName ? undefined : schema;
+  }
+  static getMetadataFromInternalRegistry(zodSchema) {
+    return zodToOpenAPIRegistry.get(zodSchema);
+  }
+  static getMetadataFromRegistry(zodSchema) {
+    const internal = this.getMetadataFromInternalRegistry(zodSchema);
+    const general = zodSchema.meta();
+    if (!internal) {
+      return general;
+    }
+    const { _internal } = internal, rest = __rest(internal, ["_internal"]);
+    const _a = general !== null && general !== undefined ? general : {}, { id, title } = _a, restGeneral = __rest(_a, ["id", "title"]);
+    return Object.assign(Object.assign(Object.assign({ _internal: Object.assign(Object.assign({}, id ? { refId: id } : {}), _internal) }, rest), title ? { description: title } : {}), restGeneral);
+  }
+  static setMetadataInRegistry(zodSchema, metadata) {
+    zodToOpenAPIRegistry.add(zodSchema, metadata);
+  }
+}
+function preserveMetadataFromModifier(zodSchema, modifier) {
+  const zodModifier = zodSchema[modifier];
+  if (typeof zodModifier !== "function") {
+    return;
+  }
+  zodSchema[modifier] = function(...args) {
+    const result = zodModifier.apply(this, args);
+    const meta = Metadata.getMetadataFromRegistry(this);
+    if (meta) {
+      Metadata.setMetadataInRegistry(result, meta);
+    }
+    return result;
+  };
+}
+function extendZodWithOpenApi(zod) {
+  if (typeof zod.ZodType.prototype.openapi !== "undefined") {
+    return;
+  }
+  zod.ZodType.prototype.openapi = function(...args) {
+    const { refId, metadata, options } = getOpenApiConfiguration(...args);
+    const _a = metadata !== null && metadata !== undefined ? metadata : {}, { param } = _a, restOfOpenApi = __rest(_a, ["param"]);
+    const allMetadata = Metadata.getMetadataFromRegistry(this);
+    const _b = allMetadata !== null && allMetadata !== undefined ? allMetadata : {}, { _internal: internalMetadata } = _b, currentMetadata = __rest(_b, ["_internal"]);
+    const _internal = Object.assign(Object.assign(Object.assign({}, internalMetadata), options), refId ? { refId } : undefined);
+    const resultMetadata = Object.assign(Object.assign(Object.assign({}, currentMetadata), restOfOpenApi), (currentMetadata === null || currentMetadata === undefined ? undefined : currentMetadata.param) || param ? {
+      param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === undefined ? undefined : currentMetadata.param), param)
+    } : undefined);
+    const result = new this.constructor(this._def);
+    function setMetadata(schema) {
+      Metadata.setMetadataInRegistry(schema, Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : undefined), resultMetadata));
+    }
+    setMetadata(result);
+    if (isZodType(result, "ZodLazy")) {
+      setMetadata(this);
+    }
+    if (isZodType(result, "ZodObject")) {
+      const currentMetadata2 = Metadata.getMetadataFromRegistry(result);
+      const originalExtend = result.extend;
+      result.extend = function(...args2) {
+        const extendedResult = originalExtend.apply(result, args2);
+        const _a2 = currentMetadata2 !== null && currentMetadata2 !== undefined ? currentMetadata2 : {}, { _internal: _internal2 } = _a2, rest = __rest(_a2, ["_internal"]);
+        Metadata.setMetadataInRegistry(extendedResult, {
+          _internal: {
+            extendedFrom: (_internal2 === null || _internal2 === undefined ? undefined : _internal2.refId) ? { refId: _internal2.refId, schema: result } : _internal2 === null || _internal2 === undefined ? undefined : _internal2.extendedFrom
+          }
+        });
+        return extendedResult.openapi(rest);
+      };
+      preserveMetadataFromModifier(result, "catchall");
+    }
+    preserveMetadataFromModifier(result, "optional");
+    preserveMetadataFromModifier(result, "nullable");
+    preserveMetadataFromModifier(result, "default");
+    preserveMetadataFromModifier(result, "transform");
+    preserveMetadataFromModifier(result, "refine");
+    preserveMetadataFromModifier(result, "length");
+    preserveMetadataFromModifier(result, "min");
+    preserveMetadataFromModifier(result, "max");
+    const originalMeta = result.meta;
+    result.meta = function(...args2) {
+      const result2 = originalMeta.apply(this, args2);
+      if (args2[0]) {
+        const meta = Metadata.getMetadataFromInternalRegistry(this);
+        if (meta) {
+          Metadata.setMetadataInRegistry(result2, Object.assign(Object.assign({}, meta), args2[0]));
+        }
+      }
+      return result2;
+    };
+    return result;
+  };
+}
+function getOpenApiConfiguration(refOrOpenapi, metadataOrOptions, options) {
+  if (typeof refOrOpenapi === "string") {
+    return {
+      refId: refOrOpenapi,
+      metadata: metadataOrOptions,
+      options
+    };
+  }
+  return {
+    refId: undefined,
+    metadata: refOrOpenapi,
+    options: metadataOrOptions
+  };
+}
+
+class OpenAPIRegistry {
+  constructor(parents) {
+    this.parents = parents;
+    this._definitions = [];
+  }
+  get definitions() {
+    var _a, _b;
+    const parentDefinitions = (_b = (_a = this.parents) === null || _a === undefined ? undefined : _a.flatMap((par) => par._definitions)) !== null && _b !== undefined ? _b : [];
+    return [...parentDefinitions, ...this._definitions];
+  }
+  register(refId, zodSchema) {
+    const schemaWithRefId = this.schemaWithRefId(refId, zodSchema);
+    this._definitions.push({ type: "schema", schema: schemaWithRefId });
+    return schemaWithRefId;
+  }
+  registerParameter(refId, zodSchema) {
+    var _a, _b, _c;
+    const schemaWithRefId = this.schemaWithRefId(refId, zodSchema);
+    const currentMetadata = (_a = Metadata.getOpenApiMetadata(schemaWithRefId)) !== null && _a !== undefined ? _a : {};
+    const schemaWithMetadata = schemaWithRefId.openapi(Object.assign(Object.assign({}, currentMetadata), { param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === undefined ? undefined : currentMetadata.param), { name: (_c = (_b = currentMetadata === null || currentMetadata === undefined ? undefined : currentMetadata.param) === null || _b === undefined ? undefined : _b.name) !== null && _c !== undefined ? _c : refId }) }));
+    this._definitions.push({
+      type: "parameter",
+      schema: schemaWithMetadata
+    });
+    return schemaWithMetadata;
+  }
+  registerPath(route) {
+    this._definitions.push({
+      type: "route",
+      route
+    });
+  }
+  registerWebhook(webhook) {
+    this._definitions.push({
+      type: "webhook",
+      webhook
+    });
+  }
+  registerComponent(type, name, component) {
+    this._definitions.push({
+      type: "component",
+      componentType: type,
+      name,
+      component
+    });
+    return {
+      name,
+      ref: { $ref: `#/components/${type}/${name}` }
+    };
+  }
+  schemaWithRefId(refId, zodSchema) {
+    return zodSchema.openapi(refId);
+  }
+}
+
+class ZodToOpenAPIError {
+  constructor(message) {
+    this.message = message;
+  }
+}
+function enhanceMissingParametersError(action, paramsToAdd) {
+  try {
+    return action();
+  } catch (error) {
+    if (error instanceof MissingParameterDataError) {
+      throw new MissingParameterDataError(Object.assign(Object.assign({}, error.data), paramsToAdd));
+    }
+    throw error;
+  }
+}
+
+class ArrayTransformer {
+  transform(zodSchema, mapNullableType, mapItems) {
+    var _a, _b, _c, _d;
+    const itemType = zodSchema.def.element;
+    const minItems = (_b = (_a = zodSchema.def.checks) === null || _a === undefined ? undefined : _a.find((check) => check._zod.def.check === "min_length")) === null || _b === undefined ? undefined : _b._zod.def.minimum;
+    const maxItems = (_d = (_c = zodSchema.def.checks) === null || _c === undefined ? undefined : _c.find((check) => check._zod.def.check === "max_length")) === null || _d === undefined ? undefined : _d._zod.def.maximum;
+    return Object.assign(Object.assign({}, mapNullableType("array")), {
+      items: isAnyZodType(itemType) ? mapItems(itemType) : {},
+      minItems,
+      maxItems
+    });
+  }
+}
+
+class BigIntTransformer {
+  transform(mapNullableType) {
+    return Object.assign(Object.assign({}, mapNullableType("string")), { pattern: `^d+$` });
+  }
+}
+
+class DiscriminatedUnionTransformer {
+  transform(zodSchema, isNullable, mapNullableOfArray, mapItem, generateSchemaRef) {
+    const options = [...zodSchema.def.options];
+    const optionSchema = options.map(mapItem);
+    if (isNullable) {
+      return {
+        oneOf: mapNullableOfArray(optionSchema, isNullable)
+      };
+    }
+    const discriminator = zodSchema._zod.def.discriminator;
+    if (!discriminator) {
+      console.error("No discriminator found for discriminated union", zodSchema);
+      return {
+        oneOf: optionSchema
+      };
+    }
+    return {
+      oneOf: optionSchema,
+      discriminator: this.mapDiscriminator(options, discriminator, generateSchemaRef)
+    };
+  }
+  mapDiscriminator(zodObjects, discriminator, generateSchemaRef) {
+    if (zodObjects.some((obj) => Metadata.getRefId(obj) === undefined)) {
+      return;
+    }
+    const mapping = {};
+    zodObjects.forEach((obj) => {
+      var _a;
+      const refId = Metadata.getRefId(obj);
+      const value = (_a = obj.def.shape) === null || _a === undefined ? undefined : _a[discriminator];
+      if (isZodType(value, "ZodEnum")) {
+        const keys = Object.values(value._zod.def.entries).filter(isString);
+        keys.forEach((enumValue) => {
+          mapping[enumValue] = generateSchemaRef(refId);
+        });
+        return;
+      }
+      const literalValue = value === null || value === undefined ? undefined : value.def.values[0];
+      if (typeof literalValue !== "string") {
+        throw new Error(`Discriminator ${discriminator} could not be found in one of the values of a discriminated union`);
+      }
+      mapping[literalValue] = generateSchemaRef(refId);
+    });
+    return {
+      propertyName: discriminator,
+      mapping
+    };
+  }
+}
+function enumInfo(enumObject) {
+  const keysExceptReverseMappings = Object.keys(enumObject).filter((key) => typeof enumObject[enumObject[key]] !== "number");
+  const values = keysExceptReverseMappings.map((key) => enumObject[key]);
+  const numericCount = values.filter((_) => typeof _ === "number").length;
+  const type = numericCount === 0 ? "string" : numericCount === values.length ? "numeric" : "mixed";
+  return { values, type };
+}
+
+class EnumTransformer {
+  transform(zodSchema, isNullable, mapNullableType) {
+    const { type, values } = enumInfo(zodSchema._zod.def.entries);
+    if (type === "mixed") {
+      throw new ZodToOpenAPIError("Enum has mixed string and number values, please specify the OpenAPI type manually");
+    }
+    return Object.assign(Object.assign({}, mapNullableType(type === "numeric" ? "integer" : "string")), { enum: isNullable ? [...values, null] : values });
+  }
+}
+
+class IntersectionTransformer {
+  transform(zodSchema, isNullable, mapNullableOfArray, mapItem) {
+    const subtypes = this.flattenIntersectionTypes(zodSchema);
+    const allOfSchema = {
+      allOf: subtypes.map(mapItem)
+    };
+    if (isNullable) {
+      return {
+        anyOf: mapNullableOfArray([allOfSchema], isNullable)
+      };
+    }
+    return allOfSchema;
+  }
+  flattenIntersectionTypes(schema) {
+    if (!isZodType(schema, "ZodIntersection")) {
+      return [schema];
+    }
+    const leftSubTypes = isAnyZodType(schema._zod.def.left) ? this.flattenIntersectionTypes(schema._zod.def.left) : [];
+    const rightSubTypes = isAnyZodType(schema._zod.def.right) ? this.flattenIntersectionTypes(schema._zod.def.right) : [];
+    return [...leftSubTypes, ...rightSubTypes];
+  }
+}
+
+class LiteralTransformer {
+  constructor() {
+    this.bigIntTransformer = new BigIntTransformer;
+  }
+  transform(zodSchema, mapNullableType) {
+    const type = typeof zodSchema.def.values[0];
+    if (type === "boolean" || type === "number" || type === "string" || type === "object") {
+      return Object.assign(Object.assign({}, mapNullableType(type)), { enum: [zodSchema.def.values[0]] });
+    }
+    if (type === "bigint") {
+      return this.bigIntTransformer.transform(mapNullableType);
+    }
+    return mapNullableType("null");
+  }
+}
+
+class NumberTransformer {
+  transform(zodSchema, mapNullableType, getNumberChecks) {
+    var _a;
+    return Object.assign(Object.assign(Object.assign({}, mapNullableType("number")), mapNullableType(zodSchema.format === "safeint" ? "integer" : "number")), getNumberChecks((_a = zodSchema.def.checks) !== null && _a !== undefined ? _a : []));
+  }
+}
+
+class ObjectTransformer {
+  transform(zodSchema, defaultValue, mapNullableType, mapItem) {
+    var _a;
+    const extendedFrom = (_a = Metadata.getInternalMetadata(zodSchema)) === null || _a === undefined ? undefined : _a.extendedFrom;
+    const required = this.requiredKeysOf(zodSchema);
+    const properties = mapValues(zodSchema.def.shape, mapItem);
+    if (!extendedFrom) {
+      return Object.assign(Object.assign(Object.assign(Object.assign({}, mapNullableType("object")), { properties, default: defaultValue }), required.length > 0 ? { required } : {}), this.generateAdditionalProperties(zodSchema, mapItem));
+    }
+    const parent = extendedFrom.schema;
+    mapItem(parent);
+    const keysRequiredByParent = this.requiredKeysOf(parent);
+    const propsOfParent = mapValues(parent === null || parent === undefined ? undefined : parent.def.shape, mapItem);
+    const propertiesToAdd = Object.fromEntries(Object.entries(properties).filter(([key, type]) => {
+      return !objectEquals(propsOfParent[key], type);
+    }));
+    const additionallyRequired = required.filter((prop) => !keysRequiredByParent.includes(prop));
+    const objectData = Object.assign(Object.assign(Object.assign(Object.assign({}, mapNullableType("object")), { default: defaultValue, properties: propertiesToAdd }), additionallyRequired.length > 0 ? { required: additionallyRequired } : {}), this.generateAdditionalProperties(zodSchema, mapItem));
+    return {
+      allOf: [
+        { $ref: `#/components/schemas/${extendedFrom.refId}` },
+        objectData
+      ]
+    };
+  }
+  generateAdditionalProperties(zodSchema, mapItem) {
+    const catchallSchema = zodSchema.def.catchall;
+    if (!catchallSchema) {
+      return {};
+    }
+    if (isZodType(catchallSchema, "ZodNever")) {
+      return { additionalProperties: false };
+    }
+    if (isAnyZodType(catchallSchema)) {
+      return { additionalProperties: mapItem(catchallSchema) };
+    }
+    return {};
+  }
+  requiredKeysOf(objectSchema) {
+    return Object.entries(objectSchema.def.shape).filter(([_key, type]) => !isOptionalSchema(type)).map(([key, _type]) => key);
+  }
+}
+
+class RecordTransformer {
+  transform(zodSchema, mapNullableType, mapItem) {
+    const propertiesType = zodSchema.valueType;
+    const keyType = zodSchema.keyType;
+    const propertiesSchema = isAnyZodType(propertiesType) ? mapItem(propertiesType) : {};
+    if (isZodType(keyType, "ZodEnum")) {
+      const keys = Object.values(keyType._zod.def.entries).filter(isString);
+      const properties = keys.reduce((acc, curr) => Object.assign(Object.assign({}, acc), { [curr]: propertiesSchema }), {});
+      return Object.assign(Object.assign({}, mapNullableType("object")), { properties });
+    }
+    return Object.assign(Object.assign({}, mapNullableType("object")), { additionalProperties: propertiesSchema });
+  }
+}
+function isZodCheckLengthEquals(check) {
+  return check._zod.def.check === "length_equals";
+}
+function isZodCheckRegex(check) {
+  return check._zod.def.check === "string_format" && check._zod.def.format === "regex";
+}
+
+class StringTransformer {
+  transform(zodSchema, mapNullableType) {
+    var _a, _b, _c, _d;
+    const regexCheck = (_a = zodSchema.def.checks) === null || _a === undefined ? undefined : _a.find(isZodCheckRegex);
+    const pattern = regexCheck === null || regexCheck === undefined ? undefined : regexCheck._zod.def.pattern.toString().replace(/^\/|\/$/g, "");
+    const check = (_b = zodSchema.def.checks) === null || _b === undefined ? undefined : _b.find(isZodCheckLengthEquals);
+    const length = check === null || check === undefined ? undefined : check._zod.def.length;
+    const maxLength = Number.isFinite(zodSchema.minLength) ? (_c = zodSchema.minLength) !== null && _c !== undefined ? _c : undefined : undefined;
+    const minLength = Number.isFinite(zodSchema.maxLength) ? (_d = zodSchema.maxLength) !== null && _d !== undefined ? _d : undefined : undefined;
+    return Object.assign(Object.assign({}, mapNullableType("string")), {
+      minLength: length !== null && length !== undefined ? length : maxLength,
+      maxLength: length !== null && length !== undefined ? length : minLength,
+      format: this.mapStringFormat(zodSchema),
+      pattern
+    });
+  }
+  mapStringFormat(zodString) {
+    if (zodString.format === "uuid")
+      return "uuid";
+    if (zodString.format === "email")
+      return "email";
+    if (zodString.format === "url")
+      return "uri";
+    if (zodString.format === "date")
+      return "date";
+    if (zodString.format === "datetime")
+      return "date-time";
+    if (zodString.format === "cuid")
+      return "cuid";
+    if (zodString.format === "cuid2")
+      return "cuid2";
+    if (zodString.format === "ulid")
+      return "ulid";
+    if (zodString.format === "ipv4")
+      return "ip";
+    if (zodString.format === "ipv6")
+      return "ip";
+    if (zodString.format === "emoji")
+      return "emoji";
+    return;
+  }
+}
+
+class TupleTransformer {
+  constructor(versionSpecifics) {
+    this.versionSpecifics = versionSpecifics;
+  }
+  transform(zodSchema, mapNullableType, mapItem) {
+    const items = zodSchema._zod.def.items;
+    const schemas = items.map((item) => isAnyZodType(item) ? mapItem(item) : {});
+    return Object.assign(Object.assign({}, mapNullableType("array")), this.versionSpecifics.mapTupleItems(schemas));
+  }
+}
+
+class UnionTransformer {
+  constructor(options) {
+    this.options = options;
+  }
+  transform(zodSchema, mapNullableOfArray, mapItem) {
+    var _a, _b, _c;
+    const internalMetadata = Metadata.getInternalMetadata(zodSchema);
+    const preferredType = (_c = (_a = internalMetadata === null || internalMetadata === undefined ? undefined : internalMetadata.unionPreferredType) !== null && _a !== undefined ? _a : (_b = this.options) === null || _b === undefined ? undefined : _b.unionPreferredType) !== null && _c !== undefined ? _c : "anyOf";
+    const options = this.flattenUnionTypes(zodSchema);
+    const schemas = options.map((schema) => {
+      const optionToGenerate = this.unwrapNullable(schema);
+      return mapItem(optionToGenerate);
+    });
+    return {
+      [preferredType]: mapNullableOfArray(schemas)
+    };
+  }
+  flattenUnionTypes(schema) {
+    if (!isZodType(schema, "ZodUnion")) {
+      return [schema];
+    }
+    const options = schema.def.options;
+    return options.flatMap((option) => isAnyZodType(option) ? this.flattenUnionTypes(option) : []);
+  }
+  unwrapNullable(schema) {
+    if (isZodType(schema, "ZodNullable")) {
+      const unwrapped = schema.unwrap();
+      if (isAnyZodType(unwrapped)) {
+        return this.unwrapNullable(unwrapped);
+      }
+    }
+    return schema;
+  }
+}
+
+class DateTransformer {
+  transform(mapNullableType) {
+    return Object.assign(Object.assign({}, mapNullableType("string")), { format: "date-time" });
+  }
+}
+
+class LazyTransformer {
+  transform(zodSchema, mapItem, mapNullableType, mapNullableRef) {
+    const result = mapItem(zodSchema._zod.def.getter());
+    return LazyTransformer.mapRecursive(result, mapNullableType, mapNullableRef);
+  }
+  static mapRecursive(schema, mapNullableType, mapNullableRef) {
+    if ("$ref" in schema) {
+      return mapNullableRef(schema);
+    }
+    if (schema.type) {
+      return Object.assign(Object.assign({}, schema), mapNullableType(schema.type));
+    }
+    return schema;
+  }
+}
+
+class TemplateLiteralTransformer {
+  transform(zodSchema, mapNullableType) {
+    const parts = zodSchema.def.parts;
+    const contentPattern = parts.map((part) => this.generatePattern(part)).join("");
+    return Object.assign(Object.assign({}, mapNullableType("string")), { pattern: `^${contentPattern}$` });
+  }
+  generatePattern(part) {
+    if (typeof part === "string" || typeof part === "number" || typeof part === "boolean" || typeof part === "bigint" || part === null || part === undefined) {
+      return this.escapeRegex(String(part));
+    }
+    if (isZodType(part, "ZodLiteral")) {
+      const value = part.def.values[0];
+      return this.escapeRegex(String(value));
+    }
+    if (isZodType(part, "ZodNumber")) {
+      return "[+-]?\\d+(\\.\\d+)?";
+    }
+    if (isZodType(part, "ZodBoolean")) {
+      return "(true|false)";
+    }
+    if (isZodType(part, "ZodEnum")) {
+      const { values } = enumInfo(part.def.entries);
+      return `(${values.map((v) => this.escapeRegex(String(v))).join("|")})`;
+    }
+    return ".*";
+  }
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+}
+
+class OpenApiTransformer {
+  constructor(versionSpecifics, options) {
+    this.versionSpecifics = versionSpecifics;
+    this.objectTransformer = new ObjectTransformer;
+    this.stringTransformer = new StringTransformer;
+    this.numberTransformer = new NumberTransformer;
+    this.bigIntTransformer = new BigIntTransformer;
+    this.dateTransformer = new DateTransformer;
+    this.lazyTransformer = new LazyTransformer;
+    this.literalTransformer = new LiteralTransformer;
+    this.templateLiteralTransformer = new TemplateLiteralTransformer;
+    this.enumTransformer = new EnumTransformer;
+    this.arrayTransformer = new ArrayTransformer;
+    this.discriminatedUnionTransformer = new DiscriminatedUnionTransformer;
+    this.intersectionTransformer = new IntersectionTransformer;
+    this.recordTransformer = new RecordTransformer;
+    this.tupleTransformer = new TupleTransformer(versionSpecifics);
+    this.unionTransformer = new UnionTransformer(options);
+  }
+  transform(zodSchema, isNullable, mapItem, generateSchemaRef, defaultValue) {
+    if (isZodType(zodSchema, "ZodNull")) {
+      return this.versionSpecifics.nullType;
+    }
+    if (isZodType(zodSchema, "ZodUnknown") || isZodType(zodSchema, "ZodAny")) {
+      return this.versionSpecifics.mapNullableType(undefined, isNullable);
+    }
+    if (isZodType(zodSchema, "ZodObject")) {
+      return this.objectTransformer.transform(zodSchema, defaultValue, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+    }
+    const schema = this.transformSchemaWithoutDefault(zodSchema, isNullable, mapItem, generateSchemaRef);
+    return Object.assign(Object.assign({}, schema), { default: defaultValue });
+  }
+  transformSchemaWithoutDefault(zodSchema, isNullable, mapItem, generateSchemaRef) {
+    if (isZodType(zodSchema, "ZodUnknown") || isZodType(zodSchema, "ZodAny")) {
+      return this.versionSpecifics.mapNullableType(undefined, isNullable);
+    }
+    if (isZodType(zodSchema, "ZodString")) {
+      return this.stringTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+    }
+    if (isZodType(zodSchema, "ZodNumber")) {
+      return this.numberTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable), (_) => this.versionSpecifics.getNumberChecks(_));
+    }
+    if (isZodType(zodSchema, "ZodBigInt")) {
+      return this.bigIntTransformer.transform((schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+    }
+    if (isZodType(zodSchema, "ZodBoolean")) {
+      return this.versionSpecifics.mapNullableType("boolean", isNullable);
+    }
+    if (isZodType(zodSchema, "ZodLazy")) {
+      return this.lazyTransformer.transform(zodSchema, mapItem, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable), (schema) => this.versionSpecifics.mapNullableOfRef(schema, isNullable));
+    }
+    if (isZodType(zodSchema, "ZodLiteral")) {
+      return this.literalTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+    }
+    if (isZodType(zodSchema, "ZodTemplateLiteral")) {
+      return this.templateLiteralTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+    }
+    if (isZodType(zodSchema, "ZodEnum")) {
+      return this.enumTransformer.transform(zodSchema, isNullable, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+    }
+    if (isZodType(zodSchema, "ZodArray")) {
+      return this.arrayTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+    }
+    if (isZodType(zodSchema, "ZodTuple")) {
+      return this.tupleTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+    }
+    if (isZodType(zodSchema, "ZodDiscriminatedUnion")) {
+      return this.discriminatedUnionTransformer.transform(zodSchema, isNullable, (_) => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem, generateSchemaRef);
+    }
+    if (isZodType(zodSchema, "ZodUnion")) {
+      return this.unionTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem);
+    }
+    if (isZodType(zodSchema, "ZodIntersection")) {
+      return this.intersectionTransformer.transform(zodSchema, isNullable, (_) => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem);
+    }
+    if (isZodType(zodSchema, "ZodRecord")) {
+      return this.recordTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+    }
+    if (isZodType(zodSchema, "ZodDate")) {
+      return this.dateTransformer.transform((_) => this.versionSpecifics.mapNullableType(_, isNullable));
+    }
+    const refId = Metadata.getRefId(zodSchema);
+    throw new UnknownZodTypeError({
+      currentSchema: zodSchema.def,
+      schemaName: refId
+    });
+  }
+}
+
+class OpenAPIGenerator {
+  constructor(definitions, versionSpecifics, options) {
+    this.definitions = definitions;
+    this.versionSpecifics = versionSpecifics;
+    this.options = options;
+    this.schemaRefs = {};
+    this.paramRefs = {};
+    this.pathRefs = {};
+    this.rawComponents = [];
+    this.openApiTransformer = new OpenApiTransformer(versionSpecifics, options);
+    this.sortDefinitions();
+  }
+  generateDocumentData() {
+    this.definitions.forEach((definition) => this.generateSingle(definition));
+    return {
+      components: this.buildComponents(),
+      paths: this.pathRefs
+    };
+  }
+  generateComponents() {
+    this.definitions.forEach((definition) => this.generateSingle(definition));
+    return {
+      components: this.buildComponents()
+    };
+  }
+  buildComponents() {
+    var _a, _b, _c, _d;
+    const rawComponents = {};
+    this.rawComponents.forEach(({ componentType, name, component }) => {
+      var _a2;
+      (_a2 = rawComponents[componentType]) !== null && _a2 !== undefined || (rawComponents[componentType] = {});
+      rawComponents[componentType][name] = component;
+    });
+    const allSchemas = Object.assign(Object.assign({}, (_a = rawComponents.schemas) !== null && _a !== undefined ? _a : {}), this.filteredSchemaRefs);
+    const schemas = ((_b = this.options) === null || _b === undefined ? undefined : _b.sortComponents) === "alphabetically" ? sortObjectByKeys(allSchemas) : allSchemas;
+    const allParameters = Object.assign(Object.assign({}, (_c = rawComponents.parameters) !== null && _c !== undefined ? _c : {}), this.paramRefs);
+    const parameters = ((_d = this.options) === null || _d === undefined ? undefined : _d.sortComponents) === "alphabetically" ? sortObjectByKeys(allParameters) : allParameters;
+    return Object.assign(Object.assign({}, rawComponents), { schemas, parameters });
+  }
+  isNotPendingRefEntry(entry) {
+    return entry[1] !== "pending";
+  }
+  get filteredSchemaRefs() {
+    const filtered = Object.entries(this.schemaRefs).filter(this.isNotPendingRefEntry);
+    return Object.fromEntries(filtered);
+  }
+  sortDefinitions() {
+    const generationOrder = [
+      "schema",
+      "parameter",
+      "component",
+      "route"
+    ];
+    this.definitions.sort((left, right) => {
+      if (!("type" in left)) {
+        if (!("type" in right)) {
+          return 0;
+        }
+        return -1;
+      }
+      if (!("type" in right)) {
+        return 1;
+      }
+      const leftIndex = generationOrder.findIndex((type) => type === left.type);
+      const rightIndex = generationOrder.findIndex((type) => type === right.type);
+      return leftIndex - rightIndex;
+    });
+  }
+  generateSingle(definition) {
+    if (!("type" in definition)) {
+      this.generateSchemaWithRef(definition);
+      return;
+    }
+    switch (definition.type) {
+      case "parameter":
+        this.generateParameterDefinition(definition.schema);
+        return;
+      case "schema":
+        this.generateSchemaWithRef(definition.schema);
+        return;
+      case "route":
+        this.generateSingleRoute(definition.route);
+        return;
+      case "component":
+        this.rawComponents.push(definition);
+        return;
+    }
+  }
+  generateParameterDefinition(zodSchema) {
+    const refId = Metadata.getRefId(zodSchema);
+    const result = this.generateParameter(zodSchema);
+    if (refId) {
+      this.paramRefs[refId] = result;
+    }
+    return result;
+  }
+  getParameterRef(schema, external) {
+    const metadata = Metadata.getOpenApiMetadata(schema);
+    const internalMetadata = Metadata.getInternalMetadata(schema);
+    const parameterMetadata = metadata === null || metadata === undefined ? undefined : metadata.param;
+    const existingRef = (internalMetadata === null || internalMetadata === undefined ? undefined : internalMetadata.refId) ? this.paramRefs[internalMetadata.refId] : undefined;
+    if (!(internalMetadata === null || internalMetadata === undefined ? undefined : internalMetadata.refId) || !existingRef) {
+      return;
+    }
+    if (parameterMetadata && existingRef.in !== parameterMetadata.in || (external === null || external === undefined ? undefined : external.in) && existingRef.in !== external.in) {
+      throw new ConflictError(`Conflicting location for parameter ${existingRef.name}`, {
+        key: "in",
+        values: compact([
+          existingRef.in,
+          external === null || external === undefined ? undefined : external.in,
+          parameterMetadata === null || parameterMetadata === undefined ? undefined : parameterMetadata.in
+        ])
+      });
+    }
+    if (parameterMetadata && existingRef.name !== parameterMetadata.name || (external === null || external === undefined ? undefined : external.name) && existingRef.name !== (external === null || external === undefined ? undefined : external.name)) {
+      throw new ConflictError(`Conflicting names for parameter`, {
+        key: "name",
+        values: compact([
+          existingRef.name,
+          external === null || external === undefined ? undefined : external.name,
+          parameterMetadata === null || parameterMetadata === undefined ? undefined : parameterMetadata.name
+        ])
+      });
+    }
+    return {
+      $ref: `#/components/parameters/${internalMetadata.refId}`
+    };
+  }
+  generateInlineParameters(zodSchema, location) {
+    const metadata = Metadata.getOpenApiMetadata(zodSchema);
+    const parameterMetadata = metadata === null || metadata === undefined ? undefined : metadata.param;
+    const referencedSchema = this.getParameterRef(zodSchema, { in: location });
+    if (referencedSchema) {
+      return [referencedSchema];
+    }
+    if (isZodType(zodSchema, "ZodObject")) {
+      const propTypes = zodSchema.def.shape;
+      const parameters = Object.entries(propTypes).map(([key, schema]) => {
+        var _a;
+        const innerMetadata = Metadata.getOpenApiMetadata(schema);
+        const referencedSchema2 = this.getParameterRef(schema, {
+          in: location,
+          name: key
+        });
+        if (referencedSchema2) {
+          return referencedSchema2;
+        }
+        const innerParameterMetadata = innerMetadata === null || innerMetadata === undefined ? undefined : innerMetadata.param;
+        if ((innerParameterMetadata === null || innerParameterMetadata === undefined ? undefined : innerParameterMetadata.name) && innerParameterMetadata.name !== key) {
+          throw new ConflictError(`Conflicting names for parameter`, {
+            key: "name",
+            values: [key, innerParameterMetadata.name]
+          });
+        }
+        if ((innerParameterMetadata === null || innerParameterMetadata === undefined ? undefined : innerParameterMetadata.in) && innerParameterMetadata.in !== location) {
+          throw new ConflictError(`Conflicting location for parameter ${(_a = innerParameterMetadata.name) !== null && _a !== undefined ? _a : key}`, {
+            key: "in",
+            values: [location, innerParameterMetadata.in]
+          });
+        }
+        return this.generateParameter(schema, { name: key, in: location });
+      });
+      return parameters;
+    }
+    if ((parameterMetadata === null || parameterMetadata === undefined ? undefined : parameterMetadata.in) && parameterMetadata.in !== location) {
+      throw new ConflictError(`Conflicting location for parameter ${parameterMetadata.name}`, {
+        key: "in",
+        values: [location, parameterMetadata.in]
+      });
+    }
+    return [this.generateParameter(zodSchema, { in: location })];
+  }
+  generateSimpleParameter(zodSchema, externalParamMetadata) {
+    const metadata = Metadata.getParamMetadata(zodSchema);
+    const paramMetadata = metadata === null || metadata === undefined ? undefined : metadata.param;
+    const mergedParamMetadata = Object.assign(Object.assign({}, paramMetadata), externalParamMetadata);
+    const required = !isOptionalSchema(zodSchema) && !isNullableSchema(zodSchema);
+    const schema = this.generateSchemaWithRef(zodSchema);
+    return Object.assign({
+      schema,
+      required
+    }, Object.keys(mergedParamMetadata).length > 0 ? Metadata.buildParameterMetadata(mergedParamMetadata) : {});
+  }
+  generateParameter(zodSchema, externalParamMetadata) {
+    var _a, _b;
+    const metadata = Metadata.getOpenApiMetadata(zodSchema);
+    const paramMetadata = metadata === null || metadata === undefined ? undefined : metadata.param;
+    const paramName = (_a = externalParamMetadata === null || externalParamMetadata === undefined ? undefined : externalParamMetadata.name) !== null && _a !== undefined ? _a : paramMetadata === null || paramMetadata === undefined ? undefined : paramMetadata.name;
+    const paramLocation = (_b = externalParamMetadata === null || externalParamMetadata === undefined ? undefined : externalParamMetadata.in) !== null && _b !== undefined ? _b : paramMetadata === null || paramMetadata === undefined ? undefined : paramMetadata.in;
+    if (!paramName) {
+      throw new MissingParameterDataError({ missingField: "name" });
+    }
+    if (!paramLocation) {
+      throw new MissingParameterDataError({
+        missingField: "in",
+        paramName
+      });
+    }
+    const baseParameter = this.generateSimpleParameter(zodSchema, externalParamMetadata);
+    return Object.assign(Object.assign({}, baseParameter), { in: paramLocation, name: paramName });
+  }
+  generateSchemaWithMetadata(zodSchema) {
+    const innerSchema = Metadata.unwrapChained(zodSchema);
+    const metadata = Metadata.getOpenApiMetadata(zodSchema);
+    const defaultValue = Metadata.getDefaultValue(zodSchema);
+    const refId = Metadata.getRefId(zodSchema);
+    if (refId && typeof this.schemaRefs[refId] === "object") {
+      return this.schemaRefs[refId];
+    }
+    if (refId && this.schemaRefs[refId] === "pending") {
+      const refSchema = { $ref: this.generateSchemaRef(refId) };
+      return this.versionSpecifics.mapNullableOfRef(refSchema, isNullableSchema(zodSchema));
+    }
+    if (refId && !this.schemaRefs[refId]) {
+      this.schemaRefs[refId] = "pending";
+    }
+    const result = (metadata === null || metadata === undefined ? undefined : metadata.type) ? { type: metadata.type } : this.toOpenAPISchema(innerSchema, isNullableSchema(zodSchema), defaultValue);
+    return metadata ? Metadata.applySchemaMetadata(result, metadata) : omitBy(result, isUndefined);
+  }
+  constructReferencedOpenAPISchema(zodSchema) {
+    const metadata = Metadata.getOpenApiMetadata(zodSchema);
+    const innerSchema = Metadata.unwrapChained(zodSchema);
+    const defaultValue = Metadata.getDefaultValue(zodSchema);
+    const isNullable = isNullableSchema(zodSchema);
+    if (metadata === null || metadata === undefined ? undefined : metadata.type) {
+      return this.versionSpecifics.mapNullableType(metadata.type, isNullable);
+    }
+    const refId = Metadata.getRefId(zodSchema);
+    if (refId && typeof this.schemaRefs[refId] === "object") {
+      return LazyTransformer.mapRecursive(this.schemaRefs[refId], (schema) => this.versionSpecifics.mapNullableType(schema, isNullable), (schema) => this.versionSpecifics.mapNullableOfRef(schema, isNullable));
+    }
+    if (refId && this.schemaRefs[refId] === "pending") {
+      const refSchema = { $ref: this.generateSchemaRef(refId) };
+      return this.versionSpecifics.mapNullableOfRef(refSchema, isNullable);
+    }
+    if (refId && !this.schemaRefs[refId]) {
+      this.schemaRefs[refId] = "pending";
+    }
+    return this.toOpenAPISchema(innerSchema, isNullable, defaultValue);
+  }
+  generateSimpleSchema(zodSchema) {
+    const metadata = Metadata.getOpenApiMetadata(zodSchema);
+    const refId = Metadata.getRefId(zodSchema);
+    if (!refId || !this.schemaRefs[refId]) {
+      return this.generateSchemaWithMetadata(zodSchema);
+    }
+    const schemaRef = this.schemaRefs[refId];
+    const referenceObject = {
+      $ref: this.generateSchemaRef(refId)
+    };
+    if (this.schemaRefs[refId] === "pending") {
+      return this.versionSpecifics.mapNullableOfRef(referenceObject, isNullableSchema(zodSchema));
+    }
+    const newMetadata = omitBy(Metadata.buildSchemaMetadata(metadata !== null && metadata !== undefined ? metadata : {}), (value, key) => value === undefined || objectEquals(value, schemaRef[key]));
+    if (newMetadata.type) {
+      return {
+        allOf: [referenceObject, newMetadata]
+      };
+    }
+    const newSchemaMetadata = omitBy(this.constructReferencedOpenAPISchema(zodSchema), (value, key) => value === undefined || objectEquals(value, schemaRef[key]));
+    const appliedMetadata = Metadata.applySchemaMetadata(newSchemaMetadata, newMetadata);
+    if (Object.keys(appliedMetadata).length > 0) {
+      return {
+        allOf: [referenceObject, appliedMetadata]
+      };
+    }
+    return referenceObject;
+  }
+  generateSchemaWithRef(zodSchema) {
+    const refId = Metadata.getRefId(zodSchema);
+    if (refId && !this.schemaRefs[refId]) {
+      this.schemaRefs[refId] = this.generateSimpleSchema(zodSchema);
+      return { $ref: this.generateSchemaRef(refId) };
+    }
+    return this.generateSimpleSchema(zodSchema);
+  }
+  generateSchemaRef(refId) {
+    return `#/components/schemas/${refId}`;
+  }
+  getRequestBody(requestBody) {
+    if (!requestBody) {
+      return;
+    }
+    const { content } = requestBody, rest = __rest(requestBody, ["content"]);
+    const requestBodyContent = this.getBodyContent(content);
+    return Object.assign(Object.assign({}, rest), { content: requestBodyContent });
+  }
+  getParameters(request) {
+    if (!request) {
+      return [];
+    }
+    const { headers } = request;
+    const query = this.cleanParameter(request.query);
+    const params = this.cleanParameter(request.params);
+    const cookies = this.cleanParameter(request.cookies);
+    const queryParameters = enhanceMissingParametersError(() => query ? this.generateInlineParameters(query, "query") : [], { location: "query" });
+    const pathParameters = enhanceMissingParametersError(() => params ? this.generateInlineParameters(params, "path") : [], { location: "path" });
+    const cookieParameters = enhanceMissingParametersError(() => cookies ? this.generateInlineParameters(cookies, "cookie") : [], { location: "cookie" });
+    const headerParameters = enhanceMissingParametersError(() => {
+      if (Array.isArray(headers)) {
+        return headers.flatMap((header) => this.generateInlineParameters(header, "header"));
+      }
+      const cleanHeaders = this.cleanParameter(headers);
+      return cleanHeaders ? this.generateInlineParameters(cleanHeaders, "header") : [];
+    }, { location: "header" });
+    return [
+      ...pathParameters,
+      ...queryParameters,
+      ...headerParameters,
+      ...cookieParameters
+    ];
+  }
+  cleanParameter(schema) {
+    if (!schema) {
+      return;
+    }
+    if (isZodType(schema, "ZodPipe")) {
+      const inSchema = schema._zod.def.in;
+      const outSchema = schema._zod.def.out;
+      if (isZodType(inSchema, "ZodObject")) {
+        return this.cleanParameter(inSchema);
+      }
+      if (isZodType(outSchema, "ZodObject")) {
+        return this.cleanParameter(outSchema);
+      }
+      return;
+    }
+    return schema;
+  }
+  generatePath(route) {
+    const { method, path, request, responses } = route, pathItemConfig = __rest(route, ["method", "path", "request", "responses"]);
+    const generatedResponses = mapValues(responses, (response) => {
+      return this.getResponse(response);
+    });
+    const parameters = enhanceMissingParametersError(() => this.getParameters(request), { route: `${method} ${path}` });
+    const requestBody = this.getRequestBody(request === null || request === undefined ? undefined : request.body);
+    const routeDoc = {
+      [method]: Object.assign(Object.assign(Object.assign(Object.assign({}, pathItemConfig), parameters.length > 0 ? {
+        parameters: [...pathItemConfig.parameters || [], ...parameters]
+      } : {}), requestBody ? { requestBody } : {}), { responses: generatedResponses })
+    };
+    return routeDoc;
+  }
+  generateSingleRoute(route) {
+    const routeDoc = this.generatePath(route);
+    this.pathRefs[route.path] = Object.assign(Object.assign({}, this.pathRefs[route.path]), routeDoc);
+    return routeDoc;
+  }
+  getResponse(response) {
+    if (this.isReferenceObject(response)) {
+      return response;
+    }
+    const { content, headers } = response, rest = __rest(response, ["content", "headers"]);
+    const responseContent = content ? { content: this.getBodyContent(content) } : {};
+    if (!headers) {
+      return Object.assign(Object.assign({}, rest), responseContent);
+    }
+    const responseHeaders = isZodType(headers, "ZodObject") ? this.getResponseHeaders(headers) : headers;
+    return Object.assign(Object.assign(Object.assign({}, rest), { headers: responseHeaders }), responseContent);
+  }
+  isReferenceObject(schema) {
+    return "$ref" in schema;
+  }
+  getResponseHeaders(headers) {
+    const schemaShape = headers.def.shape;
+    const responseHeaders = mapValues(schemaShape, (_) => this.generateSimpleParameter(_));
+    return responseHeaders;
+  }
+  getBodyContent(content) {
+    return mapValues(content, (config) => {
+      if (!config || !isAnyZodType(config.schema)) {
+        return config;
+      }
+      const { schema: configSchema } = config, rest = __rest(config, ["schema"]);
+      const schema = this.generateSchemaWithRef(configSchema);
+      return Object.assign({ schema }, rest);
+    });
+  }
+  toOpenAPISchema(zodSchema, isNullable, defaultValue) {
+    const result = this.openApiTransformer.transform(zodSchema, isNullable, (_) => this.generateSchemaWithRef(_), (_) => this.generateSchemaRef(_), defaultValue);
+    return result;
+  }
+}
+
+class OpenApiGeneratorV31Specifics {
+  get nullType() {
+    return { type: "null" };
+  }
+  mapNullableOfArray(objects, isNullable) {
+    if (isNullable && !objects.some((object) => objectEquals(object, this.nullType))) {
+      return [...objects, this.nullType];
+    }
+    return objects;
+  }
+  mapNullableType(type, isNullable) {
+    if (!type) {
+      return {};
+    }
+    if (isNullable) {
+      const typeArray = Array.isArray(type) ? type : [type];
+      const nullableType = uniq([...typeArray, "null"]);
+      return { type: nullableType };
+    }
+    return { type };
+  }
+  mapNullableOfRef(ref, isNullable) {
+    if (isNullable) {
+      return {
+        oneOf: [ref, this.nullType]
+      };
+    }
+    return ref;
+  }
+  mapTupleItems(schemas) {
+    return {
+      prefixItems: schemas
+    };
+  }
+  getNumberChecks(checks) {
+    return Object.assign({}, ...checks.map((check) => {
+      switch (check._zod.def.check) {
+        case "greater_than": {
+          const greaterThanCheck = check;
+          return greaterThanCheck._zod.def.inclusive ? { minimum: Number(greaterThanCheck._zod.def.value) } : { exclusiveMinimum: Number(greaterThanCheck._zod.def.value) };
+        }
+        case "less_than": {
+          const lessThanCheck = check;
+          return lessThanCheck._zod.def.inclusive ? { maximum: Number(lessThanCheck._zod.def.value) } : { exclusiveMaximum: Number(lessThanCheck._zod.def.value) };
+        }
+        default:
+          return {};
+      }
+    }));
+  }
+}
+function isWebhookDefinition(definition) {
+  return "type" in definition && definition.type === "webhook";
+}
+
+class OpenApiGeneratorV31 {
+  constructor(definitions, options) {
+    this.definitions = definitions;
+    this.webhookRefs = {};
+    const specifics = new OpenApiGeneratorV31Specifics;
+    this.generator = new OpenAPIGenerator(this.definitions, specifics, options);
+  }
+  generateDocument(config) {
+    const baseDocument = this.generator.generateDocumentData();
+    this.definitions.filter(isWebhookDefinition).forEach((definition) => this.generateSingleWebhook(definition.webhook));
+    return Object.assign(Object.assign(Object.assign({}, config), baseDocument), { webhooks: this.webhookRefs });
+  }
+  generateComponents() {
+    return this.generator.generateComponents();
+  }
+  generateSingleWebhook(route) {
+    const routeDoc = this.generator.generatePath(route);
+    this.webhookRefs[route.path] = Object.assign(Object.assign({}, this.webhookRefs[route.path]), routeDoc);
+    return routeDoc;
+  }
+}
+var ZodTypeKeys, objectEquals, zodToOpenAPIRegistry, ConflictError, MissingParameterDataError, UnknownZodTypeError, $OpenAPIRegistry, $OpenApiGeneratorV31, $extendZodWithOpenApi;
+var init_dist = __esm(() => {
+  ZodTypeKeys = {
+    ZodAny: "any",
+    ZodArray: "array",
+    ZodBigInt: "bigint",
+    ZodBoolean: "boolean",
+    ZodDefault: "default",
+    ZodPrefault: "prefault",
+    ZodTransform: "transform",
+    ZodEnum: "enum",
+    ZodIntersection: "intersection",
+    ZodLazy: "lazy",
+    ZodLiteral: "literal",
+    ZodNever: "never",
+    ZodNull: "null",
+    ZodNullable: "nullable",
+    ZodNumber: "number",
+    ZodNonOptional: "nonoptional",
+    ZodObject: "object",
+    ZodOptional: "optional",
+    ZodPipe: "pipe",
+    ZodReadonly: "readonly",
+    ZodRecord: "record",
+    ZodString: "string",
+    ZodTuple: "tuple",
+    ZodType: "type",
+    ZodUnion: "union",
+    ZodDiscriminatedUnion: "union",
+    ZodUnknown: "unknown",
+    ZodVoid: "void",
+    ZodDate: "date",
+    ZodTemplateLiteral: "template_literal"
+  };
+  objectEquals = isEqual;
+  zodToOpenAPIRegistry = registry();
+  ConflictError = class ConflictError extends ZodToOpenAPIError {
+    constructor(message, data) {
+      super(message);
+      this.data = data;
+    }
+  };
+  MissingParameterDataError = class MissingParameterDataError extends ZodToOpenAPIError {
+    constructor(data) {
+      super(`Missing parameter data, please specify \`${data.missingField}\` and other OpenAPI parameter props using the \`param\` field of \`schema.openapi\``);
+      this.data = data;
+    }
+  };
+  UnknownZodTypeError = class UnknownZodTypeError extends ZodToOpenAPIError {
+    constructor(data) {
+      super(`Unknown zod object type, please specify \`type\` and other OpenAPI props using \`schema.openapi\`.`);
+      this.data = data;
+    }
+  };
+  $OpenAPIRegistry = OpenAPIRegistry;
+  $OpenApiGeneratorV31 = OpenApiGeneratorV31;
+  $extendZodWithOpenApi = extendZodWithOpenApi;
+});
+
+// src/utils/zod-openapi.ts
+var init_zod_openapi = __esm(() => {
+  init_dist();
+  init_zod();
+  $extendZodWithOpenApi(exports_zod);
+});
+
+// src/types.ts
+function parseModelTier(value) {
+  if (!value)
+    return;
+  const normalized = value.trim().toLowerCase();
+  return ModelTierSchema.safeParse(normalized).success ? normalized : LEGACY_MODEL_TO_TIER[normalized];
+}
+function splitLegacyModelAlias(input) {
+  const explicitTier = parseModelTier(input.modelTier);
+  const model = input.model?.trim();
+  if (!model)
+    return { modelTier: explicitTier };
+  const legacyTier = parseModelTier(model);
+  if (legacyTier && !explicitTier) {
+    return { modelTier: legacyTier };
+  }
+  return {
+    model,
+    modelTier: explicitTier
+  };
+}
+function parseTierMapJson(value) {
+  if (!value)
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return {};
+    const result = {};
+    for (const tier of MODEL_TIERS) {
+      const model = parsed[tier];
+      if (typeof model === "string" && model.trim())
+        result[tier] = model.trim();
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function resolveModelTier(opts) {
+  const tier = parseModelTier(opts.tier);
+  if (!tier)
+    return;
+  const env = opts.env ?? {};
+  const jsonOverrides = parseTierMapJson(env.MODEL_TIER_MAP);
+  const envKey = `MODEL_TIER_${tier.toUpperCase()}`;
+  const directOverride = env[envKey]?.trim();
+  if (directOverride)
+    return directOverride;
+  if (jsonOverrides[tier])
+    return jsonOverrides[tier];
+  return DEFAULT_MODEL_TIER_MAP[opts.harnessProvider]?.[tier];
+}
+function resolveTaskModelSelection(opts) {
+  const model = opts.model?.trim();
+  if (model)
+    return { model, source: "model" };
+  const tierModel = resolveModelTier({
+    tier: opts.modelTier,
+    harnessProvider: opts.harnessProvider,
+    env: opts.env
+  });
+  if (tierModel)
+    return { model: tierModel, source: "modelTier" };
+  return { source: "none" };
+}
+function isTerminalTaskStatus(status) {
+  return TERMINAL_TASK_STATUSES.includes(status);
+}
+var AssetKeySchema, AssetEntityTypeSchema, AssetProviderRefSchema, AssetKeyMappingSchema, AssetSummarySchema, ModelTierSchema, MODEL_TIERS, ReasoningEffortSchema, LEGACY_MODEL_TO_TIER, DEFAULT_MODEL_TIER_MAP, AgentTaskStatusSchema, TERMINAL_TASK_STATUSES, InboxMessageStatusSchema, InboxMessageSchema, AgentTaskSourceSchema, RoutingReasonSchema, RoutingSourceSchema, ProviderNameSchema, SteerModeSchema, SteeringStatusSchema, SteeringSourceSchema, SteeringMessageSchema, SteerOutcomeSchema, OnUnsupportedSchema, SteerResultSchema, PROVIDER_STEER_CAPABILITIES, FollowUpConfigSchema, RoutingAffinitySchema, AgentTaskSchema, CreateTaskOptionsSchema, TaskAttachmentKindSchema, SERVER_GENERATED_ATTACHMENT_CAPABILITY = "_agentSwarmGeneratedBy", attachmentCapabilitiesSchema, attachmentCommonFields, AttachmentInputSchema, TaskAttachmentSchema, UserSchema, UserCommsPrefsSchema, IdentityEventTypeSchema, InboxItemTypeSchema, InboxItemStatusSchema, InboxItemStateSchema, FavoriteItemTypeSchema, UserFavoriteSchema, TaskTemplateKindSchema, TaskTemplateSchema, AgentStatusSchema, AgentAvatarSchema, AgentSchema, AgentCredStatusLiveTestSchema, AgentLatestModelSchema, AgentBedrockStatusSchema, AcpSessionConfigSelectValueSchema, AcpSessionConfigSelectGroupSchema, AcpSessionConfigOptionSchema, AgentAcpStatusSchema, AgentCredStatusSchema, AgentWithTasksSchema, ChangeSourceSchema, VersionableFieldSchema, ContextVersionSchema, ChannelTypeSchema, ChannelSchema, ChannelMessageSchema, ServiceStatusSchema, ServiceSchema, AgentLogEventTypeSchema, ResumeReasonSchema, AgentLogSchema, SessionLogSchema, SessionCostSourceSchema, SessionCostModelBreakdownSchema, SessionCostSchema, EventCategorySchema, EventStatusSchema, EventSourceSchema, EventNameSchema, SwarmEventSchema, AutomationIntegrationIdSchema, ScheduledTaskTargetTypeSchema, ScheduledTaskSchema, SwarmConfigScopeSchema, SwarmConfigSchema, RepoGuidelinesSchema, REPO_GUIDELINES_MAX_ENTRIES = 50, RepoGuidelinesInputSchema, RepoHooksSchema, SwarmRepoSchema, AgentMemoryScopeSchema, AgentMemorySourceSchema, AgentMemorySchema, ActiveSessionSchema, RuntimeInstanceStatusSchema, RuntimeInstanceSchema, RetryPolicySchema, ExecutorMetaSchema, ValidationResultSchema, StepValidationConfigSchema, SwarmScriptNodeConfigSchema, WorkflowNodeSchema, WorkflowEdgeSchema, WorkflowDefinitionSchema, WorkflowNodePatchSchema, WorkflowPatchSchema, WebhookVerificationSchema, TriggerConfigSchema, CooldownConfigSchema, InputValueSchema, WorkflowTemplateSchema, WorkflowSnapshotSchema, WorkflowSchema, WorkflowVersionSchema, PageContentTypeSchema, PageAuthModeSchema, PageSnapshotSchema, PageSchema, PageVersionSchema, MetricParamSchema, MetricVariableTypeSchema, MetricFormatSchema, MetricVisualizationSchema, MetricQuerySchema, MetricVariableSchema, MetricVizConfigSchema, MetricWidgetSchema, MetricDefinitionSchema, MetricSnapshotSchema, MetricSchema, MetricVersionSchema, WorkflowRunStatusSchema, WorkflowRunSchema, ScriptRunStatusSchema, TERMINAL_SCRIPT_RUN_STATUSES, ScriptRunKindSchema, ScriptRunSchema, ScriptRunListItemSchema, ScriptRunJournalEntrySchema, WorkflowRunStepStatusSchema, WorkflowRunStepSchema, WaitModeSchema, WaitStateStatusSchema, WaitStateRowSchema, PromptTemplateScopeSchema, PromptTemplateStateSchema, PromptTemplateSchema, PromptTemplateHistorySchema, ScriptScopeSchema, ScriptFsModeSchema, ScriptRecordSchema, ScriptVersionRecordSchema, ExtensionNameSchema, SemverSchema, ExtensionManifestSchema, ExtensionStatusSchema, ExtensionSchema, ExtensionFileSchema, ExtensionVersionSchema, ExtensionRunSchema, ExtensionInstallBodySchema, ScriptApiAuthModeSchema, ScriptApiRecordSchema, SkillTypeSchema, SkillScopeSchema, SkillSchema, AgentSkillSchema, SkillWithInstallInfoSchema, SkillFileSchema, McpServerTransportSchema, McpServerScopeSchema, McpAuthMethodSchema, McpServerSchema, AgentMcpServerSchema, McpServerWithInstallInfoSchema, ContextSnapshotEventTypeSchema, ContextFormulaSchema, ContextSnapshotSchema, BudgetScopeSchema, BudgetSchema, PricingProviderSchema, PricingTokenClassSchema, PricingRowSchema, BudgetRefusalCauseSchema, BudgetRefusalNotificationSchema, BudgetRefusedTriggerSchema, KvValueTypeSchema, KV_NAME_REGEX, KvNamespaceSchema, KvKeySchema, KvEntrySchema;
+var init_types = __esm(() => {
+  init_key();
+  init_bundle_path();
+  init_constants();
+  init_zod_openapi();
+  AssetKeySchema = exports_zod.string().min(1).max(255).superRefine((value, ctx) => {
+    try {
+      normalizeAssetKey(value);
+    } catch (error) {
+      ctx.addIssue({
+        code: "custom",
+        message: error instanceof Error ? error.message : "Invalid asset namespace key"
+      });
+    }
+  }).describe("Non-unique asset directory namespace (for example shared/ or personal/<user-id>/drafts/). Runtime write boundaries normalize and validate the canonical form.");
+  AssetEntityTypeSchema = exports_zod.enum([
+    "task",
+    "workflow",
+    "schedule",
+    "page",
+    "app",
+    "script",
+    "file"
+  ]);
+  AssetProviderRefSchema = exports_zod.object({
+    providerId: exports_zod.string(),
+    orgId: exports_zod.string().optional(),
+    driveId: exports_zod.string().optional(),
+    providerKey: exports_zod.string()
+  }).openapi("AssetProviderRef");
+  AssetKeyMappingSchema = exports_zod.object({
+    id: exports_zod.string(),
+    providerId: exports_zod.string(),
+    providerOrgId: exports_zod.string().optional(),
+    providerDriveId: exports_zod.string().optional(),
+    providerKey: exports_zod.string(),
+    key: AssetKeySchema,
+    sourceEntityType: exports_zod.enum(["task-attachment", "external"]).optional(),
+    sourceEntityId: exports_zod.string().optional(),
+    createdAt: exports_zod.iso.datetime(),
+    updatedAt: exports_zod.iso.datetime(),
+    createdBy: exports_zod.string().optional(),
+    updatedBy: exports_zod.string().optional()
+  }).openapi("AssetKeyMapping");
+  AssetSummarySchema = exports_zod.object({
+    entityType: AssetEntityTypeSchema,
+    id: exports_zod.string(),
+    key: AssetKeySchema,
+    label: exports_zod.string(),
+    updatedAt: exports_zod.string(),
+    providerRef: AssetProviderRefSchema.optional()
+  }).openapi("AssetSummary");
+  ModelTierSchema = exports_zod.enum(["smol", "regular", "smart", "ultra"]);
+  MODEL_TIERS = ModelTierSchema.options;
+  ReasoningEffortSchema = exports_zod.enum(["off", "low", "medium", "high", "xhigh", "max"]);
+  LEGACY_MODEL_TO_TIER = {
+    haiku: "smol",
+    sonnet: "regular",
+    opus: "smart",
+    fable: "ultra"
+  };
+  DEFAULT_MODEL_TIER_MAP = {
+    claude: {
+      smol: "haiku",
+      regular: "sonnet",
+      smart: "opus",
+      ultra: "fable"
+    },
+    "claude-managed": {
+      smol: "claude-haiku-4-5",
+      regular: "claude-sonnet-5",
+      smart: "claude-opus-4-8",
+      ultra: "claude-fable-5"
+    },
+    codex: {
+      smol: "gpt-5.6-luna",
+      regular: "gpt-5.6-terra",
+      smart: "gpt-5.6-sol",
+      ultra: "gpt-5.6-sol"
+    },
+    pi: {
+      smol: "openrouter/deepseek/deepseek-v4.1-flash",
+      regular: "openrouter/deepseek/deepseek-v4.1-flash",
+      smart: "openrouter/deepseek/deepseek-v4-pro-0813",
+      ultra: "openrouter/anthropic/claude-opus-5.5"
+    },
+    opencode: {
+      smol: "openrouter/deepseek/deepseek-v4.1-flash",
+      regular: "openrouter/deepseek/deepseek-v4.1-flash",
+      smart: "openrouter/deepseek/deepseek-v4-pro-0813",
+      ultra: "openrouter/anthropic/claude-opus-5.5"
+    },
+    dsh: {
+      smol: "openrouter/deepseek/deepseek-v4.1-flash",
+      regular: "openrouter/deepseek/deepseek-v4.1-flash",
+      smart: "openrouter/deepseek/deepseek-v4-pro-0813",
+      ultra: "openrouter/anthropic/claude-opus-5.5"
+    },
+    devin: {
+      smol: "devin",
+      regular: "devin",
+      smart: "devin",
+      ultra: "devin"
+    },
+    acp: {
+      smol: "",
+      regular: "",
+      smart: "",
+      ultra: ""
+    }
+  };
+  AgentTaskStatusSchema = exports_zod.enum([
+    "draft",
+    "backlog",
+    "unassigned",
+    "offered",
+    "reviewing",
+    "pending",
+    "in_progress",
+    "paused",
+    "completed",
+    "failed",
+    "cancelled",
+    "superseded"
+  ]);
+  TERMINAL_TASK_STATUSES = ["completed", "failed", "cancelled", "superseded"];
+  InboxMessageStatusSchema = exports_zod.enum([
+    "unread",
+    "processing",
+    "read",
+    "responded",
+    "delegated"
+  ]);
+  InboxMessageSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    agentId: exports_zod.string(),
+    content: exports_zod.string().min(1),
+    source: exports_zod.enum(["slack", "agentmail"]).default("slack"),
+    status: InboxMessageStatusSchema.default("unread"),
+    slackChannelId: exports_zod.string().optional(),
+    slackThreadTs: exports_zod.string().optional(),
+    slackUserId: exports_zod.string().optional(),
+    matchedText: exports_zod.string().optional(),
+    delegatedToTaskId: exports_zod.uuid().optional(),
+    responseText: exports_zod.string().optional(),
+    createdAt: exports_zod.iso.datetime(),
+    lastUpdatedAt: exports_zod.iso.datetime()
+  }).openapi("InboxMessage");
+  AgentTaskSourceSchema = exports_zod.enum([
+    "mcp",
+    "slack",
+    "api",
+    "ui",
+    "github",
+    "gitlab",
+    "agentmail",
+    "system",
+    "schedule",
+    "workflow",
+    "linear",
+    "jira"
+  ]);
+  RoutingReasonSchema = exports_zod.enum([
+    "skill",
+    "continuity",
+    "overflow",
+    "human_pinned",
+    "reroute_fault"
+  ]);
+  RoutingSourceSchema = exports_zod.enum(["declared", "engine_default"]);
+  ProviderNameSchema = exports_zod.enum([
+    "claude",
+    "codex",
+    "pi",
+    "devin",
+    "claude-managed",
+    "opencode",
+    "acp",
+    "dsh"
+  ]);
+  SteerModeSchema = exports_zod.enum(["steer", "queue"]);
+  SteeringStatusSchema = exports_zod.enum([
+    "pending",
+    "delivered",
+    "handled",
+    "promoted",
+    "cancelled"
+  ]);
+  SteeringSourceSchema = exports_zod.enum(["ui", "mcp", "script", "slack", "api"]);
+  SteeringMessageSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    taskId: exports_zod.uuid(),
+    body: exports_zod.string().min(1),
+    mode: SteerModeSchema,
+    status: SteeringStatusSchema,
+    deliveredMode: SteerModeSchema.optional(),
+    source: SteeringSourceSchema,
+    senderLabel: exports_zod.string().optional(),
+    createdByKind: exports_zod.enum(["user", "agent", "system"]),
+    createdByUserId: exports_zod.string().optional(),
+    createdByAgentId: exports_zod.string().optional(),
+    promotedTaskId: exports_zod.uuid().optional(),
+    createdAt: exports_zod.iso.datetime(),
+    deliveredAt: exports_zod.iso.datetime().optional(),
+    handledAt: exports_zod.iso.datetime().optional(),
+    handledNote: exports_zod.string().optional()
+  }).openapi("SteeringMessage");
+  SteerOutcomeSchema = exports_zod.enum(["steered", "queued", "promoted"]);
+  OnUnsupportedSchema = exports_zod.enum(["degrade", "fail"]).default("degrade");
+  SteerResultSchema = exports_zod.object({
+    outcome: SteerOutcomeSchema,
+    steeringMessageId: exports_zod.uuid().optional(),
+    promotedTaskId: exports_zod.uuid().optional(),
+    effectiveMode: SteerModeSchema,
+    degradedFrom: SteerModeSchema.optional()
+  }).openapi("SteerResult");
+  PROVIDER_STEER_CAPABILITIES = {
+    pi: ["steer", "queue"],
+    "claude-managed": ["steer", "queue"],
+    devin: ["queue"],
+    opencode: ["queue"],
+    claude: ["queue"],
+    codex: ["steer", "queue"],
+    acp: [],
+    dsh: []
+  };
+  FollowUpConfigSchema = exports_zod.object({
+    disabled: exports_zod.boolean().optional(),
+    onCompleted: exports_zod.string().max(4000).optional(),
+    onFailed: exports_zod.string().max(4000).optional()
+  }).openapi("FollowUpConfig");
+  RoutingAffinitySchema = exports_zod.object({
+    sourceAgentId: exports_zod.string().optional(),
+    role: exports_zod.string().max(100).optional(),
+    harnessProvider: ProviderNameSchema.optional(),
+    capabilities: exports_zod.array(exports_zod.string()).default([]),
+    leadOnly: exports_zod.boolean().optional()
+  }).openapi("RoutingAffinity");
+  AgentTaskSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    key: AssetKeySchema,
+    agentId: exports_zod.string().nullable(),
+    creatorAgentId: exports_zod.string().optional(),
+    task: exports_zod.string().min(1),
+    title: exports_zod.string().optional(),
+    status: AgentTaskStatusSchema,
+    source: AgentTaskSourceSchema.default("mcp"),
+    routingReason: RoutingReasonSchema.optional(),
+    routingSource: RoutingSourceSchema.optional().describe("Origin of the routing reason: declared by the caller or chosen by the engine. Absent for unknown historical provenance or no reason."),
+    routingNote: exports_zod.string().max(200).optional(),
+    taskType: exports_zod.string().max(50).optional(),
+    tags: exports_zod.array(exports_zod.string()).default([]),
+    priority: exports_zod.number().int().min(0).max(100).default(50),
+    dependsOn: exports_zod.array(exports_zod.string()).default([]),
+    offeredTo: exports_zod.string().optional(),
+    offeredAt: exports_zod.iso.datetime().optional(),
+    acceptedAt: exports_zod.iso.datetime().optional(),
+    rejectionReason: exports_zod.string().optional(),
+    createdAt: exports_zod.iso.datetime(),
+    lastUpdatedAt: exports_zod.iso.datetime(),
+    finishedAt: exports_zod.iso.datetime().optional(),
+    notifiedAt: exports_zod.iso.datetime().optional(),
+    failureReason: exports_zod.string().optional(),
+    output: exports_zod.string().optional(),
+    progress: exports_zod.string().optional(),
+    slackChannelId: exports_zod.string().optional(),
+    slackThreadTs: exports_zod.string().optional(),
+    slackTriggerMessageTs: exports_zod.string().optional(),
+    slackUserId: exports_zod.string().optional(),
+    slackReplySent: exports_zod.boolean().default(false),
+    slackProgressMessageTs: exports_zod.string().optional(),
+    slackTreeRootMessageTs: exports_zod.string().optional(),
+    vcsProvider: exports_zod.enum(["github", "gitlab"]).optional(),
+    vcsRepo: exports_zod.string().optional(),
+    vcsEventType: exports_zod.string().optional(),
+    vcsNumber: exports_zod.number().int().optional(),
+    vcsCommentId: exports_zod.number().int().optional(),
+    vcsAuthor: exports_zod.string().optional(),
+    vcsUrl: exports_zod.string().optional(),
+    vcsInstallationId: exports_zod.number().int().optional(),
+    vcsNodeId: exports_zod.string().optional(),
+    agentmailInboxId: exports_zod.string().optional(),
+    agentmailMessageId: exports_zod.string().optional(),
+    agentmailThreadId: exports_zod.string().optional(),
+    mentionMessageId: exports_zod.string().optional(),
+    mentionChannelId: exports_zod.string().optional(),
+    dir: exports_zod.string().min(1).optional(),
+    parentTaskId: exports_zod.string().optional(),
+    claudeSessionId: exports_zod.string().optional(),
+    model: exports_zod.string().optional(),
+    modelTier: ModelTierSchema.optional(),
+    effort: ReasoningEffortSchema.optional(),
+    scheduleId: exports_zod.string().optional(),
+    workflowRunId: exports_zod.string().uuid().nullable().optional(),
+    workflowRunStepId: exports_zod.string().uuid().nullable().optional(),
+    contextKey: exports_zod.string().optional(),
+    outputSchema: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    followUpConfig: FollowUpConfigSchema.optional(),
+    wasPaused: exports_zod.boolean().default(false),
+    deferredAt: exports_zod.iso.datetime().optional(),
+    compactionCount: exports_zod.number().int().min(0).optional(),
+    peakContextPercent: exports_zod.number().min(0).max(100).optional(),
+    peakContextTokens: exports_zod.number().int().min(0).optional(),
+    contextWindowSize: exports_zod.number().int().min(0).optional(),
+    credentialKeySuffix: exports_zod.string().optional(),
+    credentialKeyType: exports_zod.string().optional(),
+    requestedByUserId: exports_zod.string().optional(),
+    swarmVersion: exports_zod.string().optional(),
+    provider: ProviderNameSchema.optional(),
+    providerMeta: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    harnessVariant: exports_zod.string().optional(),
+    harnessVariantMeta: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    totalCostUsd: exports_zod.number().min(0).optional(),
+    routingAffinity: RoutingAffinitySchema.optional(),
+    routingAffinityInvalid: exports_zod.boolean().optional()
+  }).openapi("AgentTask");
+  CreateTaskOptionsSchema = exports_zod.object({
+    key: exports_zod.string().min(1).optional(),
+    agentId: exports_zod.string().nullable().optional(),
+    creatorAgentId: exports_zod.string().optional(),
+    source: AgentTaskSourceSchema.optional(),
+    routingReason: RoutingReasonSchema.optional(),
+    routingSource: RoutingSourceSchema.optional(),
+    routingNote: exports_zod.string().max(200).optional(),
+    taskType: exports_zod.string().max(50).optional(),
+    tags: exports_zod.array(exports_zod.string()).optional(),
+    priority: exports_zod.number().int().min(0).max(100).optional(),
+    dependsOn: exports_zod.array(exports_zod.string()).optional(),
+    offeredTo: exports_zod.string().optional(),
+    status: exports_zod.enum(["draft", "backlog", "unassigned"]).optional(),
+    slackChannelId: exports_zod.string().optional(),
+    slackThreadTs: exports_zod.string().optional(),
+    slackTriggerMessageTs: exports_zod.string().optional(),
+    slackUserId: exports_zod.string().optional(),
+    overrideSlackContext: exports_zod.boolean().optional(),
+    vcsProvider: exports_zod.enum(["github", "gitlab"]).optional(),
+    vcsRepo: exports_zod.string().optional(),
+    vcsEventType: exports_zod.string().optional(),
+    vcsNumber: exports_zod.number().int().optional(),
+    vcsCommentId: exports_zod.number().int().optional(),
+    vcsAuthor: exports_zod.string().optional(),
+    vcsUrl: exports_zod.string().optional(),
+    vcsInstallationId: exports_zod.number().int().optional(),
+    vcsNodeId: exports_zod.string().optional(),
+    agentmailInboxId: exports_zod.string().optional(),
+    agentmailMessageId: exports_zod.string().optional(),
+    agentmailThreadId: exports_zod.string().optional(),
+    mentionMessageId: exports_zod.string().optional(),
+    mentionChannelId: exports_zod.string().optional(),
+    dir: exports_zod.string().optional(),
+    parentTaskId: exports_zod.string().optional(),
+    model: exports_zod.string().optional(),
+    modelTier: ModelTierSchema.optional(),
+    effort: ReasoningEffortSchema.optional(),
+    scheduleId: exports_zod.string().optional(),
+    workflowRunId: exports_zod.string().optional(),
+    workflowRunStepId: exports_zod.string().optional(),
+    sourceTaskId: exports_zod.string().optional(),
+    outputSchema: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    inheritParentOutputSchema: exports_zod.boolean().optional(),
+    inheritParentRoutingAffinity: exports_zod.boolean().optional(),
+    followUpConfig: FollowUpConfigSchema.optional(),
+    requestedByUserId: exports_zod.string().optional(),
+    contextKey: exports_zod.string().optional(),
+    bypassTrackerContextDedup: exports_zod.boolean().optional(),
+    routingAffinity: RoutingAffinitySchema.optional()
+  });
+  TaskAttachmentKindSchema = exports_zod.enum(["agent-fs", "url", "shared-fs", "page"]);
+  attachmentCapabilitiesSchema = exports_zod.record(exports_zod.string(), exports_zod.unknown()).refine((capabilities) => !(SERVER_GENERATED_ATTACHMENT_CAPABILITY in capabilities), {
+    message: `${SERVER_GENERATED_ATTACHMENT_CAPABILITY} is reserved for server-generated attachments`
+  });
+  attachmentCommonFields = {
+    name: exports_zod.string().min(1).describe("Display name for the attachment."),
+    providerId: exports_zod.string().min(1).optional(),
+    providerKey: exports_zod.string().min(1).optional(),
+    capabilities: attachmentCapabilitiesSchema.optional(),
+    mimeType: exports_zod.string().optional(),
+    sizeBytes: exports_zod.number().int().min(0).optional(),
+    sha256: exports_zod.string().optional(),
+    intent: exports_zod.string().optional().describe("WHY this attachment exists — the purpose it serves for this task."),
+    description: exports_zod.string().optional().describe("Optional: what the attachment is."),
+    isPrimary: exports_zod.boolean().optional()
+  };
+  AttachmentInputSchema = exports_zod.discriminatedUnion("kind", [
+    exports_zod.object({
+      kind: exports_zod.literal("agent-fs"),
+      path: exports_zod.string().min(1).describe("agent-fs path the attachment points at."),
+      orgId: exports_zod.string().min(1).optional().describe("agent-fs org id — paired with `driveId` lets the renderer build a public live-host URL."),
+      driveId: exports_zod.string().min(1).optional().describe("agent-fs drive id — paired with `orgId` lets the renderer build a public live-host URL."),
+      ...attachmentCommonFields
+    }),
+    exports_zod.object({
+      kind: exports_zod.literal("url"),
+      url: exports_zod.string().min(1).describe("External URL the attachment points at."),
+      ...attachmentCommonFields
+    }),
+    exports_zod.object({
+      kind: exports_zod.literal("shared-fs"),
+      path: exports_zod.string().min(1).describe("Shared-filesystem path the attachment points at."),
+      ...attachmentCommonFields
+    }),
+    exports_zod.object({
+      kind: exports_zod.literal("page"),
+      pageId: exports_zod.string().min(1).describe("Swarm Page id the attachment points at."),
+      ...attachmentCommonFields
+    })
+  ]);
+  TaskAttachmentSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    taskId: exports_zod.uuid(),
+    agentId: exports_zod.string().nullable(),
+    name: exports_zod.string(),
+    kind: TaskAttachmentKindSchema,
+    url: exports_zod.string().optional(),
+    path: exports_zod.string().optional(),
+    pageId: exports_zod.string().optional(),
+    providerId: exports_zod.string().optional(),
+    providerKey: exports_zod.string().optional(),
+    capabilities: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    orgId: exports_zod.string().optional(),
+    driveId: exports_zod.string().optional(),
+    mimeType: exports_zod.string().optional(),
+    sizeBytes: exports_zod.number().int().min(0).optional(),
+    sha256: exports_zod.string().optional(),
+    intent: exports_zod.string().optional(),
+    description: exports_zod.string().optional(),
+    isPrimary: exports_zod.boolean().default(false),
+    createdAt: exports_zod.iso.datetime(),
+    createdBy: exports_zod.string().optional(),
+    updatedBy: exports_zod.string().optional()
+  }).openapi("TaskAttachment");
+  UserSchema = exports_zod.object({
+    id: exports_zod.string(),
+    name: exports_zod.string().min(1),
+    email: exports_zod.string().optional(),
+    role: exports_zod.string().optional(),
+    notes: exports_zod.string().optional(),
+    emailAliases: exports_zod.array(exports_zod.string()).default([]),
+    preferredChannel: exports_zod.string().default("slack"),
+    timezone: exports_zod.string().optional(),
+    metadata: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    dailyBudgetUsd: exports_zod.number().nullable().optional(),
+    status: exports_zod.enum(["invited", "active", "suspended"]).default("active"),
+    createdAt: exports_zod.iso.datetime(),
+    lastUpdatedAt: exports_zod.iso.datetime()
+  }).openapi("User");
+  UserCommsPrefsSchema = exports_zod.object({
+    tone: exports_zod.string().optional(),
+    language: exports_zod.string().optional(),
+    verbosity: exports_zod.string().optional()
+  }).openapi("UserCommsPrefs");
+  IdentityEventTypeSchema = exports_zod.enum([
+    "auto_merge",
+    "manual_merge",
+    "identity_added",
+    "identity_removed",
+    "email_added",
+    "email_removed",
+    "token_minted",
+    "token_revoked",
+    "budget_changed",
+    "status_changed",
+    "profile_changed"
+  ]);
+  InboxItemTypeSchema = exports_zod.enum([
+    "approval",
+    "credential_missing",
+    "broken_task",
+    "to_read",
+    "to_start_template",
+    "notification"
+  ]);
+  InboxItemStatusSchema = exports_zod.enum(["open", "snoozed", "dismissed", "done"]);
+  InboxItemStateSchema = exports_zod.object({
+    id: exports_zod.string(),
+    userId: exports_zod.string(),
+    itemType: InboxItemTypeSchema,
+    itemId: exports_zod.string(),
+    status: InboxItemStatusSchema,
+    snoozeUntil: exports_zod.string().optional(),
+    dismissedAt: exports_zod.string().optional(),
+    doneAt: exports_zod.string().optional(),
+    readAt: exports_zod.string().optional(),
+    createdAt: exports_zod.string(),
+    lastUpdatedAt: exports_zod.string()
+  }).openapi("InboxItemState");
+  FavoriteItemTypeSchema = exports_zod.enum(["page", "workflow", "schedule"]);
+  UserFavoriteSchema = exports_zod.object({
+    id: exports_zod.string(),
+    userId: exports_zod.string().optional(),
+    itemType: FavoriteItemTypeSchema,
+    itemId: exports_zod.string(),
+    createdAt: exports_zod.string(),
+    lastUpdatedAt: exports_zod.string(),
+    createdBy: exports_zod.string().optional(),
+    updatedBy: exports_zod.string().optional()
+  }).openapi("UserFavorite");
+  TaskTemplateKindSchema = exports_zod.enum(["task", "workflow", "schedule"]);
+  TaskTemplateSchema = exports_zod.object({
+    id: exports_zod.string(),
+    title: exports_zod.string().min(1),
+    description: exports_zod.string(),
+    prompt: exports_zod.string(),
+    kind: TaskTemplateKindSchema.default("task"),
+    payload: exports_zod.record(exports_zod.string(), exports_zod.unknown()).default({}),
+    category: exports_zod.string().optional(),
+    tags: exports_zod.array(exports_zod.string()).default([]),
+    createdAt: exports_zod.string()
+  }).openapi("TaskTemplate");
+  AgentStatusSchema = exports_zod.enum(["idle", "busy", "offline", "waiting_for_credentials"]);
+  AgentAvatarSchema = exports_zod.discriminatedUnion("type", [
+    exports_zod.object({
+      type: exports_zod.literal("lucide"),
+      icon: exports_zod.string().regex(/^[a-z0-9-]+$/).max(64),
+      color: exports_zod.string().regex(/^#[0-9a-fA-F]{6}$/).optional()
+    })
+  ]);
+  AgentSchema = exports_zod.object({
+    id: exports_zod.string(),
+    name: exports_zod.string().min(1),
+    isLead: exports_zod.boolean().default(false),
+    status: AgentStatusSchema,
+    description: exports_zod.string().optional(),
+    role: exports_zod.string().max(100).optional(),
+    capabilities: exports_zod.array(exports_zod.string()).default([]),
+    claudeMd: exports_zod.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
+    soulMd: exports_zod.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
+    identityMd: exports_zod.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
+    setupScript: exports_zod.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
+    toolsMd: exports_zod.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
+    heartbeatMd: exports_zod.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
+    maxTasks: exports_zod.number().int().min(1).max(100).optional(),
+    emptyPollCount: exports_zod.number().int().min(0).optional(),
+    lastActivityAt: exports_zod.iso.datetime().optional(),
+    provider: ProviderNameSchema.optional(),
+    harnessProvider: ProviderNameSchema.nullable().optional(),
+    credentialMissing: exports_zod.array(exports_zod.string()).nullable().optional(),
+    credStatus: exports_zod.lazy(() => AgentCredStatusSchema).nullable().optional(),
+    avatar: exports_zod.lazy(() => AgentAvatarSchema).nullable().optional(),
+    createdAt: exports_zod.iso.datetime(),
+    lastUpdatedAt: exports_zod.iso.datetime()
+  }).openapi("Agent");
+  AgentCredStatusLiveTestSchema = exports_zod.object({
+    ok: exports_zod.boolean(),
+    error: exports_zod.string().nullable().default(null),
+    latency_ms: exports_zod.number(),
+    testedAt: exports_zod.number()
+  }).openapi("AgentCredStatusLiveTest");
+  AgentLatestModelSchema = exports_zod.object({
+    model: exports_zod.string().min(1),
+    source: exports_zod.enum(["task", "agent_config", "adapter_default", "custom"]),
+    taskId: exports_zod.string().nullable().default(null),
+    harnessProvider: ProviderNameSchema.nullable().default(null),
+    reportedAt: exports_zod.number(),
+    reasoningEffort: ReasoningEffortSchema.optional()
+  }).openapi("AgentLatestModel");
+  AgentBedrockStatusSchema = exports_zod.object({
+    region: exports_zod.string(),
+    probedAt: exports_zod.number(),
+    ready: exports_zod.boolean(),
+    models: exports_zod.array(exports_zod.object({ id: exports_zod.string(), name: exports_zod.string() })).default([]),
+    error: exports_zod.string().optional()
+  }).openapi("AgentBedrockStatus");
+  AcpSessionConfigSelectValueSchema = exports_zod.object({
+    value: exports_zod.string(),
+    name: exports_zod.string(),
+    description: exports_zod.string().nullable().optional()
+  });
+  AcpSessionConfigSelectGroupSchema = exports_zod.object({
+    group: exports_zod.string(),
+    name: exports_zod.string(),
+    options: exports_zod.array(AcpSessionConfigSelectValueSchema)
+  });
+  AcpSessionConfigOptionSchema = exports_zod.discriminatedUnion("type", [
+    exports_zod.object({
+      type: exports_zod.literal("select"),
+      id: exports_zod.string(),
+      name: exports_zod.string(),
+      description: exports_zod.string().nullable().optional(),
+      category: exports_zod.string().nullable().optional(),
+      currentValue: exports_zod.string(),
+      options: exports_zod.array(exports_zod.union([AcpSessionConfigSelectValueSchema, AcpSessionConfigSelectGroupSchema]))
+    }),
+    exports_zod.object({
+      type: exports_zod.literal("boolean"),
+      id: exports_zod.string(),
+      name: exports_zod.string(),
+      description: exports_zod.string().nullable().optional(),
+      category: exports_zod.string().nullable().optional(),
+      currentValue: exports_zod.boolean()
+    })
+  ]);
+  AgentAcpStatusSchema = exports_zod.object({
+    target: exports_zod.enum(["opencode", "custom"]),
+    configOptions: exports_zod.array(AcpSessionConfigOptionSchema),
+    reportedAt: exports_zod.number()
+  }).openapi("AgentAcpStatus");
+  AgentCredStatusSchema = exports_zod.object({
+    ready: exports_zod.boolean(),
+    missing: exports_zod.array(exports_zod.string()).default([]),
+    satisfiedBy: exports_zod.enum(["env", "file", "side-effect-pending", "sdk-delegated"]).nullable().default(null),
+    hint: exports_zod.string().nullable().default(null),
+    liveTest: AgentCredStatusLiveTestSchema.nullable().default(null),
+    latestModel: AgentLatestModelSchema.nullable().default(null),
+    reportedAt: exports_zod.number(),
+    reportKind: exports_zod.enum(["boot", "post_task"]).default("boot"),
+    bedrock: AgentBedrockStatusSchema.nullable().default(null),
+    acp: AgentAcpStatusSchema.nullable().default(null)
+  }).openapi("AgentCredStatus");
+  AgentWithTasksSchema = AgentSchema.extend({
+    tasks: exports_zod.array(AgentTaskSchema).default([])
+  });
+  ChangeSourceSchema = exports_zod.enum([
+    "self_edit",
+    "lead_coaching",
+    "api",
+    "system",
+    "session_sync"
+  ]);
+  VersionableFieldSchema = exports_zod.enum([
+    "soulMd",
+    "identityMd",
+    "toolsMd",
+    "claudeMd",
+    "setupScript",
+    "heartbeatMd"
+  ]);
+  ContextVersionSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    agentId: exports_zod.string(),
+    field: VersionableFieldSchema,
+    content: exports_zod.string(),
+    version: exports_zod.number().int().min(1),
+    changeSource: ChangeSourceSchema,
+    changedByAgentId: exports_zod.string().nullable(),
+    changeReason: exports_zod.string().nullable(),
+    contentHash: exports_zod.string(),
+    previousVersionId: exports_zod.uuid().nullable(),
+    createdAt: exports_zod.iso.datetime()
+  }).openapi("ContextVersion");
+  ChannelTypeSchema = exports_zod.enum(["public", "dm"]);
+  ChannelSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    name: exports_zod.string().min(1).max(100),
+    description: exports_zod.string().max(500).optional(),
+    type: ChannelTypeSchema.default("public"),
+    createdBy: exports_zod.string().optional(),
+    participants: exports_zod.array(exports_zod.string()).default([]),
+    createdAt: exports_zod.iso.datetime()
+  }).openapi("Channel");
+  ChannelMessageSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    channelId: exports_zod.uuid(),
+    agentId: exports_zod.string().nullable(),
+    agentName: exports_zod.string().optional(),
+    content: exports_zod.string().min(1).max(4000),
+    replyToId: exports_zod.uuid().optional(),
+    mentions: exports_zod.array(exports_zod.string()).default([]),
+    createdAt: exports_zod.iso.datetime()
+  }).openapi("ChannelMessage");
+  ServiceStatusSchema = exports_zod.enum(["starting", "healthy", "unhealthy", "stopped"]);
+  ServiceSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    agentId: exports_zod.string(),
+    name: exports_zod.string().min(1).max(50),
+    port: exports_zod.number().int().min(1).max(65535).default(3000),
+    description: exports_zod.string().optional(),
+    url: exports_zod.string().url().optional(),
+    healthCheckPath: exports_zod.string().default("/health"),
+    status: ServiceStatusSchema.default("starting"),
+    script: exports_zod.string().min(1),
+    cwd: exports_zod.string().optional(),
+    interpreter: exports_zod.string().optional(),
+    args: exports_zod.array(exports_zod.string()).optional(),
+    env: exports_zod.record(exports_zod.string(), exports_zod.string()).optional(),
+    metadata: exports_zod.record(exports_zod.string(), exports_zod.unknown()).default({}),
+    createdAt: exports_zod.iso.datetime(),
+    lastUpdatedAt: exports_zod.iso.datetime()
+  }).openapi("Service");
+  AgentLogEventTypeSchema = exports_zod.enum([
+    "agent_joined",
+    "agent_status_change",
+    "agent_left",
+    "task_created",
+    "task_status_change",
+    "task_progress",
+    "task_steering",
+    "task_offered",
+    "task_accepted",
+    "task_rejected",
+    "task_claimed",
+    "task_claim_rejected_affinity",
+    "task_dispatch_rejected_affinity",
+    "task_authorization_rejected",
+    "task_recovery_authorization",
+    "task_released",
+    "channel_message",
+    "service_registered",
+    "service_unregistered",
+    "service_status_change",
+    "budget.upserted",
+    "budget.deleted",
+    "pricing.inserted",
+    "pricing.deleted",
+    "pricing.refresh",
+    "pricing.refresh.failed",
+    "task_superseded",
+    "slack_delivery"
+  ]);
+  ResumeReasonSchema = exports_zod.enum([
+    "graceful_shutdown",
+    "context_limits",
+    "manual_supersede",
+    "crash_recovery"
+  ]);
+  AgentLogSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    eventType: AgentLogEventTypeSchema,
+    agentId: exports_zod.string().optional(),
+    taskId: exports_zod.string().optional(),
+    oldValue: exports_zod.string().optional(),
+    newValue: exports_zod.string().optional(),
+    metadata: exports_zod.string().optional(),
+    createdAt: exports_zod.iso.datetime()
+  }).openapi("AgentLog");
+  SessionLogSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    taskId: exports_zod.uuid().optional(),
+    sessionId: exports_zod.string(),
+    iteration: exports_zod.number().int().min(1),
+    cli: exports_zod.string().default("claude"),
+    content: exports_zod.string(),
+    lineNumber: exports_zod.number().int().min(0),
+    createdAt: exports_zod.iso.datetime()
+  }).openapi("SessionLog");
+  SessionCostSourceSchema = exports_zod.enum(["harness", "pricing-table", "unpriced"]);
+  SessionCostModelBreakdownSchema = exports_zod.object({
+    model: exports_zod.string(),
+    inputTokens: exports_zod.number().int().nonnegative(),
+    outputTokens: exports_zod.number().int().nonnegative(),
+    cacheReadTokens: exports_zod.number().int().nonnegative(),
+    cacheWriteTokens: exports_zod.number().int().nonnegative(),
+    webSearchRequests: exports_zod.number().int().nonnegative().nullable().optional(),
+    costUsd: exports_zod.number().nullable().optional(),
+    harnessCostUsd: exports_zod.number().nullable().optional()
+  }).openapi("SessionCostModelBreakdown");
+  SessionCostSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    sessionId: exports_zod.string(),
+    taskId: exports_zod.uuid().optional(),
+    agentId: exports_zod.string(),
+    totalCostUsd: exports_zod.number().min(0),
+    inputTokens: exports_zod.number().int().min(0).default(0),
+    outputTokens: exports_zod.number().int().min(0).default(0),
+    cacheReadTokens: exports_zod.number().int().min(0).default(0),
+    cacheWriteTokens: exports_zod.number().int().min(0).default(0),
+    reasoningOutputTokens: exports_zod.number().int().min(0).default(0),
+    thinkingTokens: exports_zod.number().int().min(0).default(0),
+    durationMs: exports_zod.number().int().min(0),
+    numTurns: exports_zod.number().int().min(1).nullable(),
+    model: exports_zod.string(),
+    isError: exports_zod.boolean().default(false),
+    costSource: SessionCostSourceSchema.default("harness"),
+    harnessCostUsd: exports_zod.number().nullable().optional(),
+    cacheWrite5mTokens: exports_zod.number().int().nullable().optional(),
+    cacheWrite1hTokens: exports_zod.number().int().nullable().optional(),
+    modelBreakdown: exports_zod.array(SessionCostModelBreakdownSchema).nullable().optional(),
+    createdAt: exports_zod.iso.datetime()
+  }).openapi("SessionCost");
+  EventCategorySchema = exports_zod.enum([
+    "tool",
+    "skill",
+    "session",
+    "api",
+    "task",
+    "workflow",
+    "system"
+  ]);
+  EventStatusSchema = exports_zod.enum(["ok", "error", "timeout", "skipped"]);
+  EventSourceSchema = exports_zod.enum(["worker", "api", "hook", "scheduler", "cli"]);
+  EventNameSchema = exports_zod.enum([
+    "tool.start",
+    "tool.end",
+    "skill.invoke",
+    "skill.complete",
+    "session.start",
+    "session.end",
+    "session.resume",
+    "session.cost",
+    "api.request",
+    "api.error",
+    "task.poll",
+    "task.assign",
+    "task.timeout",
+    "workflow.step.start",
+    "workflow.step.end",
+    "workflow.run.start",
+    "workflow.run.end",
+    "system.boot",
+    "system.migration",
+    "system.error",
+    "system.profile_sync_rejected",
+    "system.profile_sync_reconciled",
+    "system.profile_sync_conflict",
+    "script.global_upsert",
+    "schedule.deleted"
+  ]);
+  SwarmEventSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    category: EventCategorySchema,
+    event: EventNameSchema,
+    status: EventStatusSchema,
+    source: EventSourceSchema,
+    agentId: exports_zod.string().optional(),
+    taskId: exports_zod.string().optional(),
+    sessionId: exports_zod.string().optional(),
+    parentEventId: exports_zod.string().optional(),
+    numericValue: exports_zod.number().optional(),
+    durationMs: exports_zod.number().int().optional(),
+    data: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    createdAt: exports_zod.iso.datetime()
+  }).openapi("SwarmEvent");
+  AutomationIntegrationIdSchema = exports_zod.enum([
+    "slack",
+    "github",
+    "linear",
+    "jira",
+    "gsc",
+    "agentmail",
+    "agentfs"
+  ]);
+  ScheduledTaskTargetTypeSchema = exports_zod.enum(["agent-task", "workflow", "script"]);
+  ScheduledTaskSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    key: AssetKeySchema,
+    name: exports_zod.string().min(1).max(100),
+    description: exports_zod.string().optional(),
+    cronExpression: exports_zod.string().optional(),
+    intervalMs: exports_zod.number().int().positive().optional(),
+    taskTemplate: exports_zod.string().optional(),
+    taskType: exports_zod.string().max(50).optional(),
+    tags: exports_zod.array(exports_zod.string()).default([]),
+    priority: exports_zod.number().int().min(0).max(100).default(50),
+    targetAgentId: exports_zod.string().optional(),
+    enabled: exports_zod.boolean().default(true),
+    lastRunAt: exports_zod.iso.datetime().optional(),
+    nextRunAt: exports_zod.iso.datetime().optional(),
+    createdByAgentId: exports_zod.string().optional(),
+    parentTaskId: exports_zod.string().optional(),
+    requestedDelayMs: exports_zod.number().int().positive().optional(),
+    requestedRunAt: exports_zod.iso.datetime().optional(),
+    timezone: exports_zod.string().default("UTC"),
+    consecutiveErrors: exports_zod.number().int().min(0).default(0),
+    lastErrorAt: exports_zod.iso.datetime().optional(),
+    lastErrorMessage: exports_zod.string().optional(),
+    model: exports_zod.string().optional(),
+    modelTier: ModelTierSchema.optional(),
+    scheduleType: exports_zod.enum(["recurring", "one_time"]).default("recurring"),
+    targetType: ScheduledTaskTargetTypeSchema.default("agent-task"),
+    workflowId: exports_zod.uuid().optional(),
+    scriptName: exports_zod.string().optional(),
+    scriptArgs: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    params: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    requiredParams: exports_zod.array(exports_zod.string()).optional(),
+    requires: exports_zod.array(AutomationIntegrationIdSchema).optional(),
+    createdAt: exports_zod.iso.datetime(),
+    lastUpdatedAt: exports_zod.iso.datetime(),
+    createdBy: exports_zod.string().optional(),
+    updatedBy: exports_zod.string().optional(),
+    favorite: exports_zod.boolean().optional()
+  }).refine((data) => {
+    if (data.scheduleType === "one_time")
+      return true;
+    return data.cronExpression || data.intervalMs;
+  }, {
+    message: "Either cronExpression or intervalMs must be provided for recurring schedules"
+  }).refine((data) => {
+    switch (data.targetType) {
+      case "agent-task":
+        return !!data.taskTemplate;
+      case "workflow":
+        return !!data.workflowId;
+      case "script":
+        return !!data.scriptName;
+      default:
+        return true;
+    }
+  }, {
+    message: "Target-type specific field is required (taskTemplate, workflowId, or scriptName)"
+  });
+  SwarmConfigScopeSchema = exports_zod.enum(["global", "agent", "repo"]);
+  SwarmConfigSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    scope: SwarmConfigScopeSchema,
+    scopeId: exports_zod.string().nullable(),
+    key: exports_zod.string().min(1).max(255),
+    value: exports_zod.string(),
+    isSecret: exports_zod.boolean(),
+    envPath: exports_zod.string().nullable(),
+    description: exports_zod.string().nullable(),
+    createdAt: exports_zod.string(),
+    lastUpdatedAt: exports_zod.string(),
+    encrypted: exports_zod.boolean()
+  }).openapi("SwarmConfig");
+  RepoGuidelinesSchema = exports_zod.object({
+    prChecks: exports_zod.array(exports_zod.string()),
+    mergeChecks: exports_zod.array(exports_zod.string()),
+    allowMerge: exports_zod.boolean().optional().default(false),
+    review: exports_zod.array(exports_zod.string())
+  }).openapi("RepoGuidelines");
+  RepoGuidelinesInputSchema = exports_zod.object({
+    prChecks: exports_zod.array(exports_zod.string()).max(REPO_GUIDELINES_MAX_ENTRIES),
+    mergeChecks: exports_zod.array(exports_zod.string()).max(REPO_GUIDELINES_MAX_ENTRIES),
+    allowMerge: exports_zod.boolean().optional().default(false),
+    review: exports_zod.array(exports_zod.string()).max(REPO_GUIDELINES_MAX_ENTRIES)
+  }).openapi("RepoGuidelinesInput");
+  RepoHooksSchema = exports_zod.object({
+    enabled: exports_zod.boolean().default(false)
+  }).openapi("RepoHooks");
+  SwarmRepoSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    url: exports_zod.string().min(1),
+    name: exports_zod.string().min(1).max(100),
+    clonePath: exports_zod.string().min(1),
+    defaultBranch: exports_zod.string().default("main"),
+    autoClone: exports_zod.boolean().default(true),
+    hooks: RepoHooksSchema.optional().default({ enabled: false }),
+    guidelines: RepoGuidelinesSchema.nullable().optional(),
+    createdAt: exports_zod.string(),
+    lastUpdatedAt: exports_zod.string()
+  }).openapi("SwarmRepo");
+  AgentMemoryScopeSchema = exports_zod.enum(["agent", "swarm"]);
+  AgentMemorySourceSchema = exports_zod.enum([
+    "manual",
+    "file_index",
+    "session_summary",
+    "task_completion"
+  ]);
+  AgentMemorySchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    agentId: exports_zod.string().nullable(),
+    scope: AgentMemoryScopeSchema,
+    key: exports_zod.string().nullable().optional(),
+    name: exports_zod.string().min(1).max(500),
+    content: exports_zod.string(),
+    summary: exports_zod.string().nullable(),
+    source: AgentMemorySourceSchema,
+    sourceTaskId: exports_zod.string().uuid().nullable(),
+    sourcePath: exports_zod.string().nullable(),
+    chunkIndex: exports_zod.number().int().min(0).default(0),
+    totalChunks: exports_zod.number().int().min(1).default(1),
+    tags: exports_zod.array(exports_zod.string()),
+    createdAt: exports_zod.string(),
+    updatedAt: exports_zod.string().nullable().optional(),
+    accessedAt: exports_zod.string(),
+    expiresAt: exports_zod.string().nullable().optional(),
+    accessCount: exports_zod.number().int().min(0).default(0).optional(),
+    embeddingModel: exports_zod.string().nullable().optional(),
+    contentHash: exports_zod.string().nullable().optional(),
+    version: exports_zod.number().int().min(1).default(1).optional()
+  }).openapi("AgentMemory");
+  ActiveSessionSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    agentId: exports_zod.string(),
+    taskId: exports_zod.string().nullable(),
+    triggerType: exports_zod.string(),
+    inboxMessageId: exports_zod.string().nullable(),
+    taskDescription: exports_zod.string().nullable(),
+    runnerSessionId: exports_zod.string().nullable(),
+    providerSessionId: exports_zod.string().nullable(),
+    runtimeInstanceId: exports_zod.string().nullable().optional(),
+    startedAt: exports_zod.iso.datetime(),
+    lastHeartbeatAt: exports_zod.iso.datetime()
+  }).openapi("ActiveSession");
+  RuntimeInstanceStatusSchema = exports_zod.enum(["active", "offline"]);
+  RuntimeInstanceSchema = exports_zod.object({
+    id: exports_zod.string(),
+    agentId: exports_zod.string(),
+    status: RuntimeInstanceStatusSchema,
+    reportedSlots: exports_zod.number().int(),
+    credentialReady: exports_zod.boolean().nullable().optional(),
+    metadata: exports_zod.record(exports_zod.string(), exports_zod.unknown()).nullable(),
+    lastSeenAt: exports_zod.iso.datetime(),
+    createdAt: exports_zod.iso.datetime(),
+    updatedAt: exports_zod.iso.datetime()
+  }).openapi("RuntimeInstance");
+  RetryPolicySchema = exports_zod.object({
+    maxRetries: exports_zod.number().int().min(0).default(3),
+    strategy: exports_zod.enum(["exponential", "static", "linear"]).default("exponential"),
+    baseDelayMs: exports_zod.number().int().min(0).default(1000),
+    maxDelayMs: exports_zod.number().int().min(0).default(60000)
+  }).openapi("RetryPolicy");
+  ExecutorMetaSchema = exports_zod.object({
+    runId: exports_zod.string().uuid(),
+    stepId: exports_zod.string().uuid(),
+    nodeId: exports_zod.string(),
+    workflowId: exports_zod.string().uuid(),
+    dryRun: exports_zod.boolean().default(false),
+    requestedByUserId: exports_zod.string().optional(),
+    inputCtx: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional()
+  }).openapi("ExecutorMeta");
+  ValidationResultSchema = exports_zod.object({
+    pass: exports_zod.boolean(),
+    reasoning: exports_zod.string(),
+    confidence: exports_zod.number().min(0).max(1)
+  }).openapi("ValidationResult");
+  StepValidationConfigSchema = exports_zod.object({
+    executor: exports_zod.string().default("validate"),
+    config: exports_zod.record(exports_zod.string(), exports_zod.unknown()),
+    mustPass: exports_zod.boolean().default(false),
+    retry: RetryPolicySchema.optional()
+  }).openapi("StepValidationConfig");
+  SwarmScriptNodeConfigSchema = exports_zod.object({
+    scriptName: exports_zod.string().min(1),
+    scope: exports_zod.enum(["global", "agent"]).optional(),
+    pinHash: exports_zod.string().min(1).optional(),
+    args: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    fsMode: exports_zod.enum(["none", "workspace-rw"]).optional(),
+    timeoutMs: exports_zod.number().int().min(1000).max(300000).optional()
+  }).openapi("SwarmScriptNodeConfig");
+  WorkflowNodeSchema = exports_zod.object({
+    id: exports_zod.string().describe("Unique node identifier, used in 'next' and 'inputs' mappings"),
+    type: exports_zod.string().describe("Executor type: 'agent-task', 'script', 'swarm-script', 'raw-llm', 'validate', 'property-match'"),
+    label: exports_zod.string().optional().describe("Human-readable label for UI display"),
+    config: exports_zod.record(exports_zod.string(), exports_zod.unknown()).describe("Executor-specific config. For agent-task: { template, outputSchema?, agentId?, routingReason?, routingNote?, tags?, priority?, dir?, vcsRepo?, model? }; configured agentId defaults routingReason to human_pinned. " + "For script: { runtime, script, args?, timeout? }. " + "For swarm-script: { scriptName, scope?, pinHash?, args?, fsMode?, timeoutMs? (1000-300000) }. " + "Agent-task templates and ordinary config values support {{interpolation}} from the node's inputs context, including trigger and declared upstream aliases. " + "SECURITY: executable source for script/swarm-script nodes does not interpolate trigger.* or upstream node outputs; only input/workflow/swarm/run values are allowed in inline script source, and named swarm-script source is not workflow-interpolated. " + "Pass dynamic values through config.args instead (inline script receives them as argv; swarm-script receives its args object). " + "NOTE: config.outputSchema on agent-task nodes validates the AGENT's raw JSON output, " + "while node-level outputSchema validates the EXECUTOR's return value ({taskId, taskOutput})."),
+    next: exports_zod.union([exports_zod.string(), exports_zod.array(exports_zod.string()), exports_zod.record(exports_zod.string(), exports_zod.string())]).optional().describe("Next node(s): string for simple chaining, string[] for fan-out to parallel nodes, or record for port-based routing ({pass: 'a', fail: 'b'})"),
+    validation: StepValidationConfigSchema.optional(),
+    retry: RetryPolicySchema.optional(),
+    inputs: exports_zod.record(exports_zod.string(), exports_zod.string()).optional().describe("REQUIRED for cross-node data access. Maps local names to context paths. " + "Without this, upstream step outputs are NOT available for interpolation; built-in trigger/input/workflow/swarm/run context remains available. " + 'Example: { "cityData": "generate-city" } → use {{cityData.taskOutput.field}} in config templates. ' + 'For trigger data: { "pr": "trigger.pullRequest" }. ' + "This mapping works in agent-task templates and ordinary config, but executable script/swarm-script source excludes trigger and upstream-output aliases. " + "Route those dynamic values through config.args (argv for inline scripts) instead."),
+    inputSchema: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional().describe("JSON Schema to validate resolved inputs before execution"),
+    outputSchema: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional().describe("JSON Schema to validate the executor's output (e.g. {taskId, taskOutput} for agent-task). " + "Different from config.outputSchema which validates the agent's raw output.")
+  }).openapi("WorkflowNode");
+  WorkflowEdgeSchema = exports_zod.object({
+    id: exports_zod.string(),
+    source: exports_zod.string(),
+    sourcePort: exports_zod.string(),
+    target: exports_zod.string()
+  }).openapi("WorkflowEdge");
+  WorkflowDefinitionSchema = exports_zod.object({
+    nodes: exports_zod.array(WorkflowNodeSchema).min(1),
+    onNodeFailure: exports_zod.enum(["fail", "continue"]).default("fail").describe("Behavior when a node's task fails or is cancelled. " + "'fail' (default): mark the entire run as failed. " + "'continue': treat the failed node as completed with error output and proceed — " + "downstream convergence nodes receive '[FAILED: reason]' and can handle partial results.")
+  }).openapi("WorkflowDefinition");
+  WorkflowNodePatchSchema = WorkflowNodeSchema.partial().omit({ id: true });
+  WorkflowPatchSchema = exports_zod.object({
+    update: exports_zod.array(exports_zod.object({
+      nodeId: exports_zod.string().describe("ID of the node to update"),
+      node: WorkflowNodePatchSchema.describe("Partial node data to merge")
+    })).optional().describe("Nodes to update (partial merge)"),
+    delete: exports_zod.array(exports_zod.string()).optional().describe("Node IDs to delete"),
+    create: exports_zod.array(WorkflowNodeSchema).optional().describe("New nodes to add"),
+    onNodeFailure: exports_zod.enum(["fail", "continue"]).optional().describe("Update the definition-level onNodeFailure behavior"),
+    triggerSchema: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional().nullable().describe("Optional JSON-Schema describing the expected trigger payload shape. " + "Pass an object to set/replace; pass null to clear; omit to leave unchanged. " + "Validator subset: type, required, properties, enum, const, items. " + "Other JSON-Schema keywords are silently ignored."),
+    params: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    requiredParams: exports_zod.array(exports_zod.string()).optional(),
+    requires: exports_zod.array(AutomationIntegrationIdSchema).optional()
+  }).openapi("WorkflowPatch");
+  WebhookVerificationSchema = exports_zod.discriminatedUnion("format", [
+    exports_zod.object({
+      format: exports_zod.literal("hmac-sha256"),
+      header: exports_zod.string().default("X-Hub-Signature-256").describe("Header containing HMAC-SHA256 over the raw request body. Accepts sha256=<hex> or bare hex.")
+    }),
+    exports_zod.object({
+      format: exports_zod.literal("timestamped-hmac-sha256"),
+      header: exports_zod.string().min(1).describe("Header containing comma-separated timestamp/signature pairs such as t=<timestamp>,v1=<hex>."),
+      timestampKey: exports_zod.string().default("t").describe("Timestamp field key in the signature header"),
+      signatureKey: exports_zod.string().default("v1").describe("Signature field key in the signature header; multiple entries are allowed"),
+      toleranceSeconds: exports_zod.number().int().positive().default(300).describe("Maximum allowed clock skew, in seconds, for replay protection")
+    }),
+    exports_zod.object({
+      format: exports_zod.literal("token-equality"),
+      header: exports_zod.string().min(1).describe("Header containing the shared token to compare")
+    })
+  ]);
+  TriggerConfigSchema = exports_zod.discriminatedUnion("type", [
+    exports_zod.object({
+      type: exports_zod.literal("webhook"),
+      hmacSecret: exports_zod.string().optional(),
+      hmacHeader: exports_zod.string().default("X-Hub-Signature-256").describe("Legacy HMAC header for webhook verification. Prefer verification.header for new workflows."),
+      verification: WebhookVerificationSchema.optional().describe("Optional webhook verification format. Omit to keep legacy HMAC-SHA256 behavior with fallback header scanning.")
+    }),
+    exports_zod.object({
+      type: exports_zod.literal("schedule"),
+      scheduleId: exports_zod.string().uuid()
+    }),
+    exports_zod.object({
+      type: exports_zod.literal("event"),
+      eventName: exports_zod.literal("slack.message")
+    })
+  ]).superRefine((trigger, ctx) => {
+    if (trigger.type === "webhook" && trigger.verification && !trigger.hmacSecret) {
+      ctx.addIssue({
+        code: exports_zod.ZodIssueCode.custom,
+        message: "hmacSecret is required when verification is configured",
+        path: ["hmacSecret"]
+      });
+    }
+  });
+  CooldownConfigSchema = exports_zod.object({
+    hours: exports_zod.number().min(0).optional(),
+    minutes: exports_zod.number().min(0).optional(),
+    seconds: exports_zod.number().min(0).optional()
+  }).refine((v) => v.hours !== undefined || v.minutes !== undefined || v.seconds !== undefined, {
+    message: "At least one of hours, minutes, or seconds is required"
+  });
+  InputValueSchema = exports_zod.union([
+    exports_zod.string().regex(/^\$\{.+\}$/),
+    exports_zod.string().regex(/^secret\..+$/),
+    exports_zod.string()
+  ]);
+  WorkflowTemplateSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    name: exports_zod.string(),
+    description: exports_zod.string(),
+    category: exports_zod.string(),
+    variables: exports_zod.array(exports_zod.object({
+      name: exports_zod.string(),
+      description: exports_zod.string(),
+      type: exports_zod.enum(["string", "number", "boolean"]),
+      default: exports_zod.unknown().optional(),
+      required: exports_zod.boolean().default(true)
+    })),
+    definition: WorkflowDefinitionSchema
+  }).openapi("WorkflowTemplate");
+  WorkflowSnapshotSchema = exports_zod.object({
+    name: exports_zod.string(),
+    description: exports_zod.string().optional(),
+    definition: WorkflowDefinitionSchema,
+    triggers: exports_zod.array(TriggerConfigSchema),
+    cooldown: CooldownConfigSchema.optional(),
+    input: exports_zod.record(exports_zod.string(), InputValueSchema).optional(),
+    triggerSchema: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    params: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    requiredParams: exports_zod.array(exports_zod.string()).optional(),
+    requires: exports_zod.array(AutomationIntegrationIdSchema).optional(),
+    dir: exports_zod.string().min(1).startsWith("/").optional(),
+    vcsRepo: exports_zod.string().min(1).optional(),
+    enabled: exports_zod.boolean()
+  }).openapi("WorkflowSnapshot");
+  WorkflowSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    key: AssetKeySchema,
+    name: exports_zod.string(),
+    description: exports_zod.string().optional(),
+    enabled: exports_zod.boolean(),
+    definition: WorkflowDefinitionSchema,
+    triggers: exports_zod.array(TriggerConfigSchema).default([]),
+    cooldown: CooldownConfigSchema.optional(),
+    input: exports_zod.record(exports_zod.string(), InputValueSchema).optional(),
+    triggerSchema: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    params: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    requiredParams: exports_zod.array(exports_zod.string()).optional(),
+    requires: exports_zod.array(AutomationIntegrationIdSchema).optional(),
+    dir: exports_zod.string().min(1).startsWith("/").optional(),
+    vcsRepo: exports_zod.string().min(1).optional(),
+    createdByAgentId: exports_zod.string().optional(),
+    createdAt: exports_zod.string(),
+    lastUpdatedAt: exports_zod.string(),
+    createdBy: exports_zod.string().optional(),
+    updatedBy: exports_zod.string().optional(),
+    favorite: exports_zod.boolean().optional()
+  }).openapi("Workflow");
+  WorkflowVersionSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    workflowId: exports_zod.string().uuid(),
+    version: exports_zod.number().int().min(1),
+    snapshot: WorkflowSnapshotSchema,
+    changedByAgentId: exports_zod.string().optional(),
+    createdAt: exports_zod.string()
+  }).openapi("WorkflowVersion");
+  PageContentTypeSchema = exports_zod.enum(["text/html", "application/json", "image/svg+xml"]);
+  PageAuthModeSchema = exports_zod.enum(["public", "authed", "password"]);
+  PageSnapshotSchema = exports_zod.object({
+    title: exports_zod.string(),
+    description: exports_zod.string().optional(),
+    contentType: PageContentTypeSchema,
+    authMode: PageAuthModeSchema,
+    passwordHash: exports_zod.string().optional(),
+    body: exports_zod.string(),
+    needsCredentials: exports_zod.array(exports_zod.string()).optional()
+  }).openapi("PageSnapshot");
+  PageSchema = exports_zod.object({
+    id: exports_zod.string(),
+    key: AssetKeySchema,
+    agentId: exports_zod.string(),
+    slug: exports_zod.string(),
+    title: exports_zod.string(),
+    description: exports_zod.string().optional(),
+    contentType: PageContentTypeSchema,
+    authMode: PageAuthModeSchema,
+    passwordHash: exports_zod.string().optional(),
+    body: exports_zod.string(),
+    needsCredentials: exports_zod.array(exports_zod.string()).optional(),
+    viewCount: exports_zod.number().int().min(0).default(0),
+    createdAt: exports_zod.string(),
+    updatedAt: exports_zod.string(),
+    favorite: exports_zod.boolean().optional()
+  }).openapi("Page");
+  PageVersionSchema = exports_zod.object({
+    id: exports_zod.string(),
+    pageId: exports_zod.string(),
+    version: exports_zod.number().int().min(1),
+    snapshot: PageSnapshotSchema,
+    changedByAgentId: exports_zod.string().optional(),
+    createdAt: exports_zod.string()
+  }).openapi("PageVersion");
+  MetricParamSchema = exports_zod.union([exports_zod.string(), exports_zod.number(), exports_zod.boolean(), exports_zod.null()]);
+  MetricVariableTypeSchema = exports_zod.enum(["text", "number", "select"]);
+  MetricFormatSchema = exports_zod.enum(["number", "integer", "currency", "percent", "duration"]);
+  MetricVisualizationSchema = exports_zod.enum([
+    "stat",
+    "table",
+    "bar",
+    "line",
+    "multi-bar",
+    "multi-line"
+  ]);
+  MetricQuerySchema = exports_zod.object({
+    sql: exports_zod.string().min(1).max(1e4),
+    params: exports_zod.array(MetricParamSchema).optional(),
+    maxRows: exports_zod.number().int().min(1).max(500).optional()
+  });
+  MetricVariableSchema = exports_zod.object({
+    key: exports_zod.string().min(1).regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+    label: exports_zod.string().min(1).optional(),
+    type: MetricVariableTypeSchema.default("text"),
+    defaultValue: MetricParamSchema.optional(),
+    options: exports_zod.array(exports_zod.object({
+      label: exports_zod.string().min(1),
+      value: MetricParamSchema
+    })).optional(),
+    optionsQuery: exports_zod.object({
+      sql: exports_zod.string().min(1).max(1e4),
+      valueKey: exports_zod.string().min(1),
+      labelKey: exports_zod.string().min(1).optional()
+    }).optional()
+  }).openapi("MetricVariable");
+  MetricVizConfigSchema = exports_zod.object({
+    type: MetricVisualizationSchema,
+    x: exports_zod.string().optional(),
+    y: exports_zod.string().optional(),
+    series: exports_zod.array(exports_zod.string()).optional(),
+    label: exports_zod.string().optional(),
+    value: exports_zod.string().optional(),
+    columns: exports_zod.array(exports_zod.object({
+      key: exports_zod.string(),
+      label: exports_zod.string().optional(),
+      format: MetricFormatSchema.optional()
+    })).optional(),
+    format: MetricFormatSchema.optional()
+  }).openapi("MetricVizConfig");
+  MetricWidgetSchema = exports_zod.object({
+    id: exports_zod.string().min(1),
+    title: exports_zod.string().min(1),
+    description: exports_zod.string().optional(),
+    query: MetricQuerySchema,
+    viz: MetricVizConfigSchema,
+    colSpan: exports_zod.number().int().min(1).max(4).optional(),
+    rowSpan: exports_zod.number().int().min(1).max(4).optional()
+  }).openapi("MetricWidget");
+  MetricDefinitionSchema = exports_zod.object({
+    version: exports_zod.literal(1),
+    widgets: exports_zod.array(MetricWidgetSchema).min(1).max(24),
+    variables: exports_zod.array(MetricVariableSchema).max(12).optional(),
+    layout: exports_zod.object({
+      columns: exports_zod.number().int().min(1).max(4).optional()
+    }).optional(),
+    refreshSeconds: exports_zod.number().int().min(5).max(3600).optional()
+  }).openapi("MetricDefinition");
+  MetricSnapshotSchema = exports_zod.object({
+    title: exports_zod.string(),
+    description: exports_zod.string().optional(),
+    definition: MetricDefinitionSchema
+  }).openapi("MetricSnapshot");
+  MetricSchema = exports_zod.object({
+    id: exports_zod.string(),
+    agentId: exports_zod.string(),
+    slug: exports_zod.string(),
+    title: exports_zod.string(),
+    description: exports_zod.string().optional(),
+    definition: MetricDefinitionSchema,
+    createdAt: exports_zod.string(),
+    updatedAt: exports_zod.string()
+  }).openapi("Metric");
+  MetricVersionSchema = exports_zod.object({
+    id: exports_zod.string(),
+    metricId: exports_zod.string(),
+    version: exports_zod.number().int().min(1),
+    snapshot: MetricSnapshotSchema,
+    changedByAgentId: exports_zod.string().optional(),
+    createdAt: exports_zod.string()
+  }).openapi("MetricVersion");
+  WorkflowRunStatusSchema = exports_zod.enum([
+    "running",
+    "waiting",
+    "completed",
+    "failed",
+    "skipped",
+    "cancelled"
+  ]);
+  WorkflowRunSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    workflowId: exports_zod.string().uuid(),
+    status: WorkflowRunStatusSchema,
+    triggerData: exports_zod.unknown().optional(),
+    context: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    error: exports_zod.string().optional(),
+    createdBy: exports_zod.string().optional(),
+    startedAt: exports_zod.string(),
+    lastUpdatedAt: exports_zod.string(),
+    finishedAt: exports_zod.string().optional()
+  }).openapi("WorkflowRun");
+  ScriptRunStatusSchema = exports_zod.enum([
+    "running",
+    "paused",
+    "completed",
+    "failed",
+    "cancelled",
+    "aborted_limit"
+  ]);
+  TERMINAL_SCRIPT_RUN_STATUSES = [
+    "completed",
+    "failed",
+    "cancelled",
+    "aborted_limit"
+  ];
+  ScriptRunKindSchema = exports_zod.enum(["workflow", "inline"]);
+  ScriptRunSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    agentId: exports_zod.string(),
+    scriptName: exports_zod.string().optional(),
+    source: exports_zod.string(),
+    args: exports_zod.unknown(),
+    kind: ScriptRunKindSchema,
+    status: ScriptRunStatusSchema,
+    pid: exports_zod.number().int().optional(),
+    startedAt: exports_zod.string(),
+    finishedAt: exports_zod.string().optional(),
+    output: exports_zod.unknown().optional(),
+    error: exports_zod.string().optional(),
+    lastHeartbeatAt: exports_zod.string().optional(),
+    idempotencyKey: exports_zod.string().optional(),
+    requestedByUserId: exports_zod.string().optional()
+  }).openapi("ScriptRun");
+  ScriptRunListItemSchema = ScriptRunSchema.omit({
+    source: true,
+    args: true,
+    output: true
+  });
+  ScriptRunJournalEntrySchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    runId: exports_zod.string().uuid(),
+    stepKey: exports_zod.string(),
+    stepType: exports_zod.string(),
+    config: exports_zod.record(exports_zod.string(), exports_zod.unknown()),
+    status: exports_zod.enum(["completed", "failed"]),
+    result: exports_zod.unknown().optional(),
+    error: exports_zod.string().optional(),
+    startedAt: exports_zod.string(),
+    completedAt: exports_zod.string().optional(),
+    durationMs: exports_zod.number().optional()
+  }).openapi("ScriptRunJournalEntry");
+  WorkflowRunStepStatusSchema = exports_zod.enum([
+    "pending",
+    "running",
+    "waiting",
+    "completed",
+    "failed",
+    "skipped",
+    "cancelled"
+  ]);
+  WorkflowRunStepSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    runId: exports_zod.string().uuid(),
+    nodeId: exports_zod.string(),
+    nodeType: exports_zod.string(),
+    status: WorkflowRunStepStatusSchema,
+    input: exports_zod.unknown().optional(),
+    output: exports_zod.unknown().optional(),
+    error: exports_zod.string().optional(),
+    startedAt: exports_zod.string(),
+    finishedAt: exports_zod.string().optional(),
+    retryCount: exports_zod.number().int().min(0).default(0),
+    maxRetries: exports_zod.number().int().min(0).default(3),
+    nextRetryAt: exports_zod.string().optional(),
+    idempotencyKey: exports_zod.string().optional(),
+    diagnostics: exports_zod.string().optional(),
+    nextPort: exports_zod.string().optional()
+  }).openapi("WorkflowRunStep");
+  WaitModeSchema = exports_zod.enum(["time", "event"]);
+  WaitStateStatusSchema = exports_zod.enum(["pending", "fired", "timeout"]);
+  WaitStateRowSchema = exports_zod.object({
+    id: exports_zod.string(),
+    workflowRunId: exports_zod.string(),
+    workflowRunStepId: exports_zod.string(),
+    mode: WaitModeSchema,
+    wakeUpAt: exports_zod.string().nullable(),
+    eventName: exports_zod.string().nullable(),
+    eventFilter: exports_zod.union([exports_zod.record(exports_zod.string(), exports_zod.unknown()), exports_zod.string()]).nullable(),
+    expiresAt: exports_zod.string().nullable(),
+    status: WaitStateStatusSchema,
+    firedPayload: exports_zod.unknown().nullable(),
+    resolvedAt: exports_zod.string().nullable(),
+    createdAt: exports_zod.string(),
+    updatedAt: exports_zod.string(),
+    eventScope: exports_zod.enum(["run", "global"])
+  }).openapi("WaitStateRow");
+  PromptTemplateScopeSchema = exports_zod.enum(["global", "agent", "repo"]);
+  PromptTemplateStateSchema = exports_zod.enum([
+    "enabled",
+    "default_prompt_fallback",
+    "skip_event"
+  ]);
+  PromptTemplateSchema = exports_zod.object({
+    id: exports_zod.string(),
+    eventType: exports_zod.string(),
+    scope: PromptTemplateScopeSchema,
+    scopeId: exports_zod.string().nullable(),
+    state: PromptTemplateStateSchema,
+    body: exports_zod.string(),
+    isDefault: exports_zod.boolean(),
+    version: exports_zod.number(),
+    createdBy: exports_zod.string().nullable(),
+    createdAt: exports_zod.string(),
+    updatedAt: exports_zod.string()
+  }).openapi("PromptTemplate");
+  PromptTemplateHistorySchema = exports_zod.object({
+    id: exports_zod.string(),
+    templateId: exports_zod.string(),
+    version: exports_zod.number(),
+    body: exports_zod.string(),
+    state: exports_zod.string(),
+    changedBy: exports_zod.string().nullable(),
+    changedAt: exports_zod.string(),
+    changeReason: exports_zod.string().nullable()
+  }).openapi("PromptTemplateHistory");
+  ScriptScopeSchema = exports_zod.enum(["global", "agent"]);
+  ScriptFsModeSchema = exports_zod.enum(["none", "workspace-rw"]);
+  ScriptRecordSchema = exports_zod.object({
+    id: exports_zod.string(),
+    name: exports_zod.string(),
+    scope: ScriptScopeSchema,
+    scopeId: exports_zod.string().nullable(),
+    source: exports_zod.string(),
+    description: exports_zod.string(),
+    intent: exports_zod.string(),
+    signatureJson: exports_zod.string(),
+    argsJsonSchema: exports_zod.string().nullable(),
+    contentHash: exports_zod.string(),
+    version: exports_zod.number(),
+    isScratch: exports_zod.boolean(),
+    typeChecked: exports_zod.boolean(),
+    fsMode: ScriptFsModeSchema,
+    createdByAgentId: exports_zod.string().nullable(),
+    createdAt: exports_zod.string(),
+    updatedAt: exports_zod.string()
+  }).openapi("ScriptRecord");
+  ScriptVersionRecordSchema = exports_zod.object({
+    id: exports_zod.string(),
+    scriptId: exports_zod.string(),
+    version: exports_zod.number(),
+    source: exports_zod.string(),
+    description: exports_zod.string(),
+    intent: exports_zod.string(),
+    signatureJson: exports_zod.string(),
+    contentHash: exports_zod.string(),
+    changedByAgentId: exports_zod.string().nullable(),
+    changedAt: exports_zod.string(),
+    changeReason: exports_zod.string().nullable()
+  }).openapi("ScriptVersionRecord");
+  ExtensionNameSchema = exports_zod.string().min(1).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "must be a lowercase slug");
+  SemverSchema = exports_zod.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/, "must be a semantic version");
+  ExtensionManifestSchema = exports_zod.object({
+    name: ExtensionNameSchema,
+    description: exports_zod.string(),
+    version: SemverSchema,
+    runtime: exports_zod.enum(["api", "worker"]),
+    assets: exports_zod.object({
+      hooks: exports_zod.string().min(1).refine(isSafeBundlePath, "Must be a relative POSIX file path without empty, dot, or parent segments, at most 256 characters"),
+      skills: exports_zod.array(exports_zod.string()).optional(),
+      workflows: exports_zod.array(exports_zod.string()).optional(),
+      schedules: exports_zod.array(exports_zod.string()).optional()
+    }).strict(),
+    homepage: exports_zod.string().url().optional(),
+    author: exports_zod.string().min(1).optional()
+  }).strict().openapi("ExtensionManifest");
+  ExtensionStatusSchema = exports_zod.enum(["disabled", "enabled", "error", "auto-disabled"]);
+  ExtensionSchema = exports_zod.object({
+    id: exports_zod.string(),
+    name: ExtensionNameSchema,
+    description: exports_zod.string(),
+    runtime: exports_zod.enum(["api", "worker"]),
+    manifestJson: exports_zod.string(),
+    contentHash: exports_zod.string(),
+    version: exports_zod.number().int().min(1),
+    activeVersion: exports_zod.number().int().min(1),
+    enabled: exports_zod.boolean(),
+    priority: exports_zod.number().int(),
+    configJson: exports_zod.string(),
+    status: ExtensionStatusSchema,
+    consecutiveFailures: exports_zod.number().int().min(0),
+    lastError: exports_zod.string().nullable(),
+    agentId: exports_zod.string().nullable(),
+    createdByAgentId: exports_zod.string().nullable(),
+    createdAt: exports_zod.string(),
+    updatedAt: exports_zod.string()
+  }).openapi("Extension");
+  ExtensionFileSchema = exports_zod.object({
+    id: exports_zod.string(),
+    extensionId: exports_zod.string(),
+    path: exports_zod.string(),
+    content: exports_zod.string(),
+    contentHash: exports_zod.string()
+  }).openapi("ExtensionFile");
+  ExtensionVersionSchema = exports_zod.object({
+    id: exports_zod.string(),
+    extensionId: exports_zod.string(),
+    version: exports_zod.number().int().min(1),
+    manifestJson: exports_zod.string(),
+    filesJson: exports_zod.string(),
+    contentHash: exports_zod.string(),
+    changedByAgentId: exports_zod.string().nullable(),
+    changedAt: exports_zod.string(),
+    changeReason: exports_zod.string().nullable()
+  }).openapi("ExtensionVersion");
+  ExtensionRunSchema = exports_zod.object({
+    id: exports_zod.string(),
+    extensionId: exports_zod.string(),
+    version: exports_zod.number().int().min(1),
+    event: exports_zod.string(),
+    action: exports_zod.enum(["continue", "modify", "block", "error", "timeout", "load-error"]),
+    durationMs: exports_zod.number().int().nullable(),
+    message: exports_zod.string().nullable(),
+    agentId: exports_zod.string().nullable(),
+    subject: exports_zod.string().nullable(),
+    createdAt: exports_zod.string()
+  }).openapi("ExtensionRun");
+  ExtensionInstallBodySchema = exports_zod.object({
+    manifest: ExtensionManifestSchema,
+    files: exports_zod.record(exports_zod.string(), exports_zod.string()),
+    priority: exports_zod.number().int().optional(),
+    config: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional()
+  }).strict().openapi("ExtensionInstallBody");
+  ScriptApiAuthModeSchema = exports_zod.enum(["none", "bearer"]);
+  ScriptApiRecordSchema = exports_zod.object({
+    id: exports_zod.string(),
+    scriptId: exports_zod.string(),
+    agentId: exports_zod.string(),
+    authMode: ScriptApiAuthModeSchema,
+    enabled: exports_zod.boolean(),
+    label: exports_zod.string().nullable(),
+    callCount: exports_zod.number(),
+    lastUsedAt: exports_zod.string().nullable(),
+    createdAt: exports_zod.string()
+  }).openapi("ScriptApiRecord");
+  SkillTypeSchema = exports_zod.enum(["remote", "personal"]);
+  SkillScopeSchema = exports_zod.enum(["global", "swarm", "agent"]);
+  SkillSchema = exports_zod.object({
+    id: exports_zod.string(),
+    name: exports_zod.string(),
+    description: exports_zod.string(),
+    content: exports_zod.string(),
+    type: SkillTypeSchema,
+    scope: SkillScopeSchema,
+    ownerAgentId: exports_zod.string().nullable(),
+    sourceUrl: exports_zod.string().nullable(),
+    sourceRepo: exports_zod.string().nullable(),
+    sourcePath: exports_zod.string().nullable(),
+    sourceBranch: exports_zod.string(),
+    sourceHash: exports_zod.string().nullable(),
+    isComplex: exports_zod.boolean(),
+    allowedTools: exports_zod.string().nullable(),
+    model: exports_zod.string().nullable(),
+    effort: exports_zod.string().nullable(),
+    context: exports_zod.string().nullable(),
+    agent: exports_zod.string().nullable(),
+    disableModelInvocation: exports_zod.boolean(),
+    userInvocable: exports_zod.boolean(),
+    version: exports_zod.number(),
+    isEnabled: exports_zod.boolean(),
+    systemDefault: exports_zod.boolean(),
+    createdAt: exports_zod.string(),
+    lastUpdatedAt: exports_zod.string(),
+    lastFetchedAt: exports_zod.string().nullable()
+  }).openapi("Skill");
+  AgentSkillSchema = exports_zod.object({
+    id: exports_zod.string(),
+    agentId: exports_zod.string(),
+    skillId: exports_zod.string(),
+    isActive: exports_zod.boolean(),
+    installedAt: exports_zod.string()
+  }).openapi("AgentSkill");
+  SkillWithInstallInfoSchema = SkillSchema.extend({
+    isActive: exports_zod.boolean(),
+    installedAt: exports_zod.string()
+  });
+  SkillFileSchema = exports_zod.object({
+    id: exports_zod.string(),
+    skillId: exports_zod.string(),
+    path: exports_zod.string(),
+    content: exports_zod.string(),
+    mimeType: exports_zod.string(),
+    isBinary: exports_zod.boolean(),
+    size: exports_zod.number().nullable(),
+    createdAt: exports_zod.string(),
+    lastUpdatedAt: exports_zod.string()
+  }).openapi("SkillFile");
+  McpServerTransportSchema = exports_zod.enum(["stdio", "http", "sse"]);
+  McpServerScopeSchema = exports_zod.enum(["global", "swarm", "agent"]);
+  McpAuthMethodSchema = exports_zod.enum(["static", "oauth", "auto"]);
+  McpServerSchema = exports_zod.object({
+    id: exports_zod.string(),
+    name: exports_zod.string(),
+    description: exports_zod.string().nullable(),
+    scope: McpServerScopeSchema,
+    ownerAgentId: exports_zod.string().nullable(),
+    transport: McpServerTransportSchema,
+    command: exports_zod.string().nullable(),
+    args: exports_zod.string().nullable(),
+    url: exports_zod.string().nullable(),
+    headers: exports_zod.string().nullable(),
+    envConfigKeys: exports_zod.string().nullable(),
+    headerConfigKeys: exports_zod.string().nullable(),
+    extraAuthorizeParams: exports_zod.string().nullable(),
+    authMethod: McpAuthMethodSchema.default("static"),
+    isEnabled: exports_zod.boolean(),
+    version: exports_zod.number(),
+    createdAt: exports_zod.string(),
+    lastUpdatedAt: exports_zod.string()
+  }).openapi("McpServer");
+  AgentMcpServerSchema = exports_zod.object({
+    id: exports_zod.string(),
+    agentId: exports_zod.string(),
+    mcpServerId: exports_zod.string(),
+    isActive: exports_zod.boolean(),
+    installedAt: exports_zod.string()
+  }).openapi("AgentMcpServer");
+  McpServerWithInstallInfoSchema = McpServerSchema.extend({
+    isActive: exports_zod.boolean(),
+    installedAt: exports_zod.string()
+  });
+  ContextSnapshotEventTypeSchema = exports_zod.enum(["progress", "compaction", "completion"]);
+  ContextFormulaSchema = exports_zod.enum([
+    "input-cache-output",
+    "input-cache-no-output",
+    "input-output-no-cache",
+    "peak-proxy",
+    "pi-delegated",
+    "harness-reported",
+    "unknown"
+  ]);
+  ContextSnapshotSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    taskId: exports_zod.uuid(),
+    agentId: exports_zod.string(),
+    sessionId: exports_zod.string(),
+    contextUsedTokens: exports_zod.number().int().min(0).optional(),
+    contextTotalTokens: exports_zod.number().int().min(0).optional(),
+    contextPercent: exports_zod.number().min(0).max(100).optional(),
+    eventType: ContextSnapshotEventTypeSchema,
+    compactTrigger: exports_zod.enum(["auto", "manual", "auto-inferred"]).optional(),
+    preCompactTokens: exports_zod.number().int().min(0).optional(),
+    cumulativeInputTokens: exports_zod.number().int().min(0).default(0),
+    cumulativeOutputTokens: exports_zod.number().int().min(0).default(0),
+    contextFormula: ContextFormulaSchema.optional(),
+    createdAt: exports_zod.iso.datetime()
+  }).openapi("ContextSnapshot");
+  BudgetScopeSchema = exports_zod.enum(["global", "agent", "user"]);
+  BudgetSchema = exports_zod.object({
+    scope: BudgetScopeSchema,
+    scopeId: exports_zod.string(),
+    dailyBudgetUsd: exports_zod.number().nonnegative(),
+    createdAt: exports_zod.number(),
+    lastUpdatedAt: exports_zod.number()
+  }).openapi("Budget");
+  PricingProviderSchema = exports_zod.enum([
+    "claude",
+    "claude-managed",
+    "codex",
+    "pi",
+    "opencode",
+    "devin",
+    "gemini",
+    "acp"
+  ]);
+  PricingTokenClassSchema = exports_zod.enum([
+    "input",
+    "cached_input",
+    "output",
+    "cache_write",
+    "cache_write_1h",
+    "web_search",
+    "runtime_hour",
+    "acu"
+  ]);
+  PricingRowSchema = exports_zod.object({
+    provider: PricingProviderSchema,
+    model: exports_zod.string(),
+    tokenClass: PricingTokenClassSchema,
+    effectiveFrom: exports_zod.number().nonnegative(),
+    pricePerMillionUsd: exports_zod.number().nonnegative(),
+    createdAt: exports_zod.number(),
+    lastUpdatedAt: exports_zod.number()
+  }).openapi("PricingRow");
+  BudgetRefusalCauseSchema = exports_zod.enum(["agent", "global", "user"]);
+  BudgetRefusalNotificationSchema = exports_zod.object({
+    taskId: exports_zod.string(),
+    date: exports_zod.string(),
+    agentId: exports_zod.string(),
+    cause: BudgetRefusalCauseSchema,
+    agentSpendUsd: exports_zod.number().nullable().optional(),
+    agentBudgetUsd: exports_zod.number().nullable().optional(),
+    globalSpendUsd: exports_zod.number().nullable().optional(),
+    globalBudgetUsd: exports_zod.number().nullable().optional(),
+    userSpendUsd: exports_zod.number().nullable().optional(),
+    userBudgetUsd: exports_zod.number().nullable().optional(),
+    followUpTaskId: exports_zod.string().nullable().optional(),
+    createdAt: exports_zod.number()
+  }).openapi("BudgetRefusalNotification");
+  BudgetRefusedTriggerSchema = exports_zod.object({
+    type: exports_zod.literal("budget_refused"),
+    cause: BudgetRefusalCauseSchema,
+    agentSpend: exports_zod.number().optional(),
+    agentBudget: exports_zod.number().optional(),
+    globalSpend: exports_zod.number().optional(),
+    globalBudget: exports_zod.number().optional(),
+    userSpend: exports_zod.number().optional(),
+    userBudget: exports_zod.number().optional(),
+    resetAt: exports_zod.string()
+  }).openapi("BudgetRefusedTrigger");
+  KvValueTypeSchema = exports_zod.enum(["json", "string", "integer"]);
+  KV_NAME_REGEX = /^[a-zA-Z0-9._:/%-]{1,512}$/;
+  KvNamespaceSchema = exports_zod.string().min(1).max(512).regex(KV_NAME_REGEX, "namespace must match [a-zA-Z0-9._:/%-]{1,512}");
+  KvKeySchema = exports_zod.string().min(1).max(512).regex(KV_NAME_REGEX, "key must match [a-zA-Z0-9._:/%-]{1,512}");
+  KvEntrySchema = exports_zod.object({
+    namespace: exports_zod.string(),
+    key: exports_zod.string(),
+    value: exports_zod.unknown(),
+    valueType: KvValueTypeSchema,
+    expiresAt: exports_zod.number().int().nullable(),
+    createdAt: exports_zod.number().int(),
+    updatedAt: exports_zod.number().int()
+  }).openapi("KvEntry");
+});
+
+export { normalizeAssetKey, defaultAssetKey, parseAssetKey, isCanonicalAssetKey, canWriteAssetKey, init_key, isSafeBundlePath, init_bundle_path, $OpenAPIRegistry, $OpenApiGeneratorV31, init_dist, init_zod_openapi, AssetKeySchema, AssetEntityTypeSchema, AssetKeyMappingSchema, AssetSummarySchema, ModelTierSchema, ReasoningEffortSchema, DEFAULT_MODEL_TIER_MAP, parseModelTier, splitLegacyModelAlias, resolveTaskModelSelection, AgentTaskStatusSchema, isTerminalTaskStatus, AgentTaskSourceSchema, RoutingReasonSchema, ProviderNameSchema, SteerModeSchema, SteeringSourceSchema, SteeringMessageSchema, SteerOutcomeSchema, OnUnsupportedSchema, SteerResultSchema, PROVIDER_STEER_CAPABILITIES, FollowUpConfigSchema, RoutingAffinitySchema, AgentTaskSchema, CreateTaskOptionsSchema, SERVER_GENERATED_ATTACHMENT_CAPABILITY, AttachmentInputSchema, TaskAttachmentSchema, UserSchema, UserCommsPrefsSchema, InboxItemTypeSchema, InboxItemStatusSchema, InboxItemStateSchema, FavoriteItemTypeSchema, UserFavoriteSchema, TaskTemplateKindSchema, TaskTemplateSchema, AgentStatusSchema, AgentAvatarSchema, AgentSchema, AgentLatestModelSchema, AgentAcpStatusSchema, AgentCredStatusSchema, AgentWithTasksSchema, VersionableFieldSchema, ChannelTypeSchema, ServiceStatusSchema, ServiceSchema, ResumeReasonSchema, AgentLogSchema, SessionLogSchema, SessionCostModelBreakdownSchema, SessionCostSchema, EventCategorySchema, EventStatusSchema, EventSourceSchema, EventNameSchema, SwarmEventSchema, AutomationIntegrationIdSchema, ScheduledTaskTargetTypeSchema, ScheduledTaskSchema, SwarmConfigScopeSchema, SwarmConfigSchema, RepoGuidelinesInputSchema, RepoHooksSchema, SwarmRepoSchema, AgentMemoryScopeSchema, AgentMemorySourceSchema, AgentMemorySchema, ActiveSessionSchema, RuntimeInstanceSchema, WorkflowEdgeSchema, WorkflowDefinitionSchema, WorkflowNodePatchSchema, WorkflowPatchSchema, TriggerConfigSchema, CooldownConfigSchema, InputValueSchema, WorkflowSchema, WorkflowVersionSchema, PageContentTypeSchema, PageAuthModeSchema, PageSchema, PageVersionSchema, MetricWidgetSchema, MetricDefinitionSchema, MetricSchema, MetricVersionSchema, WorkflowRunStatusSchema, WorkflowRunSchema, ScriptRunStatusSchema, TERMINAL_SCRIPT_RUN_STATUSES, ScriptRunSchema, ScriptRunListItemSchema, ScriptRunJournalEntrySchema, WorkflowRunStepSchema, PromptTemplateScopeSchema, PromptTemplateStateSchema, PromptTemplateSchema, PromptTemplateHistorySchema, ScriptScopeSchema, ScriptFsModeSchema, ScriptRecordSchema, ScriptVersionRecordSchema, ExtensionManifestSchema, ExtensionSchema, ExtensionVersionSchema, ExtensionRunSchema, ExtensionInstallBodySchema, ScriptApiAuthModeSchema, ScriptApiRecordSchema, SkillSchema, AgentSkillSchema, SkillWithInstallInfoSchema, SkillFileSchema, McpAuthMethodSchema, McpServerSchema, AgentMcpServerSchema, McpServerWithInstallInfoSchema, ContextSnapshotEventTypeSchema, ContextFormulaSchema, ContextSnapshotSchema, BudgetScopeSchema, BudgetSchema, PricingProviderSchema, PricingTokenClassSchema, PricingRowSchema, BudgetRefusalCauseSchema, BudgetRefusalNotificationSchema, BudgetRefusedTriggerSchema, KvValueTypeSchema, KvNamespaceSchema, KvKeySchema, KvEntrySchema, init_types };