@desplega.ai/agent-swarm 1.129.0 → 1.131.0

package/dist/{cli-t53vnnxz.js → cli-a4jzdpa3.js}

@@ -9,7 +9,7 @@ import {
   isEnvFlagEnabled,
   isSteeringEnabled,
   registerTemplate
-} from "./cli-4n4mdv21.js";
+} from "./cli-xpxde7rm.js";
 import {
   MAX_PROFILE_FILE_LENGTH,
   init_constants
@@ -19,8 +19,9 @@ import {
   init_credentials
 } from "./cli-z2zcxes1.js";
 import {
+  exports_zod,
   init_zod
-} from "./cli-d91pvmq1.js";
+} from "./cli-zsspvvm2.js";
 import {
   init_secret_scrubber,
   scrubSecrets
@@ -28,25 +29,15 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-kk4f9r17.js";
+} from "./cli-72q8m8gk.js";
 import {
-  ZodIssueCode,
   _enum,
-  _null,
   array,
   boolean,
-  discriminatedUnion,
-  exports_iso,
-  lazy,
-  literal,
-  number,
   object,
-  record,
   string,
-  union,
-  unknown,
-  uuid
-} from "./cli-2mbe7vk0.js";
+  union
+} from "./cli-5dsbcjjw.js";
 import {
   __commonJS,
   __esm,
@@ -167,11 +158,11 @@ function githubContextKey(input) {
   if (kind !== "issue" && kind !== "pr") {
     throw new Error(`context-key: github "kind" must be "issue" or "pr" (got ${JSON.stringify(kind)})`);
   }
-  const number2 = assertSafePart(input.number, "number");
-  if (!/^\d+$/.test(number2)) {
-    throw new Error(`context-key: github "number" must be a positive integer (got ${JSON.stringify(number2)})`);
+  const number = assertSafePart(input.number, "number");
+  if (!/^\d+$/.test(number)) {
+    throw new Error(`context-key: github "number" must be a positive integer (got ${JSON.stringify(number)})`);
   }
-  return ["task", "trackers", "github", owner, repo, kind, number2].join(SEPARATOR);
+  return ["task", "trackers", "github", owner, repo, kind, number].join(SEPARATOR);
 }
 function gitlabContextKey(input) {
   const projectId = assertSafePart(input.projectId, "projectId");
@@ -259,14 +250,14 @@ function parseContextKey(key) {
         if (kind !== "issue" && kind !== "pr") {
           throw new Error(`context-key: malformed github kind "${kind}": ${JSON.stringify(key)}`);
         }
-        const number2 = Number.parseInt(numberStr, 10);
-        if (!Number.isFinite(number2)) {
+        const number = Number.parseInt(numberStr, 10);
+        if (!Number.isFinite(number)) {
           throw new Error(`context-key: malformed github number "${numberStr}": ${JSON.stringify(key)}`);
         }
         return {
           family: "trackers",
           subFamily: "github",
-          parts: { owner, repo, kind, number: number2 }
+          parts: { owner, repo, kind, number }
         };
       }
       if (subFamily === "gitlab") {
@@ -586,6 +577,1437 @@ var init_telemetry = __esm(() => {
   };
 });
 
+// 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(object2) {
+    let hashCode = 0;
+    if (Array.isArray(object2)) {
+      for (let i = 0;i < object2.length; i++) {
+        hashCode ^= this.hashCodeOf(object2[i]) * i;
+      }
+      return hashCode;
+    }
+    if (typeof object2 === "string") {
+      for (let i = 0;i < object2.length; i++) {
+        hashCode ^= object2.charCodeAt(i) * i;
+      }
+      return hashCode;
+    }
+    if (typeof object2 === "number") {
+      return object2;
+    }
+    if (typeof object2 === "object") {
+      for (const [key, value] of Object.entries(object2)) {
+        hashCode ^= this.hashCodeOf(key) + this.hashCodeOf(value !== null && value !== undefined ? value : "");
+      }
+    }
+    return hashCode;
+  }
+}
+function isUndefined(value) {
+  return value === undefined;
+}
+function mapValues(object2, mapper) {
+  const result = {};
+  Object.entries(object2).forEach(([key, value]) => {
+    result[key] = mapper(value);
+  });
+  return result;
+}
+function omit(object2, keys) {
+  const result = {};
+  Object.entries(object2).forEach(([key, value]) => {
+    if (!keys.some((keyToOmit) => keyToOmit === key)) {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+function omitBy(object2, predicate) {
+  const result = {};
+  Object.entries(object2).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((object2) => objectEquals(object2, 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)
@@ -657,10 +2079,10 @@ function isTerminalTaskStatus(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, ProviderNameSchema, SteerModeSchema, SteeringStatusSchema, SteeringSourceSchema, SteeringMessageSchema, SteerOutcomeSchema, OnUnsupportedSchema, SteerResultSchema, PROVIDER_STEER_CAPABILITIES, FollowUpConfigSchema, RoutingAffinitySchema, AgentTaskSchema, TaskAttachmentKindSchema, attachmentCommonFields, AttachmentInputSchema, TaskAttachmentSchema, UserSchema, IdentityEventTypeSchema, InboxItemTypeSchema, InboxItemStatusSchema, InboxItemStateSchema, FavoriteItemTypeSchema, UserFavoriteSchema, TaskTemplateKindSchema, TaskTemplateSchema, AgentStatusSchema, AgentAvatarSchema, AgentSchema, AgentCredStatusLiveTestSchema, AgentLatestModelSchema, AgentBedrockStatusSchema, AgentCredStatusSchema, AgentWithTasksSchema, ChangeSourceSchema, VersionableFieldSchema, ContextVersionSchema, ChannelTypeSchema, ChannelSchema, ChannelMessageSchema, ServiceStatusSchema, ServiceSchema, AgentLogEventTypeSchema, ResumeReasonSchema, AgentLogSchema, SessionLogSchema, SessionCostSourceSchema, SessionCostModelBreakdownSchema, SessionCostSchema, EventCategorySchema, EventStatusSchema, EventSourceSchema, EventNameSchema, SwarmEventSchema, ScheduledTaskTargetTypeSchema, ScheduledTaskSchema, SwarmConfigScopeSchema, SwarmConfigSchema, RepoGuidelinesSchema, RepoHooksSchema, SwarmRepoSchema, AgentMemoryScopeSchema, AgentMemorySourceSchema, AgentMemorySchema, ActiveSessionSchema, 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, 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_zod();
   init_key();
   init_constants();
-  AssetKeySchema = string().min(1).max(255).superRefine((value, ctx) => {
+  init_zod_openapi();
+  AssetKeySchema = exports_zod.string().min(1).max(255).superRefine((value, ctx) => {
     try {
       normalizeAssetKey(value);
     } catch (error) {
@@ -670,38 +2092,46 @@ var init_types = __esm(() => {
       });
     }
   }).describe("Non-unique asset directory namespace (for example shared/ or personal/<user-id>/drafts/). Runtime write boundaries normalize and validate the canonical form.");
-  AssetEntityTypeSchema = _enum(["task", "workflow", "schedule", "page", "file"]);
-  AssetProviderRefSchema = object({
-    providerId: string(),
-    orgId: string().optional(),
-    driveId: string().optional(),
-    providerKey: string()
-  });
-  AssetKeyMappingSchema = object({
-    id: string(),
-    providerId: string(),
-    providerOrgId: string().optional(),
-    providerDriveId: string().optional(),
-    providerKey: string(),
+  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: _enum(["task-attachment", "external"]).optional(),
-    sourceEntityId: string().optional(),
-    createdAt: exports_iso.datetime(),
-    updatedAt: exports_iso.datetime(),
-    createdBy: string().optional(),
-    updatedBy: string().optional()
-  });
-  AssetSummarySchema = object({
+    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: string(),
+    id: exports_zod.string(),
     key: AssetKeySchema,
-    label: string(),
-    updatedAt: string(),
+    label: exports_zod.string(),
+    updatedAt: exports_zod.string(),
     providerRef: AssetProviderRefSchema.optional()
-  });
-  ModelTierSchema = _enum(["smol", "regular", "smart", "ultra"]);
+  }).openapi("AssetSummary");
+  ModelTierSchema = exports_zod.enum(["smol", "regular", "smart", "ultra"]);
   MODEL_TIERS = ModelTierSchema.options;
-  ReasoningEffortSchema = _enum(["off", "low", "medium", "high", "xhigh", "max"]);
+  ReasoningEffortSchema = exports_zod.enum(["off", "low", "medium", "high", "xhigh", "max"]);
   LEGACY_MODEL_TO_TIER = {
     haiku: "smol",
     sonnet: "regular",
@@ -746,7 +2176,7 @@ var init_types = __esm(() => {
       ultra: "devin"
     }
   };
-  AgentTaskStatusSchema = _enum([
+  AgentTaskStatusSchema = exports_zod.enum([
     "backlog",
     "unassigned",
     "offered",
@@ -760,29 +2190,29 @@ var init_types = __esm(() => {
     "superseded"
   ]);
   TERMINAL_TASK_STATUSES = ["completed", "failed", "cancelled", "superseded"];
-  InboxMessageStatusSchema = _enum([
+  InboxMessageStatusSchema = exports_zod.enum([
     "unread",
     "processing",
     "read",
     "responded",
     "delegated"
   ]);
-  InboxMessageSchema = object({
-    id: uuid(),
-    agentId: string(),
-    content: string().min(1),
-    source: _enum(["slack", "agentmail"]).default("slack"),
+  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: string().optional(),
-    slackThreadTs: string().optional(),
-    slackUserId: string().optional(),
-    matchedText: string().optional(),
-    delegatedToTaskId: uuid().optional(),
-    responseText: string().optional(),
-    createdAt: exports_iso.datetime(),
-    lastUpdatedAt: exports_iso.datetime()
-  });
-  AgentTaskSourceSchema = _enum([
+    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",
@@ -796,7 +2226,7 @@ var init_types = __esm(() => {
     "linear",
     "jira"
   ]);
-  ProviderNameSchema = _enum([
+  ProviderNameSchema = exports_zod.enum([
     "claude",
     "codex",
     "pi",
@@ -804,41 +2234,41 @@ var init_types = __esm(() => {
     "claude-managed",
     "opencode"
   ]);
-  SteerModeSchema = _enum(["steer", "queue"]);
-  SteeringStatusSchema = _enum([
+  SteerModeSchema = exports_zod.enum(["steer", "queue"]);
+  SteeringStatusSchema = exports_zod.enum([
     "pending",
     "delivered",
     "handled",
     "promoted",
     "cancelled"
   ]);
-  SteeringSourceSchema = _enum(["ui", "mcp", "script", "slack", "api"]);
-  SteeringMessageSchema = object({
-    id: uuid(),
-    taskId: uuid(),
-    body: string().min(1),
+  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,
-    createdByKind: _enum(["user", "agent", "system"]),
-    createdByUserId: string().optional(),
-    createdByAgentId: string().optional(),
-    promotedTaskId: uuid().optional(),
-    createdAt: exports_iso.datetime(),
-    deliveredAt: exports_iso.datetime().optional(),
-    handledAt: exports_iso.datetime().optional(),
-    handledNote: string().optional()
-  });
-  SteerOutcomeSchema = _enum(["steered", "queued", "promoted"]);
-  OnUnsupportedSchema = _enum(["degrade", "fail"]).default("degrade");
-  SteerResultSchema = object({
+    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: uuid().optional(),
-    promotedTaskId: uuid().optional(),
+    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"],
@@ -847,167 +2277,167 @@ var init_types = __esm(() => {
     claude: ["queue"],
     codex: ["queue"]
   };
-  FollowUpConfigSchema = object({
-    disabled: boolean().optional(),
-    onCompleted: string().max(4000).optional(),
-    onFailed: string().max(4000).optional()
-  });
-  RoutingAffinitySchema = object({
-    sourceAgentId: string().optional(),
-    role: string().max(100).optional(),
+  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: array(string()).default([])
-  });
-  AgentTaskSchema = object({
-    id: uuid(),
+    capabilities: exports_zod.array(exports_zod.string()).default([])
+  }).openapi("RoutingAffinity");
+  AgentTaskSchema = exports_zod.object({
+    id: exports_zod.uuid(),
     key: AssetKeySchema,
-    agentId: string().nullable(),
-    creatorAgentId: string().optional(),
-    task: string().min(1),
-    title: string().optional(),
+    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"),
-    taskType: string().max(50).optional(),
-    tags: array(string()).default([]),
-    priority: number().int().min(0).max(100).default(50),
-    dependsOn: array(uuid()).default([]),
-    offeredTo: string().optional(),
-    offeredAt: exports_iso.datetime().optional(),
-    acceptedAt: exports_iso.datetime().optional(),
-    rejectionReason: string().optional(),
-    createdAt: exports_iso.datetime().default(() => new Date().toISOString()),
-    lastUpdatedAt: exports_iso.datetime().default(() => new Date().toISOString()),
-    finishedAt: exports_iso.datetime().optional(),
-    notifiedAt: exports_iso.datetime().optional(),
-    failureReason: string().optional(),
-    output: string().optional(),
-    progress: string().optional(),
-    slackChannelId: string().optional(),
-    slackThreadTs: string().optional(),
-    slackTriggerMessageTs: string().optional(),
-    slackUserId: string().optional(),
-    slackReplySent: boolean().default(false),
-    slackProgressMessageTs: string().optional(),
-    slackTreeRootMessageTs: string().optional(),
-    vcsProvider: _enum(["github", "gitlab"]).optional(),
-    vcsRepo: string().optional(),
-    vcsEventType: string().optional(),
-    vcsNumber: number().int().optional(),
-    vcsCommentId: number().int().optional(),
-    vcsAuthor: string().optional(),
-    vcsUrl: string().optional(),
-    vcsInstallationId: number().int().optional(),
-    vcsNodeId: string().optional(),
-    agentmailInboxId: string().optional(),
-    agentmailMessageId: string().optional(),
-    agentmailThreadId: string().optional(),
-    mentionMessageId: uuid().optional(),
-    mentionChannelId: uuid().optional(),
-    dir: string().min(1).startsWith("/").optional(),
-    parentTaskId: uuid().optional(),
-    claudeSessionId: string().optional(),
-    model: 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),
+    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: uuid().optional(),
-    workflowRunId: string().uuid().nullable().optional(),
-    workflowRunStepId: string().uuid().nullable().optional(),
-    contextKey: string().optional(),
-    outputSchema: record(string(), unknown()).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: boolean().default(false),
-    compactionCount: number().int().min(0).optional(),
-    peakContextPercent: number().min(0).max(100).optional(),
-    peakContextTokens: number().int().min(0).optional(),
-    contextWindowSize: number().int().min(0).optional(),
-    credentialKeySuffix: string().optional(),
-    credentialKeyType: string().optional(),
-    requestedByUserId: string().optional(),
-    swarmVersion: string().optional(),
+    wasPaused: exports_zod.boolean().default(false),
+    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: record(string(), unknown()).optional(),
-    harnessVariant: string().optional(),
-    harnessVariantMeta: record(string(), unknown()).optional(),
-    totalCostUsd: number().min(0).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()
-  });
-  TaskAttachmentKindSchema = _enum(["agent-fs", "url", "shared-fs", "page"]);
+  }).openapi("AgentTask");
+  TaskAttachmentKindSchema = exports_zod.enum(["agent-fs", "url", "shared-fs", "page"]);
   attachmentCommonFields = {
-    name: string().min(1).describe("Display name for the attachment."),
-    providerId: string().min(1).optional(),
-    providerKey: string().min(1).optional(),
-    capabilities: record(string(), unknown()).optional(),
-    mimeType: string().optional(),
-    sizeBytes: number().int().min(0).optional(),
-    sha256: string().optional(),
-    intent: string().optional().describe("WHY this attachment exists — the purpose it serves for this task."),
-    description: string().optional().describe("Optional: what the attachment is."),
-    isPrimary: boolean().optional()
+    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: exports_zod.record(exports_zod.string(), exports_zod.unknown()).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 = discriminatedUnion("kind", [
-    object({
-      kind: literal("agent-fs"),
-      path: string().min(1).describe("agent-fs path the attachment points at."),
-      orgId: string().min(1).optional().describe("agent-fs org id — paired with `driveId` lets the renderer build a public live-host URL."),
-      driveId: string().min(1).optional().describe("agent-fs drive id — paired with `orgId` lets the renderer build a public live-host URL."),
+  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
     }),
-    object({
-      kind: literal("url"),
-      url: string().min(1).describe("External URL the attachment points at."),
+    exports_zod.object({
+      kind: exports_zod.literal("url"),
+      url: exports_zod.string().min(1).describe("External URL the attachment points at."),
       ...attachmentCommonFields
     }),
-    object({
-      kind: literal("shared-fs"),
-      path: string().min(1).describe("Shared-filesystem path the attachment points at."),
+    exports_zod.object({
+      kind: exports_zod.literal("shared-fs"),
+      path: exports_zod.string().min(1).describe("Shared-filesystem path the attachment points at."),
       ...attachmentCommonFields
     }),
-    object({
-      kind: literal("page"),
-      pageId: string().min(1).describe("Swarm Page id the attachment points at."),
+    exports_zod.object({
+      kind: exports_zod.literal("page"),
+      pageId: exports_zod.string().min(1).describe("Swarm Page id the attachment points at."),
       ...attachmentCommonFields
     })
   ]);
-  TaskAttachmentSchema = object({
-    id: uuid(),
-    taskId: uuid(),
-    agentId: string().nullable(),
-    name: string(),
+  TaskAttachmentSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    taskId: exports_zod.uuid(),
+    agentId: exports_zod.string().nullable(),
+    name: exports_zod.string(),
     kind: TaskAttachmentKindSchema,
-    url: string().optional(),
-    path: string().optional(),
-    pageId: string().optional(),
-    providerId: string().optional(),
-    providerKey: string().optional(),
-    capabilities: record(string(), unknown()).optional(),
-    orgId: string().optional(),
-    driveId: string().optional(),
-    mimeType: string().optional(),
-    sizeBytes: number().int().min(0).optional(),
-    sha256: string().optional(),
-    intent: string().optional(),
-    description: string().optional(),
-    isPrimary: boolean().default(false),
-    createdAt: exports_iso.datetime(),
-    createdBy: string().optional(),
-    updatedBy: string().optional()
-  });
-  UserSchema = object({
-    id: string(),
-    name: string().min(1),
-    email: string().optional(),
-    role: string().optional(),
-    notes: string().optional(),
-    emailAliases: array(string()).default([]),
-    preferredChannel: string().default("slack"),
-    timezone: string().optional(),
-    metadata: record(string(), unknown()).optional(),
-    dailyBudgetUsd: number().nullable().optional(),
-    status: _enum(["invited", "active", "suspended"]).default("active"),
-    createdAt: exports_iso.datetime(),
-    lastUpdatedAt: exports_iso.datetime()
-  });
-  IdentityEventTypeSchema = _enum([
+    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");
+  IdentityEventTypeSchema = exports_zod.enum([
     "auto_merge",
     "manual_merge",
     "identity_added",
@@ -1020,125 +2450,125 @@ var init_types = __esm(() => {
     "status_changed",
     "profile_changed"
   ]);
-  InboxItemTypeSchema = _enum([
+  InboxItemTypeSchema = exports_zod.enum([
     "approval",
     "credential_missing",
     "broken_task",
     "to_read",
     "to_start_template"
   ]);
-  InboxItemStatusSchema = _enum(["open", "snoozed", "dismissed", "done"]);
-  InboxItemStateSchema = object({
-    id: string(),
-    userId: string(),
+  InboxItemStatusSchema = exports_zod.enum(["open", "snoozed", "dismissed", "done"]);
+  InboxItemStateSchema = exports_zod.object({
+    id: exports_zod.string(),
+    userId: exports_zod.string(),
     itemType: InboxItemTypeSchema,
-    itemId: string(),
+    itemId: exports_zod.string(),
     status: InboxItemStatusSchema,
-    snoozeUntil: string().optional(),
-    dismissedAt: string().optional(),
-    doneAt: string().optional(),
-    createdAt: string(),
-    lastUpdatedAt: string()
-  });
-  FavoriteItemTypeSchema = _enum(["page", "workflow", "schedule"]);
-  UserFavoriteSchema = object({
-    id: string(),
-    userId: string().optional(),
+    snoozeUntil: exports_zod.string().optional(),
+    dismissedAt: exports_zod.string().optional(),
+    doneAt: 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: string(),
-    createdAt: string(),
-    lastUpdatedAt: string(),
-    createdBy: string().optional(),
-    updatedBy: string().optional()
-  });
-  TaskTemplateKindSchema = _enum(["task", "workflow", "schedule"]);
-  TaskTemplateSchema = object({
-    id: string(),
-    title: string().min(1),
-    description: string(),
-    prompt: string(),
+    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: record(string(), unknown()).default({}),
-    category: string().optional(),
-    tags: array(string()).default([]),
-    createdAt: string()
-  });
-  AgentStatusSchema = _enum(["idle", "busy", "offline", "waiting_for_credentials"]);
-  AgentAvatarSchema = discriminatedUnion("type", [
-    object({
-      type: literal("lucide"),
-      icon: string().regex(/^[a-z0-9-]+$/).max(64),
-      color: string().regex(/^#[0-9a-fA-F]{6}$/).optional()
+    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 = object({
-    id: string(),
-    name: string().min(1),
-    isLead: boolean().default(false),
+  AgentSchema = exports_zod.object({
+    id: exports_zod.string(),
+    name: exports_zod.string().min(1),
+    isLead: exports_zod.boolean().default(false),
     status: AgentStatusSchema,
-    description: string().optional(),
-    role: string().max(100).optional(),
-    capabilities: array(string()).default([]),
-    claudeMd: string().max(MAX_PROFILE_FILE_LENGTH).optional(),
-    soulMd: string().max(MAX_PROFILE_FILE_LENGTH).optional(),
-    identityMd: string().max(MAX_PROFILE_FILE_LENGTH).optional(),
-    setupScript: string().max(MAX_PROFILE_FILE_LENGTH).optional(),
-    toolsMd: string().max(MAX_PROFILE_FILE_LENGTH).optional(),
-    heartbeatMd: string().max(MAX_PROFILE_FILE_LENGTH).optional(),
-    maxTasks: number().int().min(1).max(100).optional(),
-    emptyPollCount: number().int().min(0).optional(),
-    lastActivityAt: exports_iso.datetime().optional(),
+    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: array(string()).nullable().optional(),
-    credStatus: lazy(() => AgentCredStatusSchema).nullable().optional(),
-    avatar: lazy(() => AgentAvatarSchema).nullable().optional(),
-    createdAt: exports_iso.datetime().default(() => new Date().toISOString()),
-    lastUpdatedAt: exports_iso.datetime().default(() => new Date().toISOString())
-  });
-  AgentCredStatusLiveTestSchema = object({
-    ok: boolean(),
-    error: string().nullable().default(null),
-    latency_ms: number(),
-    testedAt: number()
-  });
-  AgentLatestModelSchema = object({
-    model: string().min(1),
-    source: _enum(["task", "agent_config", "adapter_default", "custom"]),
-    taskId: string().nullable().default(null),
+    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: number(),
+    reportedAt: exports_zod.number(),
     reasoningEffort: ReasoningEffortSchema.optional()
-  });
-  AgentBedrockStatusSchema = object({
-    region: string(),
-    probedAt: number(),
-    ready: boolean(),
-    models: array(object({ id: string(), name: string() })).default([]),
-    error: string().optional()
-  });
-  AgentCredStatusSchema = object({
-    ready: boolean(),
-    missing: array(string()).default([]),
-    satisfiedBy: _enum(["env", "file", "side-effect-pending", "sdk-delegated"]).nullable().default(null),
-    hint: string().nullable().default(null),
+  }).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");
+  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: number(),
-    reportKind: _enum(["boot", "post_task"]).default("boot"),
+    reportedAt: exports_zod.number(),
+    reportKind: exports_zod.enum(["boot", "post_task"]).default("boot"),
     bedrock: AgentBedrockStatusSchema.nullable().default(null)
-  });
+  }).openapi("AgentCredStatus");
   AgentWithTasksSchema = AgentSchema.extend({
-    tasks: array(AgentTaskSchema).default([])
+    tasks: exports_zod.array(AgentTaskSchema).default([])
   });
-  ChangeSourceSchema = _enum([
+  ChangeSourceSchema = exports_zod.enum([
     "self_edit",
     "lead_coaching",
     "api",
     "system",
     "session_sync"
   ]);
-  VersionableFieldSchema = _enum([
+  VersionableFieldSchema = exports_zod.enum([
     "soulMd",
     "identityMd",
     "toolsMd",
@@ -1146,59 +2576,59 @@ var init_types = __esm(() => {
     "setupScript",
     "heartbeatMd"
   ]);
-  ContextVersionSchema = object({
-    id: uuid(),
-    agentId: string(),
+  ContextVersionSchema = exports_zod.object({
+    id: exports_zod.uuid(),
+    agentId: exports_zod.string(),
     field: VersionableFieldSchema,
-    content: string(),
-    version: number().int().min(1),
+    content: exports_zod.string(),
+    version: exports_zod.number().int().min(1),
     changeSource: ChangeSourceSchema,
-    changedByAgentId: string().nullable(),
-    changeReason: string().nullable(),
-    contentHash: string(),
-    previousVersionId: uuid().nullable(),
-    createdAt: exports_iso.datetime()
-  });
-  ChannelTypeSchema = _enum(["public", "dm"]);
-  ChannelSchema = object({
-    id: uuid(),
-    name: string().min(1).max(100),
-    description: string().max(500).optional(),
+    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: string().optional(),
-    participants: array(string()).default([]),
-    createdAt: exports_iso.datetime()
-  });
-  ChannelMessageSchema = object({
-    id: uuid(),
-    channelId: uuid(),
-    agentId: string().nullable(),
-    agentName: string().optional(),
-    content: string().min(1).max(4000),
-    replyToId: uuid().optional(),
-    mentions: array(string()).default([]),
-    createdAt: exports_iso.datetime()
-  });
-  ServiceStatusSchema = _enum(["starting", "healthy", "unhealthy", "stopped"]);
-  ServiceSchema = object({
-    id: uuid(),
-    agentId: string(),
-    name: string().min(1).max(50),
-    port: number().int().min(1).max(65535).default(3000),
-    description: string().optional(),
-    url: string().url().optional(),
-    healthCheckPath: string().default("/health"),
+    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: string().min(1),
-    cwd: string().optional(),
-    interpreter: string().optional(),
-    args: array(string()).optional(),
-    env: record(string(), string()).optional(),
-    metadata: record(string(), unknown()).default({}),
-    createdAt: exports_iso.datetime(),
-    lastUpdatedAt: exports_iso.datetime()
-  });
-  AgentLogEventTypeSchema = _enum([
+    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",
@@ -1224,67 +2654,67 @@ var init_types = __esm(() => {
     "pricing.refresh.failed",
     "task_superseded"
   ]);
-  ResumeReasonSchema = _enum([
+  ResumeReasonSchema = exports_zod.enum([
     "graceful_shutdown",
     "context_limits",
     "manual_supersede",
     "crash_recovery"
   ]);
-  AgentLogSchema = object({
-    id: uuid(),
+  AgentLogSchema = exports_zod.object({
+    id: exports_zod.uuid(),
     eventType: AgentLogEventTypeSchema,
-    agentId: string().optional(),
-    taskId: string().optional(),
-    oldValue: string().optional(),
-    newValue: string().optional(),
-    metadata: string().optional(),
-    createdAt: exports_iso.datetime()
-  });
-  SessionLogSchema = object({
-    id: uuid(),
-    taskId: uuid().optional(),
-    sessionId: string(),
-    iteration: number().int().min(1),
-    cli: string().default("claude"),
-    content: string(),
-    lineNumber: number().int().min(0),
-    createdAt: exports_iso.datetime()
-  });
-  SessionCostSourceSchema = _enum(["harness", "pricing-table", "unpriced"]);
-  SessionCostModelBreakdownSchema = object({
-    model: string(),
-    inputTokens: number().int().nonnegative(),
-    outputTokens: number().int().nonnegative(),
-    cacheReadTokens: number().int().nonnegative(),
-    cacheWriteTokens: number().int().nonnegative(),
-    webSearchRequests: number().int().nonnegative().nullable().optional(),
-    costUsd: number().nullable().optional(),
-    harnessCostUsd: number().nullable().optional()
-  });
-  SessionCostSchema = object({
-    id: uuid(),
-    sessionId: string(),
-    taskId: uuid().optional(),
-    agentId: string(),
-    totalCostUsd: number().min(0),
-    inputTokens: number().int().min(0).default(0),
-    outputTokens: number().int().min(0).default(0),
-    cacheReadTokens: number().int().min(0).default(0),
-    cacheWriteTokens: number().int().min(0).default(0),
-    reasoningOutputTokens: number().int().min(0).default(0),
-    thinkingTokens: number().int().min(0).default(0),
-    durationMs: number().int().min(0),
-    numTurns: number().int().min(1).nullable(),
-    model: string(),
-    isError: boolean().default(false),
+    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: number().nullable().optional(),
-    cacheWrite5mTokens: number().int().nullable().optional(),
-    cacheWrite1hTokens: number().int().nullable().optional(),
-    modelBreakdown: array(SessionCostModelBreakdownSchema).nullable().optional(),
-    createdAt: exports_iso.datetime()
-  });
-  EventCategorySchema = _enum([
+    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",
@@ -1293,9 +2723,9 @@ var init_types = __esm(() => {
     "workflow",
     "system"
   ]);
-  EventStatusSchema = _enum(["ok", "error", "timeout", "skipped"]);
-  EventSourceSchema = _enum(["worker", "api", "hook", "scheduler", "cli"]);
-  EventNameSchema = _enum([
+  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",
@@ -1319,54 +2749,54 @@ var init_types = __esm(() => {
     "script.global_upsert",
     "schedule.deleted"
   ]);
-  SwarmEventSchema = object({
-    id: uuid(),
+  SwarmEventSchema = exports_zod.object({
+    id: exports_zod.uuid(),
     category: EventCategorySchema,
     event: EventNameSchema,
     status: EventStatusSchema,
     source: EventSourceSchema,
-    agentId: string().optional(),
-    taskId: string().optional(),
-    sessionId: string().optional(),
-    parentEventId: string().optional(),
-    numericValue: number().optional(),
-    durationMs: number().int().optional(),
-    data: record(string(), unknown()).optional(),
-    createdAt: exports_iso.datetime()
-  });
-  ScheduledTaskTargetTypeSchema = _enum(["agent-task", "workflow", "script"]);
-  ScheduledTaskSchema = object({
-    id: uuid(),
+    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");
+  ScheduledTaskTargetTypeSchema = exports_zod.enum(["agent-task", "workflow", "script"]);
+  ScheduledTaskSchema = exports_zod.object({
+    id: exports_zod.uuid(),
     key: AssetKeySchema,
-    name: string().min(1).max(100),
-    description: string().optional(),
-    cronExpression: string().optional(),
-    intervalMs: number().int().positive().optional(),
-    taskTemplate: string().optional(),
-    taskType: string().max(50).optional(),
-    tags: array(string()).default([]),
-    priority: number().int().min(0).max(100).default(50),
-    targetAgentId: string().optional(),
-    enabled: boolean().default(true),
-    lastRunAt: exports_iso.datetime().optional(),
-    nextRunAt: exports_iso.datetime().optional(),
-    createdByAgentId: string().optional(),
-    timezone: string().default("UTC"),
-    consecutiveErrors: number().int().min(0).default(0),
-    lastErrorAt: exports_iso.datetime().optional(),
-    lastErrorMessage: string().optional(),
-    model: string().optional(),
+    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(),
+    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: _enum(["recurring", "one_time"]).default("recurring"),
+    scheduleType: exports_zod.enum(["recurring", "one_time"]).default("recurring"),
     targetType: ScheduledTaskTargetTypeSchema.default("agent-task"),
-    workflowId: uuid().optional(),
-    scriptName: string().optional(),
-    scriptArgs: record(string(), unknown()).optional(),
-    createdAt: exports_iso.datetime(),
-    lastUpdatedAt: exports_iso.datetime(),
-    createdBy: string().optional(),
-    updatedBy: string().optional(),
-    favorite: boolean().optional()
+    workflowId: exports_zod.uuid().optional(),
+    scriptName: exports_zod.string().optional(),
+    scriptArgs: exports_zod.record(exports_zod.string(), exports_zod.unknown()).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;
@@ -1387,293 +2817,293 @@ var init_types = __esm(() => {
   }, {
     message: "Target-type specific field is required (taskTemplate, workflowId, or scriptName)"
   });
-  SwarmConfigScopeSchema = _enum(["global", "agent", "repo"]);
-  SwarmConfigSchema = object({
-    id: string().uuid(),
+  SwarmConfigScopeSchema = exports_zod.enum(["global", "agent", "repo"]);
+  SwarmConfigSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
     scope: SwarmConfigScopeSchema,
-    scopeId: string().nullable(),
-    key: string().min(1).max(255),
-    value: string(),
-    isSecret: boolean(),
-    envPath: string().nullable(),
-    description: string().nullable(),
-    createdAt: string(),
-    lastUpdatedAt: string(),
-    encrypted: boolean()
-  });
-  RepoGuidelinesSchema = object({
-    prChecks: array(string()),
-    mergeChecks: array(string()),
-    allowMerge: boolean().optional().default(false),
-    review: array(string())
-  });
-  RepoHooksSchema = object({
-    enabled: boolean().default(false)
-  });
-  SwarmRepoSchema = object({
-    id: string().uuid(),
-    url: string().min(1),
-    name: string().min(1).max(100),
-    clonePath: string().min(1),
-    defaultBranch: string().default("main"),
-    autoClone: boolean().default(true),
+    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");
+  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: string(),
-    lastUpdatedAt: string()
-  });
-  AgentMemoryScopeSchema = _enum(["agent", "swarm"]);
-  AgentMemorySourceSchema = _enum([
+    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 = object({
-    id: string().uuid(),
-    agentId: string().nullable(),
+  AgentMemorySchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    agentId: exports_zod.string().nullable(),
     scope: AgentMemoryScopeSchema,
-    key: string().nullable().optional(),
-    name: string().min(1).max(500),
-    content: string(),
-    summary: string().nullable(),
+    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: string().uuid().nullable(),
-    sourcePath: string().nullable(),
-    chunkIndex: number().int().min(0).default(0),
-    totalChunks: number().int().min(1).default(1),
-    tags: array(string()),
-    createdAt: string(),
-    updatedAt: string().nullable().optional(),
-    accessedAt: string(),
-    expiresAt: string().nullable().optional(),
-    accessCount: number().int().min(0).default(0).optional(),
-    embeddingModel: string().nullable().optional(),
-    contentHash: string().nullable().optional(),
-    version: number().int().min(1).default(1).optional()
-  });
-  ActiveSessionSchema = object({
-    id: uuid(),
-    agentId: string(),
-    taskId: string().nullable(),
-    triggerType: string(),
-    inboxMessageId: string().nullable(),
-    taskDescription: string().nullable(),
-    runnerSessionId: string().nullable(),
-    providerSessionId: string().nullable(),
-    startedAt: exports_iso.datetime(),
-    lastHeartbeatAt: exports_iso.datetime()
-  });
-  RetryPolicySchema = object({
-    maxRetries: number().int().min(0).default(3),
-    strategy: _enum(["exponential", "static", "linear"]).default("exponential"),
-    baseDelayMs: number().int().min(0).default(1000),
-    maxDelayMs: number().int().min(0).default(60000)
-  });
-  ExecutorMetaSchema = object({
-    runId: string().uuid(),
-    stepId: string().uuid(),
-    nodeId: string(),
-    workflowId: string().uuid(),
-    dryRun: boolean().default(false),
-    requestedByUserId: string().optional(),
-    inputCtx: record(string(), unknown()).optional()
-  });
-  ValidationResultSchema = object({
-    pass: boolean(),
-    reasoning: string(),
-    confidence: number().min(0).max(1)
-  });
-  StepValidationConfigSchema = object({
-    executor: string().default("validate"),
-    config: record(string(), unknown()),
-    mustPass: boolean().default(false),
+    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(),
+    startedAt: exports_zod.iso.datetime(),
+    lastHeartbeatAt: exports_zod.iso.datetime()
+  }).openapi("ActiveSession");
+  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()
-  });
-  SwarmScriptNodeConfigSchema = object({
-    scriptName: string().min(1),
-    scope: _enum(["global", "agent"]).optional(),
-    pinHash: string().min(1).optional(),
-    args: record(string(), unknown()).optional(),
-    fsMode: _enum(["none", "workspace-rw"]).optional(),
-    timeoutMs: number().int().min(1000).max(300000).optional()
-  });
-  WorkflowNodeSchema = object({
-    id: string().describe("Unique node identifier, used in 'next' and 'inputs' mappings"),
-    type: string().describe("Executor type: 'agent-task', 'script', 'swarm-script', 'raw-llm', 'validate', 'property-match'"),
-    label: string().optional().describe("Human-readable label for UI display"),
-    config: record(string(), unknown()).describe("Executor-specific config. For agent-task: { template, outputSchema?, agentId?, tags?, priority?, dir?, vcsRepo?, model? }. " + "For swarm-script: { scriptName, scope?, pinHash?, args?, fsMode?, timeoutMs? (1000-300000) }. " + "Values support {{interpolation}} from the node's inputs context. " + "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: union([string(), array(string()), record(string(), 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'})"),
+  }).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?, tags?, priority?, dir?, vcsRepo?, model? }. " + "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: record(string(), 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 — only 'trigger' and 'input' are. " + 'Example: { "cityData": "generate-city" } → use {{cityData.taskOutput.field}} in config templates. ' + 'For trigger data: { "pr": "trigger.pullRequest" }.'),
-    inputSchema: record(string(), unknown()).optional().describe("JSON Schema to validate resolved inputs before execution"),
-    outputSchema: record(string(), 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.")
-  });
-  WorkflowEdgeSchema = object({
-    id: string(),
-    source: string(),
-    sourcePort: string(),
-    target: string()
-  });
-  WorkflowDefinitionSchema = object({
-    nodes: array(WorkflowNodeSchema).min(1),
-    onNodeFailure: _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.")
-  });
+    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 = object({
-    update: array(object({
-      nodeId: string().describe("ID of the node to update"),
+  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: array(string()).optional().describe("Node IDs to delete"),
-    create: array(WorkflowNodeSchema).optional().describe("New nodes to add"),
-    onNodeFailure: _enum(["fail", "continue"]).optional().describe("Update the definition-level onNodeFailure behavior"),
-    triggerSchema: record(string(), 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.")
-  });
-  WebhookVerificationSchema = discriminatedUnion("format", [
-    object({
-      format: literal("hmac-sha256"),
-      header: string().default("X-Hub-Signature-256").describe("Header containing HMAC-SHA256 over the raw request body. Accepts sha256=<hex> or bare hex.")
+    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.")
+  }).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.")
     }),
-    object({
-      format: literal("timestamped-hmac-sha256"),
-      header: string().min(1).describe("Header containing comma-separated timestamp/signature pairs such as t=<timestamp>,v1=<hex>."),
-      timestampKey: string().default("t").describe("Timestamp field key in the signature header"),
-      signatureKey: string().default("v1").describe("Signature field key in the signature header; multiple entries are allowed"),
-      toleranceSeconds: number().int().positive().default(300).describe("Maximum allowed clock skew, in seconds, for replay protection")
+    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")
     }),
-    object({
-      format: literal("token-equality"),
-      header: string().min(1).describe("Header containing the shared token to compare")
+    exports_zod.object({
+      format: exports_zod.literal("token-equality"),
+      header: exports_zod.string().min(1).describe("Header containing the shared token to compare")
     })
   ]);
-  TriggerConfigSchema = discriminatedUnion("type", [
-    object({
-      type: literal("webhook"),
-      hmacSecret: string().optional(),
-      hmacHeader: string().default("X-Hub-Signature-256").describe("Legacy HMAC header for webhook verification. Prefer verification.header for new workflows."),
+  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.")
     }),
-    object({
-      type: literal("schedule"),
-      scheduleId: string().uuid()
+    exports_zod.object({
+      type: exports_zod.literal("schedule"),
+      scheduleId: exports_zod.string().uuid()
     })
   ]).superRefine((trigger, ctx) => {
     if (trigger.type === "webhook" && trigger.verification && !trigger.hmacSecret) {
       ctx.addIssue({
-        code: ZodIssueCode.custom,
+        code: exports_zod.ZodIssueCode.custom,
         message: "hmacSecret is required when verification is configured",
         path: ["hmacSecret"]
       });
     }
   });
-  CooldownConfigSchema = object({
-    hours: number().min(0).optional(),
-    minutes: number().min(0).optional(),
-    seconds: number().min(0).optional()
+  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 = union([
-    string().regex(/^\$\{.+\}$/),
-    string().regex(/^secret\..+$/),
-    string()
+  InputValueSchema = exports_zod.union([
+    exports_zod.string().regex(/^\$\{.+\}$/),
+    exports_zod.string().regex(/^secret\..+$/),
+    exports_zod.string()
   ]);
-  WorkflowTemplateSchema = object({
-    id: string().uuid(),
-    name: string(),
-    description: string(),
-    category: string(),
-    variables: array(object({
-      name: string(),
-      description: string(),
-      type: _enum(["string", "number", "boolean"]),
-      default: unknown().optional(),
-      required: boolean().default(true)
+  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
-  });
-  WorkflowSnapshotSchema = object({
-    name: string(),
-    description: string().optional(),
+  }).openapi("WorkflowTemplate");
+  WorkflowSnapshotSchema = exports_zod.object({
+    name: exports_zod.string(),
+    description: exports_zod.string().optional(),
     definition: WorkflowDefinitionSchema,
-    triggers: array(TriggerConfigSchema),
+    triggers: exports_zod.array(TriggerConfigSchema),
     cooldown: CooldownConfigSchema.optional(),
-    input: record(string(), InputValueSchema).optional(),
-    triggerSchema: record(string(), unknown()).optional(),
-    dir: string().min(1).startsWith("/").optional(),
-    vcsRepo: string().min(1).optional(),
-    enabled: boolean()
-  });
-  WorkflowSchema = object({
-    id: string().uuid(),
+    input: exports_zod.record(exports_zod.string(), InputValueSchema).optional(),
+    triggerSchema: exports_zod.record(exports_zod.string(), exports_zod.unknown()).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: string(),
-    description: string().optional(),
-    enabled: boolean(),
+    name: exports_zod.string(),
+    description: exports_zod.string().optional(),
+    enabled: exports_zod.boolean(),
     definition: WorkflowDefinitionSchema,
-    triggers: array(TriggerConfigSchema).default([]),
+    triggers: exports_zod.array(TriggerConfigSchema).default([]),
     cooldown: CooldownConfigSchema.optional(),
-    input: record(string(), InputValueSchema).optional(),
-    triggerSchema: record(string(), unknown()).optional(),
-    dir: string().min(1).startsWith("/").optional(),
-    vcsRepo: string().min(1).optional(),
-    createdByAgentId: string().optional(),
-    createdAt: string(),
-    lastUpdatedAt: string(),
-    createdBy: string().optional(),
-    updatedBy: string().optional(),
-    favorite: boolean().optional()
-  });
-  WorkflowVersionSchema = object({
-    id: string().uuid(),
-    workflowId: string().uuid(),
-    version: number().int().min(1),
+    input: exports_zod.record(exports_zod.string(), InputValueSchema).optional(),
+    triggerSchema: exports_zod.record(exports_zod.string(), exports_zod.unknown()).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: string().optional(),
-    createdAt: string()
-  });
-  PageContentTypeSchema = _enum(["text/html", "application/json"]);
-  PageAuthModeSchema = _enum(["public", "authed", "password"]);
-  PageSnapshotSchema = object({
-    title: string(),
-    description: string().optional(),
+    changedByAgentId: exports_zod.string().optional(),
+    createdAt: exports_zod.string()
+  }).openapi("WorkflowVersion");
+  PageContentTypeSchema = exports_zod.enum(["text/html", "application/json"]);
+  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: string().optional(),
-    body: string(),
-    needsCredentials: array(string()).optional()
-  });
-  PageSchema = object({
-    id: string(),
+    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: string(),
-    slug: string(),
-    title: string(),
-    description: string().optional(),
+    agentId: exports_zod.string(),
+    slug: exports_zod.string(),
+    title: exports_zod.string(),
+    description: exports_zod.string().optional(),
     contentType: PageContentTypeSchema,
     authMode: PageAuthModeSchema,
-    passwordHash: string().optional(),
-    body: string(),
-    needsCredentials: array(string()).optional(),
-    viewCount: number().int().min(0).default(0),
-    createdAt: string(),
-    updatedAt: string(),
-    favorite: boolean().optional()
-  });
-  PageVersionSchema = object({
-    id: string(),
-    pageId: string(),
-    version: number().int().min(1),
+    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: string().optional(),
-    createdAt: string()
-  });
-  MetricParamSchema = union([string(), number(), boolean(), _null()]);
-  MetricVariableTypeSchema = _enum(["text", "number", "select"]);
-  MetricFormatSchema = _enum(["number", "integer", "currency", "percent", "duration"]);
-  MetricVisualizationSchema = _enum([
+    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",
@@ -1681,82 +3111,82 @@ var init_types = __esm(() => {
     "multi-bar",
     "multi-line"
   ]);
-  MetricQuerySchema = object({
-    sql: string().min(1).max(1e4),
-    params: array(MetricParamSchema).optional(),
-    maxRows: number().int().min(1).max(500).optional()
+  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 = object({
-    key: string().min(1).regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
-    label: string().min(1).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: array(object({
-      label: string().min(1),
+    options: exports_zod.array(exports_zod.object({
+      label: exports_zod.string().min(1),
       value: MetricParamSchema
     })).optional(),
-    optionsQuery: object({
-      sql: string().min(1).max(1e4),
-      valueKey: string().min(1),
-      labelKey: string().min(1).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()
-  });
-  MetricVizConfigSchema = object({
+  }).openapi("MetricVariable");
+  MetricVizConfigSchema = exports_zod.object({
     type: MetricVisualizationSchema,
-    x: string().optional(),
-    y: string().optional(),
-    series: array(string()).optional(),
-    label: string().optional(),
-    value: string().optional(),
-    columns: array(object({
-      key: string(),
-      label: string().optional(),
+    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()
-  });
-  MetricWidgetSchema = object({
-    id: string().min(1),
-    title: string().min(1),
-    description: string().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: number().int().min(1).max(4).optional(),
-    rowSpan: number().int().min(1).max(4).optional()
-  });
-  MetricDefinitionSchema = object({
-    version: literal(1),
-    widgets: array(MetricWidgetSchema).min(1).max(24),
-    variables: array(MetricVariableSchema).max(12).optional(),
-    layout: object({
-      columns: number().int().min(1).max(4).optional()
+    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: number().int().min(5).max(3600).optional()
-  });
-  MetricSnapshotSchema = object({
-    title: string(),
-    description: string().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
-  });
-  MetricSchema = object({
-    id: string(),
-    agentId: string(),
-    slug: string(),
-    title: string(),
-    description: string().optional(),
+  }).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: string(),
-    updatedAt: string()
-  });
-  MetricVersionSchema = object({
-    id: string(),
-    metricId: string(),
-    version: number().int().min(1),
+    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: string().optional(),
-    createdAt: string()
-  });
-  WorkflowRunStatusSchema = _enum([
+    changedByAgentId: exports_zod.string().optional(),
+    createdAt: exports_zod.string()
+  }).openapi("MetricVersion");
+  WorkflowRunStatusSchema = exports_zod.enum([
     "running",
     "waiting",
     "completed",
@@ -1764,18 +3194,18 @@ var init_types = __esm(() => {
     "skipped",
     "cancelled"
   ]);
-  WorkflowRunSchema = object({
-    id: string().uuid(),
-    workflowId: string().uuid(),
+  WorkflowRunSchema = exports_zod.object({
+    id: exports_zod.string().uuid(),
+    workflowId: exports_zod.string().uuid(),
     status: WorkflowRunStatusSchema,
-    triggerData: unknown().optional(),
-    context: record(string(), unknown()).optional(),
-    error: string().optional(),
-    startedAt: string(),
-    lastUpdatedAt: string(),
-    finishedAt: string().optional()
-  });
-  ScriptRunStatusSchema = _enum([
+    triggerData: exports_zod.unknown().optional(),
+    context: exports_zod.record(exports_zod.string(), exports_zod.unknown()).optional(),
+    error: 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",
@@ -1789,43 +3219,43 @@ var init_types = __esm(() => {
     "cancelled",
     "aborted_limit"
   ];
-  ScriptRunKindSchema = _enum(["workflow", "inline"]);
-  ScriptRunSchema = object({
-    id: string().uuid(),
-    agentId: string(),
-    scriptName: string().optional(),
-    source: string(),
-    args: unknown(),
+  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: number().int().optional(),
-    startedAt: string(),
-    finishedAt: string().optional(),
-    output: unknown().optional(),
-    error: string().optional(),
-    lastHeartbeatAt: string().optional(),
-    idempotencyKey: string().optional(),
-    requestedByUserId: string().optional()
-  });
+    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 = object({
-    id: string().uuid(),
-    runId: string().uuid(),
-    stepKey: string(),
-    stepType: string(),
-    config: record(string(), unknown()),
-    status: _enum(["completed", "failed"]),
-    result: unknown().optional(),
-    error: string().optional(),
-    startedAt: string(),
-    completedAt: string().optional(),
-    durationMs: number().optional()
-  });
-  WorkflowRunStepStatusSchema = _enum([
+  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",
@@ -1834,205 +3264,205 @@ var init_types = __esm(() => {
     "skipped",
     "cancelled"
   ]);
-  WorkflowRunStepSchema = object({
-    id: string().uuid(),
-    runId: string().uuid(),
-    nodeId: string(),
-    nodeType: string(),
+  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: unknown().optional(),
-    output: unknown().optional(),
-    error: string().optional(),
-    startedAt: string(),
-    finishedAt: string().optional(),
-    retryCount: number().int().min(0).default(0),
-    maxRetries: number().int().min(0).default(3),
-    nextRetryAt: string().optional(),
-    idempotencyKey: string().optional(),
-    diagnostics: string().optional(),
-    nextPort: string().optional()
-  });
-  WaitModeSchema = _enum(["time", "event"]);
-  WaitStateStatusSchema = _enum(["pending", "fired", "timeout"]);
-  WaitStateRowSchema = object({
-    id: string(),
-    workflowRunId: string(),
-    workflowRunStepId: string(),
+    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: string().nullable(),
-    eventName: string().nullable(),
-    eventFilter: union([record(string(), unknown()), string()]).nullable(),
-    expiresAt: string().nullable(),
+    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: unknown().nullable(),
-    resolvedAt: string().nullable(),
-    createdAt: string(),
-    updatedAt: string(),
-    eventScope: _enum(["run", "global"])
-  });
-  PromptTemplateScopeSchema = _enum(["global", "agent", "repo"]);
-  PromptTemplateStateSchema = _enum([
+    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 = object({
-    id: string(),
-    eventType: string(),
+  PromptTemplateSchema = exports_zod.object({
+    id: exports_zod.string(),
+    eventType: exports_zod.string(),
     scope: PromptTemplateScopeSchema,
-    scopeId: string().nullable(),
+    scopeId: exports_zod.string().nullable(),
     state: PromptTemplateStateSchema,
-    body: string(),
-    isDefault: boolean(),
-    version: number(),
-    createdBy: string().nullable(),
-    createdAt: string(),
-    updatedAt: string()
-  });
-  PromptTemplateHistorySchema = object({
-    id: string(),
-    templateId: string(),
-    version: number(),
-    body: string(),
-    state: string(),
-    changedBy: string().nullable(),
-    changedAt: string(),
-    changeReason: string().nullable()
-  });
-  ScriptScopeSchema = _enum(["global", "agent"]);
-  ScriptFsModeSchema = _enum(["none", "workspace-rw"]);
-  ScriptRecordSchema = object({
-    id: string(),
-    name: string(),
+    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: string().nullable(),
-    source: string(),
-    description: string(),
-    intent: string(),
-    signatureJson: string(),
-    argsJsonSchema: string().nullable(),
-    contentHash: string(),
-    version: number(),
-    isScratch: boolean(),
-    typeChecked: boolean(),
+    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: string().nullable(),
-    createdAt: string(),
-    updatedAt: string()
-  });
-  ScriptVersionRecordSchema = object({
-    id: string(),
-    scriptId: string(),
-    version: number(),
-    source: string(),
-    description: string(),
-    intent: string(),
-    signatureJson: string(),
-    contentHash: string(),
-    changedByAgentId: string().nullable(),
-    changedAt: string(),
-    changeReason: string().nullable()
-  });
-  ScriptApiAuthModeSchema = _enum(["none", "bearer"]);
-  ScriptApiRecordSchema = object({
-    id: string(),
-    scriptId: string(),
-    agentId: string(),
+    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");
+  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: boolean(),
-    label: string().nullable(),
-    callCount: number(),
-    lastUsedAt: string().nullable(),
-    createdAt: string()
-  });
-  SkillTypeSchema = _enum(["remote", "personal"]);
-  SkillScopeSchema = _enum(["global", "swarm", "agent"]);
-  SkillSchema = object({
-    id: string(),
-    name: string(),
-    description: string(),
-    content: string(),
+    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: string().nullable(),
-    sourceUrl: string().nullable(),
-    sourceRepo: string().nullable(),
-    sourcePath: string().nullable(),
-    sourceBranch: string(),
-    sourceHash: string().nullable(),
-    isComplex: boolean(),
-    allowedTools: string().nullable(),
-    model: string().nullable(),
-    effort: string().nullable(),
-    context: string().nullable(),
-    agent: string().nullable(),
-    disableModelInvocation: boolean(),
-    userInvocable: boolean(),
-    version: number(),
-    isEnabled: boolean(),
-    systemDefault: boolean(),
-    createdAt: string(),
-    lastUpdatedAt: string(),
-    lastFetchedAt: string().nullable()
-  });
-  AgentSkillSchema = object({
-    id: string(),
-    agentId: string(),
-    skillId: string(),
-    isActive: boolean(),
-    installedAt: string()
-  });
+    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: boolean(),
-    installedAt: string()
+    isActive: exports_zod.boolean(),
+    installedAt: exports_zod.string()
   });
-  SkillFileSchema = object({
-    id: string(),
-    skillId: string(),
-    path: string(),
-    content: string(),
-    mimeType: string(),
-    isBinary: boolean(),
-    size: number().nullable(),
-    createdAt: string(),
-    lastUpdatedAt: string()
-  });
-  McpServerTransportSchema = _enum(["stdio", "http", "sse"]);
-  McpServerScopeSchema = _enum(["global", "swarm", "agent"]);
-  McpAuthMethodSchema = _enum(["static", "oauth", "auto"]);
-  McpServerSchema = object({
-    id: string(),
-    name: string(),
-    description: string().nullable(),
+  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: string().nullable(),
+    ownerAgentId: exports_zod.string().nullable(),
     transport: McpServerTransportSchema,
-    command: string().nullable(),
-    args: string().nullable(),
-    url: string().nullable(),
-    headers: string().nullable(),
-    envConfigKeys: string().nullable(),
-    headerConfigKeys: string().nullable(),
-    extraAuthorizeParams: string().nullable(),
+    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: boolean(),
-    version: number(),
-    createdAt: string(),
-    lastUpdatedAt: string()
-  });
-  AgentMcpServerSchema = object({
-    id: string(),
-    agentId: string(),
-    mcpServerId: string(),
-    isActive: boolean(),
-    installedAt: string()
-  });
+    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: boolean(),
-    installedAt: string()
+    isActive: exports_zod.boolean(),
+    installedAt: exports_zod.string()
   });
-  ContextSnapshotEventTypeSchema = _enum(["progress", "compaction", "completion"]);
-  ContextFormulaSchema = _enum([
+  ContextSnapshotEventTypeSchema = exports_zod.enum(["progress", "compaction", "completion"]);
+  ContextFormulaSchema = exports_zod.enum([
     "input-cache-output",
     "input-cache-no-output",
     "input-output-no-cache",
@@ -2041,31 +3471,31 @@ var init_types = __esm(() => {
     "harness-reported",
     "unknown"
   ]);
-  ContextSnapshotSchema = object({
-    id: uuid(),
-    taskId: uuid(),
-    agentId: string(),
-    sessionId: string(),
-    contextUsedTokens: number().int().min(0).optional(),
-    contextTotalTokens: number().int().min(0).optional(),
-    contextPercent: number().min(0).max(100).optional(),
+  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: _enum(["auto", "manual", "auto-inferred"]).optional(),
-    preCompactTokens: number().int().min(0).optional(),
-    cumulativeInputTokens: number().int().min(0).default(0),
-    cumulativeOutputTokens: number().int().min(0).default(0),
+    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_iso.datetime()
-  });
-  BudgetScopeSchema = _enum(["global", "agent", "user"]);
-  BudgetSchema = object({
+    createdAt: exports_zod.iso.datetime()
+  }).openapi("ContextSnapshot");
+  BudgetScopeSchema = exports_zod.enum(["global", "agent", "user"]);
+  BudgetSchema = exports_zod.object({
     scope: BudgetScopeSchema,
-    scopeId: string(),
-    dailyBudgetUsd: number().nonnegative(),
-    createdAt: number(),
-    lastUpdatedAt: number()
-  });
-  PricingProviderSchema = _enum([
+    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",
@@ -2074,7 +3504,7 @@ var init_types = __esm(() => {
     "devin",
     "gemini"
   ]);
-  PricingTokenClassSchema = _enum([
+  PricingTokenClassSchema = exports_zod.enum([
     "input",
     "cached_input",
     "output",
@@ -2084,54 +3514,54 @@ var init_types = __esm(() => {
     "runtime_hour",
     "acu"
   ]);
-  PricingRowSchema = object({
+  PricingRowSchema = exports_zod.object({
     provider: PricingProviderSchema,
-    model: string(),
+    model: exports_zod.string(),
     tokenClass: PricingTokenClassSchema,
-    effectiveFrom: number().nonnegative(),
-    pricePerMillionUsd: number().nonnegative(),
-    createdAt: number(),
-    lastUpdatedAt: number()
-  });
-  BudgetRefusalCauseSchema = _enum(["agent", "global", "user"]);
-  BudgetRefusalNotificationSchema = object({
-    taskId: string(),
-    date: string(),
-    agentId: string(),
+    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: number().nullable().optional(),
-    agentBudgetUsd: number().nullable().optional(),
-    globalSpendUsd: number().nullable().optional(),
-    globalBudgetUsd: number().nullable().optional(),
-    userSpendUsd: number().nullable().optional(),
-    userBudgetUsd: number().nullable().optional(),
-    followUpTaskId: string().nullable().optional(),
-    createdAt: number()
-  });
-  BudgetRefusedTriggerSchema = object({
-    type: literal("budget_refused"),
+    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: number().optional(),
-    agentBudget: number().optional(),
-    globalSpend: number().optional(),
-    globalBudget: number().optional(),
-    userSpend: number().optional(),
-    userBudget: number().optional(),
-    resetAt: string()
-  });
-  KvValueTypeSchema = _enum(["json", "string", "integer"]);
+    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 = string().min(1).max(512).regex(KV_NAME_REGEX, "namespace must match [a-zA-Z0-9._:/%-]{1,512}");
-  KvKeySchema = string().min(1).max(512).regex(KV_NAME_REGEX, "key must match [a-zA-Z0-9._:/%-]{1,512}");
-  KvEntrySchema = object({
-    namespace: string(),
-    key: string(),
-    value: unknown(),
+  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: number().int().nullable(),
-    createdAt: number().int(),
-    updatedAt: number().int()
-  });
+    expiresAt: exports_zod.number().int().nullable(),
+    createdAt: exports_zod.number().int(),
+    updatedAt: exports_zod.number().int()
+  }).openapi("KvEntry");
 });
 
 // src/utils/request-auth-context.ts
@@ -2299,6 +3729,8 @@ var init_asset_key_audit = __esm(() => {
     { entityType: "workflow", sql: 'SELECT id, "key" as key FROM workflows' },
     { entityType: "schedule", sql: 'SELECT id, "key" as key FROM scheduled_tasks' },
     { entityType: "page", sql: 'SELECT id, "key" as key FROM pages' },
+    { entityType: "app", sql: 'SELECT id, "key" as key FROM apps' },
+    { entityType: "script", sql: 'SELECT id, "key" as key FROM scripts' },
     { entityType: "file", sql: 'SELECT id, "key" as key FROM asset_key_mappings' }
   ];
 });
@@ -4912,8 +6344,8 @@ function ensureSlackRenderV2Activation() {
     throw new Error("Failed to persist Slack render v2 activation");
   return persisted;
 }
-function isPendingSlackMessage(record2) {
-  return record2.ts.startsWith(PENDING_SLACK_MESSAGE_TS_PREFIX);
+function isPendingSlackMessage(record) {
+  return record.ts.startsWith(PENDING_SLACK_MESSAGE_TS_PREFIX);
 }
 function rowToSlackMessage(row) {
   return {
@@ -6169,6 +7601,18 @@ function assetSummaryQueries(types) {
               NULL AS providerDriveId, NULL AS providerKey
        FROM pages`);
   }
+  if (types.has("app")) {
+    queries.push(`SELECT 'app' AS entityType, id, "key", name AS label,
+              updated_at AS updatedAt, NULL AS providerId, NULL AS providerOrgId,
+              NULL AS providerDriveId, NULL AS providerKey
+       FROM apps`);
+  }
+  if (types.has("script")) {
+    queries.push(`SELECT 'script' AS entityType, id, "key", name AS label,
+              updatedAt, NULL AS providerId, NULL AS providerOrgId,
+              NULL AS providerDriveId, NULL AS providerKey
+       FROM scripts`);
+  }
   if (types.has("file")) {
     queries.push(`SELECT 'file' AS entityType, id, "key", provider_key AS label,
               updated_at AS updatedAt, provider_id AS providerId,
@@ -6180,7 +7624,7 @@ function assetSummaryQueries(types) {
   return queries;
 }
 function listAssetSummaries(filters) {
-  const requestedTypes = new Set(filters?.types?.length ? filters.types : ["task", "workflow", "schedule", "page", "file"]);
+  const requestedTypes = new Set(filters?.types?.length ? filters.types : ["task", "workflow", "schedule", "page", "app", "script", "file"]);
   const queries = assetSummaryQueries(requestedTypes);
   if (queries.length === 0)
     return [];
@@ -6218,6 +7662,10 @@ function currentAssetKey(entityType, id) {
       return getDb().prepare('SELECT "key" AS key FROM scheduled_tasks WHERE id = ?').get(id)?.key ?? null;
     case "page":
       return getDb().prepare('SELECT "key" AS key FROM pages WHERE id = ?').get(id)?.key ?? null;
+    case "app":
+      return getDb().prepare('SELECT "key" AS key FROM apps WHERE id = ?').get(id)?.key ?? null;
+    case "script":
+      return getDb().prepare('SELECT "key" AS key FROM scripts WHERE id = ?').get(id)?.key ?? null;
     case "file":
       return getAssetKeyMapping(id)?.key ?? null;
   }
@@ -6289,6 +7737,17 @@ function moveAssetKey(input) {
           input.id
         ]);
         break;
+      case "app":
+        getDb().run('UPDATE apps SET "key" = ?, updated_at = ? WHERE id = ?', [key, now, input.id]);
+        break;
+      case "script":
+        getDb().run('UPDATE scripts SET "key" = ?, updatedAt = ?, updated_by = ? WHERE id = ?', [
+          key,
+          now,
+          input.changedBy ?? null,
+          input.id
+        ]);
+        break;
       case "file":
         getDb().run('UPDATE asset_key_mappings SET "key" = ?, updated_at = ?, updated_by = ? WHERE id = ?', [key, now, input.changedBy ?? null, input.id]);
         break;
@@ -11473,4 +12932,4 @@ var init_db = __esm(() => {
   };
 });
 
-export { normalizeAssetKey, parseAssetKey, canWriteAssetKey, init_key, slackContextKey, agentmailContextKey, githubContextKey, gitlabContextKey, linearContextKey, buildJiraContextKey, scheduleContextKey, workflowContextKey, agentContextKey, pageContextKey, init_context_key, checkSlackRoutingCoherence, init_slack_routing, initTelemetry, telemetry, init_telemetry, AssetKeySchema, AssetEntityTypeSchema, ModelTierSchema, ReasoningEffortSchema, splitLegacyModelAlias, resolveTaskModelSelection, AgentTaskStatusSchema, isTerminalTaskStatus, AgentTaskSourceSchema, ProviderNameSchema, SteerModeSchema, SteeringSourceSchema, SteerOutcomeSchema, OnUnsupportedSchema, FollowUpConfigSchema, AttachmentInputSchema, InboxItemTypeSchema, InboxItemStatusSchema, FavoriteItemTypeSchema, TaskTemplateKindSchema, AgentStatusSchema, AgentAvatarSchema, AgentLatestModelSchema, AgentCredStatusSchema, ChannelTypeSchema, ServiceStatusSchema, ResumeReasonSchema, SessionCostModelBreakdownSchema, EventCategorySchema, EventStatusSchema, EventSourceSchema, EventNameSchema, ScheduledTaskTargetTypeSchema, SwarmConfigScopeSchema, RepoGuidelinesSchema, RepoHooksSchema, SwarmRepoSchema, AgentMemoryScopeSchema, AgentMemorySourceSchema, WorkflowDefinitionSchema, WorkflowNodePatchSchema, WorkflowPatchSchema, TriggerConfigSchema, CooldownConfigSchema, InputValueSchema, PageContentTypeSchema, PageAuthModeSchema, MetricDefinitionSchema, MetricVersionSchema, WorkflowRunStatusSchema, ScriptRunStatusSchema, TERMINAL_SCRIPT_RUN_STATUSES, PromptTemplateScopeSchema, PromptTemplateStateSchema, ScriptScopeSchema, ScriptFsModeSchema, ScriptApiAuthModeSchema, ContextSnapshotEventTypeSchema, ContextFormulaSchema, BudgetScopeSchema, BudgetSchema, PricingProviderSchema, PricingTokenClassSchema, PricingRowSchema, BudgetRefusalCauseSchema, BudgetRefusalNotificationSchema, KvValueTypeSchema, KvNamespaceSchema, KvKeySchema, init_types, setRequestAuth, getRequestAuth, getCurrentRequestAuth, init_request_auth_context, auditAssetKeys, init_asset_key_audit, CredentialBindingSchema, placeholderForConfigKey, CredentialBroker, DEFAULT_CREDENTIAL_BINDINGS, init_credential_broker, encryptSecret, decryptSecret, getEncryptionKey, init_crypto, normalizeDate, normalizeDateRequired, init_date_utils, init_templates, init_templates2 as init_templates1, SteeringRequestError, isSteeringEnabled2 as isSteeringEnabled, getTaskSteeringFields, promotePendingSteeringForTask, markSteeringUndeliverable, requestSteering, init_steering, isReservedConfigKey, reservedKeyError, validateConfigValue, init_swarm_config_guard, onTaskStarted, init_task_lifecycle_events, generateDefaultClaudeMd, generateDefaultSoulMd, generateDefaultIdentityMd, generateDefaultToolsMd, init_defaults, isSqliteVecAvailable, initDb, getDb, closeDb, computeContentHash, createContextVersion, getLatestContextVersion, getContextVersion, getContextVersionHistory, agentQueries, updateAgentCredentialState, createAgent, getAgentById, getAllAgents, getLeadAgent, updateAgentStatus, updateAgentMaxTasks, updateAgentProvider, setAgentHarnessProvider, updateAgentCredStatus, listAgentsWithCredStatusByProvider, getAgentHarnessProviders, updateAgentActivity, MAX_EMPTY_POLLS, incrementEmptyPollCount, resetEmptyPollCount, shouldBlockPolling, deleteAgent, getActiveTaskCount, hasCapacity, getRemainingCapacity, updateAgentStatusFromCapacity, isPoolAffinityEnforcementEnabled, buildRoutingAffinityFromAgent, isAgentEligibleForTask, taskQueries, createTask, getPendingTaskForAgent, assignUnassignedTaskPending, startTask, getTaskById, getSlackRenderV2ActivatedAt, ensureSlackRenderV2Activation, isPendingSlackMessage, recordSlackMessage, reserveSlackMessage, bindSlackMessageTimestamp, updateSlackMessageRecord, markSlackTreeRendered, deleteSlackMessageRecord, getSlackTreeMessage, getSlackTreeMessageByThread, getSlackOutcomeMessage, getSlackTreeMessages, getSlackMessageByChannelTs, getSlackTasksInThread, markTaskSlackReplySent, setSlackMessageTracking, getChildTasks, hasNonTerminalResumeChild, hasNonTerminalRerouteDecisionChild, updateTaskClaudeSessionId, updateTaskTitle, updateTaskVcs, getTasksByAgentId, getAgentCurrentTask, getTasksByStatus, findTaskByVcs, findTaskByGitHub, getAllTasks, getTasksCount, getTaskStats, getCompletedSlackTasks, getRecentlyFinishedWorkerTasks, markTasksNotified, resetTasksNotified, getInProgressSlackTasks, getSlackTasksMissingTree, getInProgressTasksByContextKey, findExistingLinearTrackerContextWork, getLatestTaskByContextKey, getLatestScriptRunStepTaskByContextKey, getAgentWorkingOnThread, getLatestActiveTaskInThread, getLatestLeadTaskInThread, getMostRecentTaskInThread, findCompletedTaskInThread, findRecentCancelledTaskInThread, completeTask, failTask, overwriteTerminalTaskResultText, cancelTask, supersedeTask, backfillSupersedeTaskResumeTaskId, pauseTask, resumeTask, getPausedTasksForAgent, getOrphanedInProgressTasksForAgent, resetOrphanedInProgressTasksForAgent, getRecentlyCancelledTasksForAgent, deleteTask, updateTaskProgress, insertTaskAttachment, getAssetKeyMappingByProvider, upsertAssetKeyMapping, getAssetKeyMapping, listAssetSummaries, moveAssetKey, deleteTaskAttachment, replaceTaskAttachment, getTaskAttachments, createSteeringMessage, getSteeringMessagesForTask, getSteeringMessageById, getPendingSteeringForTask, getPendingSteeringForAgent, markSteeringDelivered, markSteeringHandled, markSteeringPromoted, cancelPendingSteeringForTask, hasPendingSteering, getAgentWithTasks, getAllAgentsWithTasks, logQueries, createLogEntry, getLogsByAgentId, getLogsByTaskId, getLogsByTaskIdChronological, getLogsByEventType, getAllLogs, findRecentSimilarTasks, createTaskExtended, claimTask, releaseTask, acceptTask, rejectTask, moveTaskToBacklog, moveTaskFromBacklog, releaseStaleReviewingTasks, getOfferedTasksForAgent, claimOfferedTask, getUnassignedTasksCount, getUnassignedTaskIds, getUnassignedTaskIdsForAgent, checkDependencies, getDependentTasks, cascadeFailDependents, updateAgentProfile, updateAgentName, createChannel, getMessageById, getChannelById, getChannelByName, getAllChannels, deleteChannel, postMessage, getChannelMessages, updateReadState, getLastReadAt, getUnreadMessages, getMentionsForAgent, getInboxSummary, claimMentions, releaseMentionProcessing, releaseStaleMentionProcessing, createService, getServiceById, getServiceByAgentAndName, getServicesByAgentId, getAllServices, updateServiceStatus, deleteService, upsertService, deleteServicesByAgentId, sessionLogQueries, createSessionLogs, getSessionLogsByTaskId, getSessionLogsBySession, createSessionCost, getSessionCostsByTaskId, getSessionCostsByAgentId, getAllSessionCosts, getSessionCostsFiltered, UNATTRIBUTED_USER_ID, getSessionCostSummary, getDashboardCostSummary, createInboxMessage, getInboxMessageById, getUnreadInboxMessages, claimInboxMessages, markInboxMessageRead, markInboxMessageResponded, markInboxMessageDelegated, releaseStaleProcessingInbox, getConcurrentContext, getScheduledTasks, getScheduledTaskById, getScheduledTaskByName, createScheduledTask, updateScheduledTask, deleteScheduledTask, getDueScheduledTasks, autoEncryptLegacyPlaintextSecrets, maskSecrets, getSwarmConfigs, getInjectableGlobalConfigs, getSwarmConfigById, getSwarmConfigLookupById, upsertSwarmConfig, deleteSwarmConfig, deleteSwarmConfigByKey, getResolvedConfig, getSwarmRepos, getSwarmRepoById, getSwarmRepoByName, getSwarmRepoByUrl, createSwarmRepo, updateSwarmRepo, deleteSwarmRepo, getAgentMailInboxMapping, getAgentMailInboxMappingsByAgent, getAllAgentMailInboxMappings, createAgentMailInboxMapping, deleteAgentMailInboxMapping, findTaskByAgentMailThread, insertActiveSession, deleteActiveSession, deleteActiveSessionById, getActiveSessions, heartbeatActiveSession, cleanupStaleSessions, cleanupAgentSessions, updateActiveSessionProviderSessionId, getActiveSessionForTask, reassociateSessionLogs, getStalledInProgressTasks, getStalePinnedResumes, failPendingResumeIfUnclaimed, getIdleWorkersWithCapacity, getUnassignedPoolTasks, getStaleUnassignedAffinityTasks, getRecentFailedTasks, getRecentCompletedCount, getRecentFailedCount, createWorkflow, getWorkflow, listWorkflows, updateWorkflow, deleteWorkflow, getWorkflowsByScheduleId, createWorkflowRun, getWorkflowRun, updateWorkflowRun, listWorkflowRuns, countWorkflowRuns, listWorkflowRunsPage, createWorkflowRunStep, getWorkflowRunStep, updateWorkflowRunStep, getWorkflowRunStepsByRunId, getStuckWorkflowRuns, getLastSuccessfulRun, getLastRunStart, getRetryableSteps, getCompletedStepNodeIds, getTaskByWorkflowRunStepId, detachTaskFromWorkflowRunStep, getStepByIdempotencyKey, getStepCountForNode, getLatestStepForNode, createWorkflowVersion, getWorkflowVersions, getWorkflowVersion, createAppVersion, getAppVersions, getAppVersion, createPage, getPage, getPageBySlug, getLatestPageBySlug, listPagesByAgent, listAllPages, countAllPages, countPagesByAgent, updatePage, deletePage, incrementPageViewCount, createPageVersion, getPageVersions, getPageVersion, createMetric, getMetric, getMetricBySlug, listMetricsByAgent, listAllMetrics, countAllMetrics, countMetricsByAgent, updateMetric, deleteMetric, createMetricVersion, getMetricVersions, getMetricVersion, getPromptTemplates, getPromptTemplateById, upsertPromptTemplate, deletePromptTemplate, resetPromptTemplateToDefault, getPromptTemplateHistory, resolvePromptTemplate, checkoutPromptTemplate, getAllChannelActivityCursors, getChannelActivityCursor, upsertChannelActivityCursor, createApprovalRequest, getApprovalRequestById, resolveApprovalRequest, updateApprovalRequestNotifications, listApprovalRequests, getStuckApprovalRuns, getApprovalRequestByStepId, getExpiredPendingApprovals, createWaitState, getWaitStateById, getWaitStateByStepId, getDueWaitStates, getPendingEventWaitNames, getPendingWaitsByEvent, resolveWaitState, getStuckWaitRuns, SKILL_FILE_LIMITS, normalizeSkillFilePath, createSkill, updateSkill, listSkillFileManifest, getSkillFiles, getSkillFile, upsertSkillFile, upsertSkillFiles, deleteSkillFile, deleteSkill, getSkillById, getSkillByName, listSkills, searchSkills, installSkill, getSystemDefaultSkills, installSystemDefaultSkillsForAgent, uninstallSkill, getAgentSkills, toggleAgentSkill, createMcpServer, updateMcpServer, deleteMcpServer, getMcpServerById, getMcpServerByName, listMcpServers, installMcpServer, uninstallMcpServer, getAgentMcpServers, createContextSnapshot, getContextSnapshotsByTaskId, getContextSnapshotsBySessionId, getContextSummaryByTaskId, getAvailableKeyIndices, recordKeyUsage, markKeyRateLimited, recordKeyRateLimitWindows, setApiKeyName, clearKeyRateLimit, getKeyStatuses, getKeyCostSummary, getUserById, getAllUsers, createUser, updateUser, deleteUser, listInboxState, upsertInboxState, listFavorites, listUserFavorites, getFavoriteItemIdSet, setFavorite, setUserFavorite, withFavoriteFlags, listTaskTemplates, getRootTaskChain, listRecentSessions, countSessions, getBudget, getBudgets, upsertBudget, deleteBudget, getAllPricingRows, getPricingRows, getActivePricingRow, insertPricingRow, deletePricingRow, getDailySpendForAgent, getDailySpendGlobal, getDailySpendForUser, recordBudgetRefusalNotification, getBudgetRefusalNotification, getRecentBudgetRefusalNotifications, hasBudgetRefusalNotificationToday, setBudgetRefusalFollowUpTaskId, getLiveAgentCounts, getInstanceActivity, getSwarmMetrics, hasFirstCompletedTask, getKv, sweepExpiredKv, sweepExpiredKvPrefix, upsertKv, deleteKv, KvTypeCollisionError, incrKv, listKv, countKv, createScriptRun, recordInlineScriptRun, getScriptRun, getScriptRunByIdempotencyKey, listScriptRuns, countScriptRuns, countActiveScriptRuns, updateScriptRun, getRunningScriptRuns, getScriptRunJournalStep, upsertScriptRunJournalStep, listScriptRunJournalSteps, countScriptRunJournalSteps, countScriptRunJournalAgentTaskSteps, exports_db, init_db };
+export { normalizeAssetKey, defaultAssetKey, parseAssetKey, canWriteAssetKey, init_key, slackContextKey, agentmailContextKey, githubContextKey, gitlabContextKey, linearContextKey, buildJiraContextKey, scheduleContextKey, workflowContextKey, agentContextKey, pageContextKey, init_context_key, checkSlackRoutingCoherence, init_slack_routing, initTelemetry, telemetry, init_telemetry, $OpenAPIRegistry, $OpenApiGeneratorV31, init_dist, init_zod_openapi, AssetKeySchema, AssetEntityTypeSchema, AssetKeyMappingSchema, AssetSummarySchema, ModelTierSchema, ReasoningEffortSchema, splitLegacyModelAlias, resolveTaskModelSelection, AgentTaskStatusSchema, isTerminalTaskStatus, AgentTaskSourceSchema, ProviderNameSchema, SteerModeSchema, SteeringSourceSchema, SteeringMessageSchema, SteerOutcomeSchema, OnUnsupportedSchema, SteerResultSchema, FollowUpConfigSchema, AgentTaskSchema, AttachmentInputSchema, TaskAttachmentSchema, UserSchema, InboxItemTypeSchema, InboxItemStatusSchema, InboxItemStateSchema, FavoriteItemTypeSchema, UserFavoriteSchema, TaskTemplateKindSchema, TaskTemplateSchema, AgentStatusSchema, AgentAvatarSchema, AgentSchema, AgentLatestModelSchema, AgentCredStatusSchema, AgentWithTasksSchema, ChannelTypeSchema, ServiceStatusSchema, ServiceSchema, ResumeReasonSchema, AgentLogSchema, SessionLogSchema, SessionCostModelBreakdownSchema, SessionCostSchema, EventCategorySchema, EventStatusSchema, EventSourceSchema, EventNameSchema, SwarmEventSchema, ScheduledTaskTargetTypeSchema, ScheduledTaskSchema, SwarmConfigScopeSchema, SwarmConfigSchema, RepoGuidelinesSchema, RepoHooksSchema, SwarmRepoSchema, AgentMemoryScopeSchema, AgentMemorySourceSchema, AgentMemorySchema, ActiveSessionSchema, 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, 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, setRequestAuth, getRequestAuth, getCurrentRequestAuth, init_request_auth_context, auditAssetKeys, init_asset_key_audit, CredentialBindingSchema, placeholderForConfigKey, CredentialBroker, DEFAULT_CREDENTIAL_BINDINGS, init_credential_broker, encryptSecret, decryptSecret, getEncryptionKey, init_crypto, normalizeDate, normalizeDateRequired, init_date_utils, init_templates, init_templates2 as init_templates1, SteeringRequestError, isSteeringEnabled2 as isSteeringEnabled, getTaskSteeringFields, promotePendingSteeringForTask, markSteeringUndeliverable, requestSteering, init_steering, isReservedConfigKey, reservedKeyError, validateConfigValue, init_swarm_config_guard, onTaskStarted, init_task_lifecycle_events, generateDefaultClaudeMd, generateDefaultSoulMd, generateDefaultIdentityMd, generateDefaultToolsMd, init_defaults, isSqliteVecAvailable, initDb, getDb, closeDb, computeContentHash, createContextVersion, getLatestContextVersion, getContextVersion, getContextVersionHistory, agentQueries, updateAgentCredentialState, createAgent, getAgentById, getAllAgents, getLeadAgent, updateAgentStatus, updateAgentMaxTasks, updateAgentProvider, setAgentHarnessProvider, updateAgentCredStatus, listAgentsWithCredStatusByProvider, getAgentHarnessProviders, updateAgentActivity, MAX_EMPTY_POLLS, incrementEmptyPollCount, resetEmptyPollCount, shouldBlockPolling, deleteAgent, getActiveTaskCount, hasCapacity, getRemainingCapacity, updateAgentStatusFromCapacity, isPoolAffinityEnforcementEnabled, buildRoutingAffinityFromAgent, isAgentEligibleForTask, taskQueries, createTask, getPendingTaskForAgent, assignUnassignedTaskPending, startTask, getTaskById, getSlackRenderV2ActivatedAt, ensureSlackRenderV2Activation, isPendingSlackMessage, recordSlackMessage, reserveSlackMessage, bindSlackMessageTimestamp, updateSlackMessageRecord, markSlackTreeRendered, deleteSlackMessageRecord, getSlackTreeMessage, getSlackTreeMessageByThread, getSlackOutcomeMessage, getSlackTreeMessages, getSlackMessageByChannelTs, getSlackTasksInThread, markTaskSlackReplySent, setSlackMessageTracking, getChildTasks, hasNonTerminalResumeChild, hasNonTerminalRerouteDecisionChild, updateTaskClaudeSessionId, updateTaskTitle, updateTaskVcs, getTasksByAgentId, getAgentCurrentTask, getTasksByStatus, findTaskByVcs, findTaskByGitHub, getAllTasks, getTasksCount, getTaskStats, getCompletedSlackTasks, getRecentlyFinishedWorkerTasks, markTasksNotified, resetTasksNotified, getInProgressSlackTasks, getSlackTasksMissingTree, getInProgressTasksByContextKey, findExistingLinearTrackerContextWork, getLatestTaskByContextKey, getLatestScriptRunStepTaskByContextKey, getAgentWorkingOnThread, getLatestActiveTaskInThread, getLatestLeadTaskInThread, getMostRecentTaskInThread, findCompletedTaskInThread, findRecentCancelledTaskInThread, completeTask, failTask, overwriteTerminalTaskResultText, cancelTask, supersedeTask, backfillSupersedeTaskResumeTaskId, pauseTask, resumeTask, getPausedTasksForAgent, getOrphanedInProgressTasksForAgent, resetOrphanedInProgressTasksForAgent, getRecentlyCancelledTasksForAgent, deleteTask, updateTaskProgress, insertTaskAttachment, getAssetKeyMappingByProvider, upsertAssetKeyMapping, getAssetKeyMapping, listAssetSummaries, moveAssetKey, deleteTaskAttachment, replaceTaskAttachment, getTaskAttachments, createSteeringMessage, getSteeringMessagesForTask, getSteeringMessageById, getPendingSteeringForTask, getPendingSteeringForAgent, markSteeringDelivered, markSteeringHandled, markSteeringPromoted, cancelPendingSteeringForTask, hasPendingSteering, getAgentWithTasks, getAllAgentsWithTasks, logQueries, createLogEntry, getLogsByAgentId, getLogsByTaskId, getLogsByTaskIdChronological, getLogsByEventType, getAllLogs, findRecentSimilarTasks, createTaskExtended, claimTask, releaseTask, acceptTask, rejectTask, moveTaskToBacklog, moveTaskFromBacklog, releaseStaleReviewingTasks, getOfferedTasksForAgent, claimOfferedTask, getUnassignedTasksCount, getUnassignedTaskIds, getUnassignedTaskIdsForAgent, checkDependencies, getDependentTasks, cascadeFailDependents, updateAgentProfile, updateAgentName, createChannel, getMessageById, getChannelById, getChannelByName, getAllChannels, deleteChannel, postMessage, getChannelMessages, updateReadState, getLastReadAt, getUnreadMessages, getMentionsForAgent, getInboxSummary, claimMentions, releaseMentionProcessing, releaseStaleMentionProcessing, createService, getServiceById, getServiceByAgentAndName, getServicesByAgentId, getAllServices, updateServiceStatus, deleteService, upsertService, deleteServicesByAgentId, sessionLogQueries, createSessionLogs, getSessionLogsByTaskId, getSessionLogsBySession, createSessionCost, getSessionCostsByTaskId, getSessionCostsByAgentId, getAllSessionCosts, getSessionCostsFiltered, UNATTRIBUTED_USER_ID, getSessionCostSummary, getDashboardCostSummary, createInboxMessage, getInboxMessageById, getUnreadInboxMessages, claimInboxMessages, markInboxMessageRead, markInboxMessageResponded, markInboxMessageDelegated, releaseStaleProcessingInbox, getConcurrentContext, getScheduledTasks, getScheduledTaskById, getScheduledTaskByName, createScheduledTask, updateScheduledTask, deleteScheduledTask, getDueScheduledTasks, autoEncryptLegacyPlaintextSecrets, maskSecrets, getSwarmConfigs, getInjectableGlobalConfigs, getSwarmConfigById, getSwarmConfigLookupById, upsertSwarmConfig, deleteSwarmConfig, deleteSwarmConfigByKey, getResolvedConfig, getSwarmRepos, getSwarmRepoById, getSwarmRepoByName, getSwarmRepoByUrl, createSwarmRepo, updateSwarmRepo, deleteSwarmRepo, getAgentMailInboxMapping, getAgentMailInboxMappingsByAgent, getAllAgentMailInboxMappings, createAgentMailInboxMapping, deleteAgentMailInboxMapping, findTaskByAgentMailThread, insertActiveSession, deleteActiveSession, deleteActiveSessionById, getActiveSessions, heartbeatActiveSession, cleanupStaleSessions, cleanupAgentSessions, updateActiveSessionProviderSessionId, getActiveSessionForTask, reassociateSessionLogs, getStalledInProgressTasks, getStalePinnedResumes, failPendingResumeIfUnclaimed, getIdleWorkersWithCapacity, getUnassignedPoolTasks, getStaleUnassignedAffinityTasks, getRecentFailedTasks, getRecentCompletedCount, getRecentFailedCount, createWorkflow, getWorkflow, listWorkflows, updateWorkflow, deleteWorkflow, getWorkflowsByScheduleId, createWorkflowRun, getWorkflowRun, updateWorkflowRun, listWorkflowRuns, countWorkflowRuns, listWorkflowRunsPage, createWorkflowRunStep, getWorkflowRunStep, updateWorkflowRunStep, getWorkflowRunStepsByRunId, getStuckWorkflowRuns, getLastSuccessfulRun, getLastRunStart, getRetryableSteps, getCompletedStepNodeIds, getTaskByWorkflowRunStepId, detachTaskFromWorkflowRunStep, getStepByIdempotencyKey, getStepCountForNode, getLatestStepForNode, createWorkflowVersion, getWorkflowVersions, getWorkflowVersion, createAppVersion, getAppVersions, getAppVersion, createPage, getPage, getPageBySlug, getLatestPageBySlug, listPagesByAgent, listAllPages, countAllPages, countPagesByAgent, updatePage, deletePage, incrementPageViewCount, createPageVersion, getPageVersions, getPageVersion, createMetric, getMetric, getMetricBySlug, listMetricsByAgent, listAllMetrics, countAllMetrics, countMetricsByAgent, updateMetric, deleteMetric, createMetricVersion, getMetricVersions, getMetricVersion, getPromptTemplates, getPromptTemplateById, upsertPromptTemplate, deletePromptTemplate, resetPromptTemplateToDefault, getPromptTemplateHistory, resolvePromptTemplate, checkoutPromptTemplate, getAllChannelActivityCursors, getChannelActivityCursor, upsertChannelActivityCursor, createApprovalRequest, getApprovalRequestById, resolveApprovalRequest, updateApprovalRequestNotifications, listApprovalRequests, getStuckApprovalRuns, getApprovalRequestByStepId, getExpiredPendingApprovals, createWaitState, getWaitStateById, getWaitStateByStepId, getDueWaitStates, getPendingEventWaitNames, getPendingWaitsByEvent, resolveWaitState, getStuckWaitRuns, SKILL_FILE_LIMITS, normalizeSkillFilePath, createSkill, updateSkill, listSkillFileManifest, getSkillFiles, getSkillFile, upsertSkillFile, upsertSkillFiles, deleteSkillFile, deleteSkill, getSkillById, getSkillByName, listSkills, searchSkills, installSkill, getSystemDefaultSkills, installSystemDefaultSkillsForAgent, uninstallSkill, getAgentSkills, toggleAgentSkill, createMcpServer, updateMcpServer, deleteMcpServer, getMcpServerById, getMcpServerByName, listMcpServers, installMcpServer, uninstallMcpServer, getAgentMcpServers, createContextSnapshot, getContextSnapshotsByTaskId, getContextSnapshotsBySessionId, getContextSummaryByTaskId, getAvailableKeyIndices, recordKeyUsage, markKeyRateLimited, recordKeyRateLimitWindows, setApiKeyName, clearKeyRateLimit, getKeyStatuses, getKeyCostSummary, getUserById, getAllUsers, createUser, updateUser, deleteUser, listInboxState, upsertInboxState, listFavorites, listUserFavorites, getFavoriteItemIdSet, setFavorite, setUserFavorite, withFavoriteFlags, listTaskTemplates, getRootTaskChain, listRecentSessions, countSessions, getBudget, getBudgets, upsertBudget, deleteBudget, getAllPricingRows, getPricingRows, getActivePricingRow, insertPricingRow, deletePricingRow, getDailySpendForAgent, getDailySpendGlobal, getDailySpendForUser, recordBudgetRefusalNotification, getBudgetRefusalNotification, getRecentBudgetRefusalNotifications, hasBudgetRefusalNotificationToday, setBudgetRefusalFollowUpTaskId, getLiveAgentCounts, getInstanceActivity, getSwarmMetrics, hasFirstCompletedTask, getKv, sweepExpiredKv, sweepExpiredKvPrefix, upsertKv, deleteKv, KvTypeCollisionError, incrKv, listKv, countKv, createScriptRun, recordInlineScriptRun, getScriptRun, getScriptRunByIdempotencyKey, listScriptRuns, countScriptRuns, countActiveScriptRuns, updateScriptRun, getRunningScriptRuns, getScriptRunJournalStep, upsertScriptRunJournalStep, listScriptRunJournalSteps, countScriptRunJournalSteps, countScriptRunJournalAgentTaskSteps, exports_db, init_db };