@nocobase/plugin-mcp-server 2.1.0-alpha.13 → 2.1.0-alpha.14

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v4/core/function.ts

@@ -1,176 +0,0 @@
-import { _array, _tuple, _unknown } from "./api.js";
-import type * as core from "./core.js";
-import { parse, parseAsync } from "./parse.js";
-import * as schemas from "./schemas.js";
-import { $ZodTuple } from "./schemas.js";
-import type * as util from "./util.js";
-
-//////////////////////////////////////////
-//////////////////////////////////////////
-//////////                      //////////
-//////////     $ZodFunction     //////////
-//////////                      //////////
-//////////////////////////////////////////
-//////////////////////////////////////////
-export interface $ZodFunctionDef<
-  In extends $ZodFunctionIn = $ZodFunctionIn,
-  Out extends $ZodFunctionOut = $ZodFunctionOut,
-> {
-  type: "function";
-  input: In;
-  output: Out;
-}
-
-export type $ZodFunctionArgs = schemas.$ZodType<unknown[], unknown[]>;
-export type $ZodFunctionIn = $ZodFunctionArgs;
-export type $ZodFunctionOut = schemas.$ZodType;
-
-export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
-  ...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>
-) => core.input<Returns>;
-
-export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
-  ...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>
-) => util.MaybeAsync<core.input<Returns>>;
-
-export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
-  ...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>
-) => core.output<Returns>;
-
-export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
-  ...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>
-) => util.MaybeAsync<core.output<Returns>>;
-
-export class $ZodFunction<
-  Args extends $ZodFunctionIn = $ZodFunctionIn,
-  Returns extends $ZodFunctionOut = $ZodFunctionOut,
-> {
-  def: $ZodFunctionDef<Args, Returns>;
-
-  /** @deprecated */
-  _def!: $ZodFunctionDef<Args, Returns>;
-  _input!: $InferInnerFunctionType<Args, Returns>;
-  _output!: $InferOuterFunctionType<Args, Returns>;
-
-  constructor(def: $ZodFunctionDef<Args, Returns>) {
-    this._def = def;
-    this.def = def;
-  }
-
-  implement<F extends $InferInnerFunctionType<Args, Returns>>(
-    func: F
-  ): // allow for return type inference
-  (
-    ...args: Parameters<this["_output"]>
-  ) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]> {
-    if (typeof func !== "function") {
-      throw new Error("implement() must be called with a function");
-    }
-    const impl = ((...args: any[]) => {
-      const parsedArgs = this._def.input ? parse(this._def.input, args, undefined, { callee: impl }) : args;
-      if (!Array.isArray(parsedArgs)) {
-        throw new Error("Invalid arguments schema: not an array or tuple schema.");
-      }
-      const output = func(...(parsedArgs as any));
-      return this._def.output ? parse(this._def.output, output, undefined, { callee: impl }) : output;
-    }) as any;
-    return impl;
-  }
-
-  implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(
-    func: F
-  ): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns> {
-    if (typeof func !== "function") {
-      throw new Error("implement() must be called with a function");
-    }
-
-    const impl = (async (...args: any[]) => {
-      const parsedArgs = this._def.input ? await parseAsync(this._def.input, args, undefined, { callee: impl }) : args;
-      if (!Array.isArray(parsedArgs)) {
-        throw new Error("Invalid arguments schema: not an array or tuple schema.");
-      }
-      const output = await func(...(parsedArgs as any));
-      return this._def.output ? parseAsync(this._def.output, output, undefined, { callee: impl }) : output;
-    }) as any;
-    return impl;
-  }
-
-  input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(
-    args: Items,
-    rest?: Rest
-  ): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
-  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
-  input(...args: any[]): $ZodFunction<any, Returns> {
-    const F: any = this.constructor;
-    if (Array.isArray(args[0])) {
-      return new F({
-        type: "function",
-        input: new $ZodTuple({
-          type: "tuple",
-          items: args[0],
-          rest: args[1],
-        }),
-        output: this._def.output,
-      });
-    }
-
-    return new F({
-      type: "function",
-      input: args[0],
-      output: this._def.output,
-    });
-  }
-
-  output<NewReturns extends schemas.$ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns> {
-    const F: any = this.constructor;
-    return new F({
-      type: "function",
-      input: this._def.input,
-      output,
-    });
-  }
-}
-
-export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends schemas.$ZodType> {
-  input?: I;
-  output?: O;
-}
-
-function _function(): $ZodFunction;
-function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>>(params: {
-  input: In;
-}): $ZodFunction<$ZodTuple<In, null>, $ZodFunctionOut>;
-function _function<
-  const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>,
-  const Out extends $ZodFunctionOut = $ZodFunctionOut,
->(params: {
-  input: In;
-  output: Out;
-}): $ZodFunction<$ZodTuple<In, null>, Out>;
-function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
-  input: In;
-}): $ZodFunction<In, $ZodFunctionOut>;
-function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
-  output: Out;
-}): $ZodFunction<$ZodFunctionIn, Out>;
-function _function<
-  In extends $ZodFunctionIn = $ZodFunctionIn,
-  Out extends schemas.$ZodType = schemas.$ZodType,
->(params?: {
-  input: In;
-  output: Out;
-}): $ZodFunction<In, Out>;
-function _function(params?: {
-  output?: schemas.$ZodType;
-  input?: $ZodFunctionArgs | Array<schemas.$ZodType>;
-}): any {
-  return new $ZodFunction({
-    type: "function",
-    input: Array.isArray(params?.input)
-      ? _tuple(schemas.$ZodTuple, params?.input as any)
-      : (params?.input ?? _array(schemas.$ZodArray, _unknown(schemas.$ZodUnknown))),
-    output: params?.output ?? _unknown(schemas.$ZodUnknown),
-  });
-}
-
-export { _function as function };

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v4/core/index.ts

