@inkeep/agents-core 0.36.0 → 0.37.0

package/dist/auth/auth-validation-schemas.js

@@ -1,6 +1,6 @@
 import { user, session, account, organization, member, invitation, verification } from '../chunk-NOPEANIU.js';
+import { external_exports } from '../chunk-OUXC23J7.js';
 import { createSelectSchema, createInsertSchema } from 'drizzle-zod';
-import { z } from 'zod';
 
 var UserSelectSchema = createSelectSchema(user);
 var UserInsertSchema = createInsertSchema(user);
@@ -16,24 +16,24 @@ var InvitationSelectSchema = createSelectSchema(invitation);
 var InvitationInsertSchema = createInsertSchema(invitation);
 var VerificationSelectSchema = createSelectSchema(verification);
 var VerificationInsertSchema = createInsertSchema(verification);
-var UserOrganizationSchema = z.object({
-  id: z.string(),
-  userId: z.string(),
-  organizationId: z.string(),
-  role: z.string(),
-  createdAt: z.union([z.string(), z.date()]).transform((val) => val instanceof Date ? val.toISOString() : val),
-  organizationName: z.string().nullable(),
-  organizationSlug: z.string().nullable()
+var UserOrganizationSchema = external_exports.object({
+  id: external_exports.string(),
+  userId: external_exports.string(),
+  organizationId: external_exports.string(),
+  role: external_exports.string(),
+  createdAt: external_exports.union([external_exports.string(), external_exports.date()]).transform((val) => val instanceof Date ? val.toISOString() : val),
+  organizationName: external_exports.string().nullable(),
+  organizationSlug: external_exports.string().nullable()
 });
-var UserOrganizationsResponseSchema = z.array(UserOrganizationSchema);
-var AddUserToOrganizationRequestSchema = z.object({
-  organizationId: z.string(),
-  role: z.string().default("member")
+var UserOrganizationsResponseSchema = external_exports.array(UserOrganizationSchema);
+var AddUserToOrganizationRequestSchema = external_exports.object({
+  organizationId: external_exports.string(),
+  role: external_exports.string().default("member")
 });
-var AddUserToOrganizationResponseSchema = z.object({
-  organizationId: z.string(),
-  role: z.string(),
-  createdAt: z.string()
+var AddUserToOrganizationResponseSchema = external_exports.object({
+  organizationId: external_exports.string(),
+  role: external_exports.string(),
+  createdAt: external_exports.string()
 });
 
 export { AccountInsertSchema, AccountSelectSchema, AddUserToOrganizationRequestSchema, AddUserToOrganizationResponseSchema, InvitationInsertSchema, InvitationSelectSchema, MemberInsertSchema, MemberSelectSchema, OrganizationInsertSchema, OrganizationSelectSchema, SessionInsertSchema, SessionSelectSchema, UserInsertSchema, UserOrganizationSchema, UserOrganizationsResponseSchema, UserSelectSchema, VerificationInsertSchema, VerificationSelectSchema };

package/dist/auth/auth.d.ts

@@ -2,14 +2,15 @@ import * as better_auth_plugins from 'better-auth/plugins';
 import * as _better_auth_sso from '@better-auth/sso';
 import * as zod from 'zod';
 import * as better_auth from 'better-auth';
+import { BetterAuthAdvancedOptions } from 'better-auth';
 import { GoogleOptions } from 'better-auth/social-providers';
-import { D as DatabaseClient } from '../client-HrEgt7wv.js';
+import { D as DatabaseClient } from '../client-CnpNkGsH.js';
 import 'drizzle-orm/node-postgres';
 import 'drizzle-orm/pglite';
-import '../schema-CoC3tYFX.js';
+import '../schema-Cgkp_geg.js';
 import 'drizzle-orm';
 import 'drizzle-orm/pg-core';
-import '../utility-C4QAannk.js';
+import '../utility-C_tTZ7-k.js';
 import 'drizzle-zod';
 import '@hono/zod-openapi';
 import './auth-schema.js';
@@ -68,12 +69,14 @@ interface BetterAuthConfig {
     socialProviders?: {
         google?: GoogleOptions;
     };
+    advanced?: BetterAuthAdvancedOptions;
 }
 interface UserAuthConfig {
     ssoProviders?: SSOProviderConfig[];
     socialProviders?: {
         google?: GoogleOptions;
     };
+    advanced?: BetterAuthAdvancedOptions;
 }
 declare function createAuth(config: BetterAuthConfig): better_auth.Auth<{
     baseURL: string;
@@ -94,9 +97,31 @@ declare function createAuth(config: BetterAuthConfig): better_auth.Auth<{
         updateAge: number;
     };
     advanced: {
+        ipAddress?: {
+            ipAddressHeaders?: string[];
+            disableIpTracking?: boolean;
+        } | undefined;
+        useSecureCookies?: boolean | undefined;
+        disableCSRFCheck?: boolean | undefined;
+        disableOriginCheck?: boolean | undefined;
         crossSubDomainCookies: {
-            enabled: true;
+            enabled: boolean;
+            additionalCookies?: string[];
+            domain?: string;
         };
+        cookies?: {
+            [key: string]: {
+                name?: string;
+                attributes?: better_auth.CookieOptions;
+            };
+        } | undefined;
+        defaultCookieAttributes?: better_auth.CookieOptions | undefined;
+        cookiePrefix?: string | undefined;
+        database?: {
+            defaultFindManyLimit?: number;
+            useNumberId?: boolean;
+            generateId?: better_auth.GenerateIdFn | false | "serial" | "uuid";
+        } | undefined;
     };
     trustedOrigins: string[];
     plugins: [{

package/dist/auth/auth.js

@@ -1,12 +1,36 @@
-import { generateId } from '../chunk-4OISWRFK.js';
+import { generateId } from '../chunk-ICZLNCX7.js';
 import { ssoProvider } from '../chunk-NOPEANIU.js';
 import { ownerRole, adminRole, memberRole, ac } from '../chunk-VMSYBWFH.js';
 import { sso } from '@better-auth/sso';
-import { betterAuth } from 'better-auth';
+import { betterAuth, env } from 'better-auth';
 import { drizzleAdapter } from 'better-auth/adapters/drizzle';
 import { organization } from 'better-auth/plugins';
 import { eq } from 'drizzle-orm';
 
+function extractCookieDomain(baseURL) {
+  try {
+    const url = new URL(baseURL);
+    const hostname = url.hostname;
+    if (hostname === "localhost" || hostname.match(/^\d+\.\d+\.\d+\.\d+$/)) {
+      return void 0;
+    }
+    const parts = hostname.split(".");
+    if (parts.length < 2) {
+      return void 0;
+    }
+    let domainParts;
+    if (parts.length === 3) {
+      domainParts = parts;
+    } else if (parts.length > 3) {
+      domainParts = parts.slice(1);
+    } else {
+      domainParts = parts;
+    }
+    return `.${domainParts.join(".")}`;
+  } catch {
+    return void 0;
+  }
+}
 async function registerSSOProvider(dbClient, provider) {
   try {
     const existing = await dbClient.select().from(ssoProvider).where(eq(ssoProvider.providerId, provider.providerId)).limit(1);
@@ -31,6 +55,7 @@ async function registerSSOProvider(dbClient, provider) {
   }
 }
 function createAuth(config) {
+  const cookieDomain = extractCookieDomain(config.baseURL);
   const auth2 = betterAuth({
     baseURL: config.baseURL,
     secret: config.secret,
@@ -53,10 +78,17 @@ function createAuth(config) {
     },
     advanced: {
       crossSubDomainCookies: {
-        enabled: true
-      }
+        enabled: true,
+        ...cookieDomain && { domain: cookieDomain }
+      },
+      ...config.advanced
     },
-    trustedOrigins: ["http://localhost:3000", "http://localhost:3002", config.baseURL],
+    trustedOrigins: [
+      "http://localhost:3000",
+      "http://localhost:3002",
+      env.INKEEP_AGENTS_MANAGE_UI_URL,
+      env.INKEEP_AGENTS_MANAGE_API_URL
+    ],
     plugins: [
       sso(),
       organization({

package/dist/{chunk-OEHP46F7.js → chunk-32YRH2S7.js}

@@ -1,5 +1,5 @@
-import { AgentWithinContextOfProjectSchema, resourceIdSchema, MAX_ID_LENGTH } from './chunk-ZCEKN54E.js';
-import { z } from 'zod';
+import { AgentWithinContextOfProjectSchema, resourceIdSchema, MAX_ID_LENGTH } from './chunk-VQXQOGJU.js';
+import { external_exports } from './chunk-OUXC23J7.js';
 
 // src/validation/cycleDetection.ts
 function detectDelegationCycles(agentData) {
@@ -181,42 +181,44 @@ function validateAgentStructure(agentData, projectResources) {
   }
   validateAgentRelationships(agentData);
 }
-var TransferDataSchema = z.object({
-  fromSubAgent: z.string().describe("ID of the sub-agent transferring control"),
-  targetSubAgent: z.string().describe("ID of the sub-agent receiving control"),
-  reason: z.string().optional().describe("Reason for the transfer"),
-  context: z.any().optional().describe("Additional context data")
+
+// src/validation/event-schemas.ts
+var TransferDataSchema = external_exports.object({
+  fromSubAgent: external_exports.string().describe("ID of the sub-agent transferring control"),
+  targetSubAgent: external_exports.string().describe("ID of the sub-agent receiving control"),
+  reason: external_exports.string().optional().describe("Reason for the transfer"),
+  context: external_exports.any().optional().describe("Additional context data")
 });
-var DelegationSentDataSchema = z.object({
-  delegationId: z.string().describe("Unique identifier for this delegation"),
-  fromSubAgent: z.string().describe("ID of the delegating sub-agent"),
-  targetSubAgent: z.string().describe("ID of the sub-agent receiving the delegation"),
-  taskDescription: z.string().describe("Description of the delegated task"),
-  context: z.any().optional().describe("Additional context data")
+var DelegationSentDataSchema = external_exports.object({
+  delegationId: external_exports.string().describe("Unique identifier for this delegation"),
+  fromSubAgent: external_exports.string().describe("ID of the delegating sub-agent"),
+  targetSubAgent: external_exports.string().describe("ID of the sub-agent receiving the delegation"),
+  taskDescription: external_exports.string().describe("Description of the delegated task"),
+  context: external_exports.any().optional().describe("Additional context data")
 });
-var DelegationReturnedDataSchema = z.object({
-  delegationId: z.string().describe("Unique identifier matching the original delegation"),
-  fromSubAgent: z.string().describe("ID of the sub-agent that completed the task"),
-  targetSubAgent: z.string().describe("ID of the sub-agent receiving the result"),
-  result: z.any().optional().describe("Result data from the delegated task")
+var DelegationReturnedDataSchema = external_exports.object({
+  delegationId: external_exports.string().describe("Unique identifier matching the original delegation"),
+  fromSubAgent: external_exports.string().describe("ID of the sub-agent that completed the task"),
+  targetSubAgent: external_exports.string().describe("ID of the sub-agent receiving the result"),
+  result: external_exports.any().optional().describe("Result data from the delegated task")
 });
-var DataOperationDetailsSchema = z.object({
-  timestamp: z.number().describe("Unix timestamp in milliseconds"),
-  subAgentId: z.string().describe("ID of the sub-agent that generated this data"),
-  data: z.any().describe("The actual data payload")
+var DataOperationDetailsSchema = external_exports.object({
+  timestamp: external_exports.number().describe("Unix timestamp in milliseconds"),
+  subAgentId: external_exports.string().describe("ID of the sub-agent that generated this data"),
+  data: external_exports.any().describe("The actual data payload")
 });
-var DataOperationEventSchema = z.object({
-  type: z.string().describe("Event type identifier"),
-  label: z.string().describe("Human-readable label for the event"),
+var DataOperationEventSchema = external_exports.object({
+  type: external_exports.string().describe("Event type identifier"),
+  label: external_exports.string().describe("Human-readable label for the event"),
   details: DataOperationDetailsSchema
 });
-var A2AMessageMetadataSchema = z.object({
-  fromSubAgentId: z.string().optional().describe("ID of the sending sub-agent"),
-  toSubAgentId: z.string().optional().describe("ID of the receiving sub-agent"),
-  fromExternalAgentId: z.string().optional().describe("ID of the sending external agent"),
-  toExternalAgentId: z.string().optional().describe("ID of the receiving external agent"),
-  taskId: z.string().optional().describe("Associated task ID"),
-  a2aTaskId: z.string().optional().describe("A2A-specific task ID")
+var A2AMessageMetadataSchema = external_exports.object({
+  fromSubAgentId: external_exports.string().optional().describe("ID of the sending sub-agent"),
+  toSubAgentId: external_exports.string().optional().describe("ID of the receiving sub-agent"),
+  fromExternalAgentId: external_exports.string().optional().describe("ID of the sending external agent"),
+  toExternalAgentId: external_exports.string().optional().describe("ID of the receiving external agent"),
+  taskId: external_exports.string().optional().describe("Associated task ID"),
+  a2aTaskId: external_exports.string().optional().describe("A2A-specific task ID")
 });
 
 // src/validation/id-validation.ts
@@ -339,48 +341,50 @@ function validateRender(render) {
     errors
   };
 }
-var TextStartEventSchema = z.object({
-  type: z.literal("text-start"),
-  id: z.string()
+
+// src/validation/stream-event-schemas.ts
+var TextStartEventSchema = external_exports.object({
+  type: external_exports.literal("text-start"),
+  id: external_exports.string()
 });
-var TextDeltaEventSchema = z.object({
-  type: z.literal("text-delta"),
-  id: z.string(),
-  delta: z.string()
+var TextDeltaEventSchema = external_exports.object({
+  type: external_exports.literal("text-delta"),
+  id: external_exports.string(),
+  delta: external_exports.string()
 });
-var TextEndEventSchema = z.object({
-  type: z.literal("text-end"),
-  id: z.string()
+var TextEndEventSchema = external_exports.object({
+  type: external_exports.literal("text-end"),
+  id: external_exports.string()
 });
-var DataComponentStreamEventSchema = z.object({
-  type: z.literal("data-component"),
-  id: z.string(),
-  data: z.any()
+var DataComponentStreamEventSchema = external_exports.object({
+  type: external_exports.literal("data-component"),
+  id: external_exports.string(),
+  data: external_exports.any()
 });
-var DataOperationStreamEventSchema = z.object({
-  type: z.literal("data-operation"),
-  data: z.any()
+var DataOperationStreamEventSchema = external_exports.object({
+  type: external_exports.literal("data-operation"),
+  data: external_exports.any()
   // Contains OperationEvent types (AgentInitializingEvent, CompletionEvent, etc.)
 });
-var DataSummaryStreamEventSchema = z.object({
-  type: z.literal("data-summary"),
-  data: z.any()
+var DataSummaryStreamEventSchema = external_exports.object({
+  type: external_exports.literal("data-summary"),
+  data: external_exports.any()
   // Contains SummaryEvent from entities.ts
 });
-var StreamErrorEventSchema = z.object({
-  type: z.literal("error"),
-  error: z.string()
+var StreamErrorEventSchema = external_exports.object({
+  type: external_exports.literal("error"),
+  error: external_exports.string()
 });
-var StreamFinishEventSchema = z.object({
-  type: z.literal("finish"),
-  finishReason: z.string().optional(),
-  usage: z.object({
-    promptTokens: z.number().optional(),
-    completionTokens: z.number().optional(),
-    totalTokens: z.number().optional()
+var StreamFinishEventSchema = external_exports.object({
+  type: external_exports.literal("finish"),
+  finishReason: external_exports.string().optional(),
+  usage: external_exports.object({
+    promptTokens: external_exports.number().optional(),
+    completionTokens: external_exports.number().optional(),
+    totalTokens: external_exports.number().optional()
   }).optional()
 });
-var StreamEventSchema = z.discriminatedUnion("type", [
+var StreamEventSchema = external_exports.discriminatedUnion("type", [
   TextStartEventSchema,
   TextDeltaEventSchema,
   TextEndEventSchema,

package/dist/chunk-CUM6BY2Y.js

@@ -0,0 +1,320 @@
+import { external_exports } from './chunk-OUXC23J7.js';
+
+// ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.1.0_zod@4.1.12/node_modules/@asteasolutions/zod-to-openapi/dist/index.mjs
+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;
+}
+var ZodTypeKeys = {
+  ZodAny: "any",
+  ZodArray: "array",
+  ZodBigInt: "bigint",
+  ZodBoolean: "boolean",
+  ZodDefault: "default",
+  ZodTransform: "transform",
+  ZodEnum: "enum",
+  ZodIntersection: "intersection",
+  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"
+};
+function isZodType(schema, typeNames) {
+  const typeNamesArray = Array.isArray(typeNames) ? typeNames : [typeNames];
+  return typeNamesArray.some((typeName) => {
+    var _a;
+    const typeNameMatch = ((_a = schema === null || schema === void 0 ? void 0 : schema.def) === null || _a === void 0 ? void 0 : _a.type) === ZodTypeKeys[typeName];
+    if (typeName === "ZodDiscriminatedUnion") {
+      return typeNameMatch && "discriminator" in schema.def;
+    }
+    return typeNameMatch;
+  });
+}
+function isAnyZodType(schema) {
+  return "def" in schema;
+}
+var $ZodRegistry = class {
+  constructor() {
+    this._map = /* @__PURE__ */ new Map();
+    this._idmap = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
+    this._idmap = /* @__PURE__ */ 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 isUndefined(value) {
+  return value === void 0;
+}
+function omit(object, keys) {
+  const result = {};
+  Object.entries(object).forEach(([key, value]) => {
+    if (!keys.some((keyToOmit) => keyToOmit === key)) {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+function omitBy(object, predicate) {
+  const result = {};
+  Object.entries(object).forEach(([key, value]) => {
+    if (!predicate(value, key)) {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+var zodToOpenAPIRegistry = registry();
+var Metadata = class {
+  static collectMetadata(schema, metadata) {
+    const currentMetadata = this.getMetadataFromRegistry(schema);
+    const _internal = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata._internal), metadata === null || metadata === void 0 ? void 0 : metadata._internal);
+    const param = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), metadata === null || metadata === void 0 ? void 0 : 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",
+      "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;
+  }
+  /**
+   * @deprecated Use one of `getOpenApiMetadata` or `getInternalMetadata` instead
+   */
+  static getMetadata(zodSchema) {
+    return this.collectMetadata(zodSchema);
+  }
+  static getOpenApiMetadata(zodSchema) {
+    const metadata = this.collectMetadata(zodSchema);
+    const _a = metadata !== null && metadata !== void 0 ? metadata : {}, rest = __rest(_a, ["_internal"]);
+    return rest;
+  }
+  static getInternalMetadata(zodSchema) {
+    var _a;
+    return (_a = this.collectMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a._internal;
+  }
+  static getParamMetadata(zodSchema) {
+    const metadata = this.collectMetadata(zodSchema);
+    return Object.assign(Object.assign({}, metadata), {
+      // A description provided from .openapi() should be taken with higher precedence
+      param: Object.assign(Object.assign({}, (metadata === null || metadata === void 0 ? void 0 : metadata.description) ? { description: metadata.description } : {}), metadata === null || metadata === void 0 ? void 0 : metadata.param)
+    });
+  }
+  /**
+   * A method that omits all custom keys added to the regular OpenAPI
+   * metadata properties
+   */
+  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 === void 0 ? void 0 : _a.refId;
+  }
+  static unwrapChained(schema) {
+    return this.unwrapUntil(schema);
+  }
+  static getDefaultValue(zodSchema) {
+    const unwrapped = this.unwrapUntil(zodSchema, "ZodDefault");
+    return unwrapped === null || unwrapped === void 0 ? void 0 : unwrapped._zod.def.defaultValue;
+  }
+  static unwrapUntil(schema, typeName) {
+    if (typeName && isZodType(schema, typeName)) {
+      return schema;
+    }
+    if (isZodType(schema, [
+      "ZodOptional",
+      "ZodNullable",
+      "ZodDefault",
+      "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 ? void 0 : 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 !== void 0 ? 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 !== void 0 ? metadata : {}, { param } = _a, restOfOpenApi = __rest(_a, ["param"]);
+    const allMetadata = Metadata.getMetadataFromRegistry(this);
+    const _b = allMetadata !== null && allMetadata !== void 0 ? allMetadata : {}, { _internal: internalMetadata } = _b, currentMetadata = __rest(_b, ["_internal"]);
+    const _internal = Object.assign(Object.assign(Object.assign({}, internalMetadata), options), refId ? { refId } : void 0);
+    const resultMetadata = Object.assign(Object.assign(Object.assign({}, currentMetadata), restOfOpenApi), (currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param) || param ? {
+      param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), param)
+    } : void 0);
+    const result = new this.constructor(this._def);
+    Metadata.setMetadataInRegistry(result, Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : void 0), resultMetadata));
+    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 !== void 0 ? currentMetadata2 : {}, { _internal: _internal2 } = _a2, rest = __rest(_a2, ["_internal"]);
+        Metadata.setMetadataInRegistry(extendedResult, {
+          _internal: {
+            extendedFrom: (_internal2 === null || _internal2 === void 0 ? void 0 : _internal2.refId) ? { refId: _internal2.refId, schema: result } : _internal2 === null || _internal2 === void 0 ? void 0 : _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: void 0,
+    metadata: refOrOpenapi,
+    options: metadataOrOptions
+  };
+}
+extendZodWithOpenApi(external_exports);