@@ -1,15 +0,0 @@
-export * from "./core.js";
-export * from "./parse.js";
-export * from "./errors.js";
-export * from "./schemas.js";
-export * from "./checks.js";
-export * from "./versions.js";
-export * as util from "./util.js";
-export * as regexes from "./regexes.js";
-export * as locales from "../locales/index.js";
-export * from "./registries.js";
-export * from "./doc.js";
-export * from "./function.js";
-export * from "./api.js";
-export * from "./to-json-schema.js";
-export * as JSONSchema from "./json-schema.js";

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v4/core/json-schema.ts

@@ -1,143 +0,0 @@
-export type Schema =
-  | ObjectSchema
-  | ArraySchema
-  | StringSchema
-  | NumberSchema
-  | IntegerSchema
-  | BooleanSchema
-  | NullSchema;
-
-// export type JsonType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
-
-// export interface JSONSchema {
-//   type?: string ;
-//   $id?: string ;
-//   id?: string ;
-//   $schema?: string ;
-//   $ref?: string ;
-//   $anchor?: string ;
-//   $defs?: { [key: string]: JSONSchema } ;
-//   definitions?: { [key: string]: JSONSchema } ;
-//   $comment?: string ;
-//   title?: string ;
-//   description?: string ;
-//   default?: unknown ;
-//   examples?: unknown[] ;
-//   readOnly?: boolean ;
-//   writeOnly?: boolean ;
-//   deprecated?: boolean ;
-//   allOf?: JSONSchema[] ;
-//   anyOf?: JSONSchema[] ;
-//   oneOf?: JSONSchema[] ;
-//   not?: JSONSchema ;
-//   if?: JSONSchema ;
-//   then?: JSONSchema ;
-//   else?: JSONSchema ;
-//   enum?: Array<string | number | boolean | null> ;
-//   const?: string | number | boolean | null ;
-//   [k: string]: unknown;
-
-//   /** A special key used as an intermediate representation of extends-style relationships. Omitted as a $ref with additional properties. */
-//   // _ref?: JSONSchema;
-//   _prefault?: unknown ;
-// }
-
-export type _JSONSchema = boolean | JSONSchema;
-export type JSONSchema = {
-  [k: string]: unknown;
-  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#";
-  $id?: string;
-  $anchor?: string;
-  $ref?: string;
-  $dynamicRef?: string;
-  $dynamicAnchor?: string;
-  $vocabulary?: Record<string, boolean>;
-  $comment?: string;
-  $defs?: Record<string, JSONSchema>;
-  type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
-  additionalItems?: _JSONSchema;
-  unevaluatedItems?: _JSONSchema;
-  prefixItems?: _JSONSchema[];
-  items?: _JSONSchema | _JSONSchema[];
-  contains?: _JSONSchema;
-  additionalProperties?: _JSONSchema;
-  unevaluatedProperties?: _JSONSchema;
-  properties?: Record<string, _JSONSchema>;
-  patternProperties?: Record<string, _JSONSchema>;
-  dependentSchemas?: Record<string, _JSONSchema>;
-  propertyNames?: _JSONSchema;
-  if?: _JSONSchema;
-  then?: _JSONSchema;
-  else?: _JSONSchema;
-  allOf?: JSONSchema[];
-  anyOf?: JSONSchema[];
-  oneOf?: JSONSchema[];
-  not?: _JSONSchema;
-  multipleOf?: number;
-  maximum?: number;
-  exclusiveMaximum?: number;
-  minimum?: number;
-  exclusiveMinimum?: number;
-  maxLength?: number;
-  minLength?: number;
-  pattern?: string;
-  maxItems?: number;
-  minItems?: number;
-  uniqueItems?: boolean;
-  maxContains?: number;
-  minContains?: number;
-  maxProperties?: number;
-  minProperties?: number;
-  required?: string[];
-  dependentRequired?: Record<string, string[]>;
-  enum?: Array<string | number | boolean | null>;
-  const?: string | number | boolean | null;
-
-  // metadata
-  id?: string;
-  title?: string;
-  description?: string;
-  default?: unknown;
-  deprecated?: boolean;
-  readOnly?: boolean;
-  writeOnly?: boolean;
-  examples?: unknown[];
-  format?: string;
-  contentMediaType?: string;
-  contentEncoding?: string;
-  contentSchema?: JSONSchema;
-
-  // internal
-  _prefault?: unknown;
-};
-
-// for backwards compatibility
-export type BaseSchema = JSONSchema;
-
-export interface ObjectSchema extends JSONSchema {
-  type: "object";
-}
-
-export interface ArraySchema extends JSONSchema {
-  type: "array";
-}
-
-export interface StringSchema extends JSONSchema {
-  type: "string";
-}
-
-export interface NumberSchema extends JSONSchema {
-  type: "number";
-}
-
-export interface IntegerSchema extends JSONSchema {
-  type: "integer";
-}
-
-export interface BooleanSchema extends JSONSchema {
-  type: "boolean";
-}
-
-export interface NullSchema extends JSONSchema {
-  type: "null";
-}

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v4/core/parse.ts

@@ -1,94 +0,0 @@
-import * as core from "./core.js";
-import * as errors from "./errors.js";
-import type * as schemas from "./schemas.js";
-import * as util from "./util.js";
-
-export type $ZodErrorClass = { new (issues: errors.$ZodIssue[]): errors.$ZodError };
-
-///////////        METHODS       ///////////
-export type $Parse = <T extends schemas.$ZodType>(
-  schema: T,
-  value: unknown,
-  _ctx?: schemas.ParseContext<errors.$ZodIssue>,
-  _params?: { callee?: util.AnyFunc; Err?: $ZodErrorClass }
-) => core.output<T>;
-
-export const _parse: (_Err: $ZodErrorClass) => $Parse = (_Err) => (schema, value, _ctx, _params) => {
-  const ctx: schemas.ParseContextInternal = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) {
-    throw new core.$ZodAsyncError();
-  }
-  if (result.issues.length) {
-    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
-    util.captureStackTrace(e, _params?.callee);
-    throw e;
-  }
-  return result.value as core.output<typeof schema>;
-};
-
-export const parse: $Parse = /* @__PURE__*/ _parse(errors.$ZodRealError);
-
-export type $ParseAsync = <T extends schemas.$ZodType>(
-  schema: T,
-  value: unknown,
-  _ctx?: schemas.ParseContext<errors.$ZodIssue>,
-  _params?: { callee?: util.AnyFunc; Err?: $ZodErrorClass }
-) => Promise<core.output<T>>;
-
-export const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync = (_Err) => async (schema, value, _ctx, params) => {
-  const ctx: schemas.ParseContextInternal = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) result = await result;
-  if (result.issues.length) {
-    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
-    util.captureStackTrace(e, params?.callee);
-    throw e;
-  }
-  return result.value as core.output<typeof schema>;
-};
-
-export const parseAsync: $ParseAsync = /* @__PURE__*/ _parseAsync(errors.$ZodRealError);
-
-export type $SafeParse = <T extends schemas.$ZodType>(
-  schema: T,
-  value: unknown,
-  _ctx?: schemas.ParseContext<errors.$ZodIssue>
-) => util.SafeParseResult<core.output<T>>;
-
-export const _safeParse: (_Err: $ZodErrorClass) => $SafeParse = (_Err) => (schema, value, _ctx) => {
-  const ctx: schemas.ParseContextInternal = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) {
-    throw new core.$ZodAsyncError();
-  }
-
-  return result.issues.length
-    ? {
-        success: false,
-        error: new (_Err ?? errors.$ZodError)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
-      }
-    : ({ success: true, data: result.value } as any);
-};
-export const safeParse: $SafeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);
-
-export type $SafeParseAsync = <T extends schemas.$ZodType>(
-  schema: T,
-  value: unknown,
-  _ctx?: schemas.ParseContext<errors.$ZodIssue>
-) => Promise<util.SafeParseResult<core.output<T>>>;
-
-export const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync = (_Err) => async (schema, value, _ctx) => {
-  const ctx: schemas.ParseContextInternal = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) result = await result;
-
-  return result.issues.length
-    ? {
-        success: false,
-        error: new _Err(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
-      }
-    : ({ success: true, data: result.value } as any);
-};
-
-export const safeParseAsync: $SafeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v4/core/regexes.ts

@@ -1,135 +0,0 @@
-export const cuid: RegExp = /^[cC][^\s-]{8,}$/;
-export const cuid2: RegExp = /^[0-9a-z]+$/;
-export const ulid: RegExp = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
-export const xid: RegExp = /^[0-9a-vA-V]{20}$/;
-export const ksuid: RegExp = /^[A-Za-z0-9]{27}$/;
-export const nanoid: RegExp = /^[a-zA-Z0-9_-]{21}$/;
-
-/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
-export const duration: RegExp =
-  /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
-
-/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
-export const extendedDuration: RegExp =
-  /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
-
-/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
-export const guid: RegExp = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
-
-/** Returns a regex for validating an RFC 4122 UUID.
- *
- * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
-export const uuid = (version?: number | undefined): RegExp => {
-  if (!version)
-    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
-  return new RegExp(
-    `^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`
-  );
-};
-export const uuid4: RegExp = /*@__PURE__*/ uuid(4);
-export const uuid6: RegExp = /*@__PURE__*/ uuid(6);
-export const uuid7: RegExp = /*@__PURE__*/ uuid(7);
-
-/** Practical email validation */
-export const email: RegExp =
-  /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
-
-/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
-export const html5Email: RegExp =
-  /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
-
-/** The classic emailregex.com regex for RFC 5322-compliant emails */
-export const rfc5322Email =
-  /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
-
-/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
-export const unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
-
-export const browserEmail: RegExp =
-  /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
-// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
-
-export const _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
-export function emoji(): RegExp {
-  return new RegExp(_emoji, "u");
-}
-
-export const ipv4: RegExp =
-  /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
-export const ipv6: RegExp =
-  /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
-
-export const cidrv4: RegExp =
-  /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
-export const cidrv6: RegExp =
-  /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
-
-// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
-export const base64: RegExp = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
-export const base64url: RegExp = /^[A-Za-z0-9_-]*$/;
-
-// based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
-// export const hostname: RegExp =
-//   /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)+([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/;
-export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
-export const domain: RegExp = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
-
-// https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
-export const e164: RegExp = /^\+(?:[0-9]){6,14}[0-9]$/;
-
-// const dateSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
-const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
-export const date: RegExp = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
-
-function timeSource(args: { precision?: number | null | undefined }) {
-  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
-  const regex =
-    typeof args.precision === "number"
-      ? args.precision === -1
-        ? `${hhmm}`
-        : args.precision === 0
-          ? `${hhmm}:[0-5]\\d`
-          : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}`
-      : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
-  return regex;
-}
-export function time(args: {
-  precision?: number | null;
-  // local?: boolean;
-}): RegExp {
-  return new RegExp(`^${timeSource(args)}$`);
-}
-
-// Adapted from https://stackoverflow.com/a/3143231
-export function datetime(args: {
-  precision?: number | null;
-  offset?: boolean;
-  local?: boolean;
-}): RegExp {
-  const time = timeSource({ precision: args.precision });
-  const opts = ["Z"];
-  if (args.local) opts.push("");
-  if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
-  const timeRegex = `${time}(?:${opts.join("|")})`;
-
-  return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
-}
-
-export const string = (params?: { minimum?: number | undefined; maximum?: number | undefined }): RegExp => {
-  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
-  return new RegExp(`^${regex}$`);
-};
-
-export const bigint: RegExp = /^\d+n?$/;
-export const integer: RegExp = /^\d+$/;
-export const number: RegExp = /^-?\d+(?:\.\d+)?/i;
-export const boolean: RegExp = /true|false/i;
-const _null: RegExp = /null/i;
-export { _null as null };
-const _undefined: RegExp = /undefined/i;
-export { _undefined as undefined };
-
-// regex for string with no uppercase letters
-export const lowercase: RegExp = /^[^A-Z]*$/;
-// regex for string with no lowercase letters
-export const uppercase: RegExp = /^[^a-z]*$/;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v4/core/registries.ts

@@ -1,96 +0,0 @@
-import type * as core from "./core.js";
-import type { $ZodType } from "./schemas.js";
-
-export const $output: unique symbol = Symbol("ZodOutput");
-export type $output = typeof $output;
-export const $input: unique symbol = Symbol("ZodInput");
-export type $input = typeof $input;
-
-export type $replace<Meta, S extends $ZodType> = Meta extends $output
-  ? core.output<S>
-  : Meta extends $input
-    ? core.input<S>
-    : Meta extends (infer M)[]
-      ? $replace<M, S>[]
-      : Meta extends (...args: infer P) => infer R
-        ? (
-            ...args: {
-              [K in keyof P]: $replace<P[K], S>; // tuple
-            }
-          ) => $replace<R, S>
-        : // handle objects
-          Meta extends object
-          ? { [K in keyof Meta]: $replace<Meta[K], S> }
-          : Meta;
-
-type MetadataType = Record<string, unknown> | undefined;
-export class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
-  _meta!: Meta;
-  _schema!: Schema;
-  _map: Map<Schema, $replace<Meta, Schema>> = new Map();
-  _idmap: Map<string, Schema> = new Map();
-
-  add<S extends Schema>(
-    schema: S,
-    ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]
-  ): this {
-    const meta: any = _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 as any;
-  }
-
-  clear(): this {
-    this._map = new Map();
-    this._idmap = new Map();
-    return this;
-  }
-
-  remove(schema: Schema): this {
-    const meta: any = this._map.get(schema);
-    if (meta && typeof meta === "object" && "id" in meta) {
-      this._idmap.delete(meta.id!);
-    }
-    this._map.delete(schema);
-    return this;
-  }
-
-  get<S extends Schema>(schema: S): $replace<Meta, S> | undefined {
-    // return this._map.get(schema) as any;
-
-    // inherit metadata
-    const p = schema._zod.parent as Schema;
-    if (p) {
-      const pm: any = { ...(this.get(p) ?? {}) };
-      delete pm.id; // do not inherit id
-      return { ...pm, ...this._map.get(schema) } as any;
-    }
-    return this._map.get(schema) as any;
-  }
-
-  has(schema: Schema): boolean {
-    return this._map.has(schema);
-  }
-}
-
-export interface JSONSchemaMeta {
-  id?: string | undefined;
-  title?: string | undefined;
-  description?: string | undefined;
-  deprecated?: boolean | undefined;
-  [k: string]: unknown;
-}
-
-export interface GlobalMeta extends JSONSchemaMeta {}
-
-// registries
-export function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S> {
-  return new $ZodRegistry<T, S>();
-}
-
-export const globalRegistry: $ZodRegistry<GlobalMeta> = /*@__PURE__*/ registry<GlobalMeta>();