@mastra/server 1.37.0 → 1.37.2-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @mastra/server
 
+## 1.37.2-alpha.1
+
+### Patch Changes
+
+- Added sseFlushOnConnect route option to scope the SSE connected comment to subscribe endpoints only ([#17158](https://github.com/mastra-ai/mastra/pull/17158))
+
+- Fixed sub-agent version resolution in supervisor mode. Sub-agents now inherit the parent's draft/published version semantics — when chatting in the editor (draft mode), sub-agents resolve to their latest draft version; in the main agent chat (published mode), sub-agents resolve to their published version. Previously, sub-agents without explicit per-agent version overrides always fell back to the code-defined default, ignoring the parent's version context. ([#17165](https://github.com/mastra-ai/mastra/pull/17165))
+
+- Scoped the SSE connected comment to subscribe routes only and added SSE comment passthrough for Fastify and NestJS adapters ([#17158](https://github.com/mastra-ai/mastra/pull/17158))
+
+- Updated dependencies [[`49f8abc`](https://github.com/mastra-ai/mastra/commit/49f8abce8258e4f2f87bd326acfbdb641264a47c)]:
+  - @mastra/core@1.37.2-alpha.1
+
+## 1.37.2-alpha.0
+
+### Patch Changes
+
+- Moved shared voice primitives and route metadata into the new `@internal/voice` package so voice providers no longer depend on `@mastra/core` and server voice routes share the same route definitions. ([#16725](https://github.com/mastra-ai/mastra/pull/16725))
+
+  `@mastra/core/voice` continues to re-export the voice APIs for backwards compatibility.
+
+- Updated dependencies [[`07c3de7`](https://github.com/mastra-ai/mastra/commit/07c3de7f7bc418beccaea3b5e6b7f7cdda79d492)]:
+  - @mastra/core@1.37.2-alpha.0
+
+## 1.37.1
+
+### Patch Changes
+
+- Updated dependencies [[`21db1a4`](https://github.com/mastra-ai/mastra/commit/21db1a4b8ac058d5a4fbe38b516cc1b81e526915)]:
+  - @mastra/core@1.37.1
+
 ## 1.37.0
 
 ### Minor Changes

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/request-context/index.d.ts

@@ -0,0 +1,147 @@
+type RecordToTuple<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+/**
+ * Reserved key for setting resourceId from middleware.
+ * When set in RequestContext, this takes precedence over client-provided values
+ * for security (prevents attackers from hijacking another user's memory).
+ *
+ * @example
+ * ```typescript
+ * // In your auth middleware:
+ * const requestContext = c.get('requestContext');
+ * requestContext.set(MASTRA_RESOURCE_ID_KEY, authenticatedUser.id);
+ * ```
+ */
+declare const MASTRA_RESOURCE_ID_KEY = "mastra__resourceId";
+/**
+ * Reserved key for setting threadId from middleware.
+ * When set in RequestContext, this takes precedence over client-provided values
+ * for security (prevents attackers from hijacking another user's memory).
+ *
+ * @example
+ * ```typescript
+ * // In your auth middleware:
+ * const requestContext = c.get('requestContext');
+ * requestContext.set(MASTRA_THREAD_ID_KEY, threadId);
+ * ```
+ */
+declare const MASTRA_THREAD_ID_KEY = "mastra__threadId";
+/**
+ * Reserved key for storing version overrides on RequestContext.
+ * When set, sub-agent delegation resolves versioned agents from these overrides.
+ *
+ * @example
+ * ```typescript
+ * requestContext.set(MASTRA_VERSIONS_KEY, {
+ *   agents: { 'researcher-agent': { versionId: '123' } },
+ * });
+ * ```
+ */
+declare const MASTRA_VERSIONS_KEY = "mastra__versions";
+/**
+ * Reserved key for storing the raw auth token from the incoming request.
+ * Used by the editor to forward authentication when connecting to MCP servers
+ * that require the same auth as the Mastra server itself.
+ */
+declare const MASTRA_AUTH_TOKEN_KEY = "mastra__authToken";
+type VersionSelector = {
+    versionId: string;
+} | {
+    status: 'draft' | 'published';
+};
+type VersionOverrides = {
+    agents?: Record<string, VersionSelector>;
+    /** Fallback status for sub-agents (and future primitives) without an explicit entry. */
+    defaultStatus?: 'draft' | 'published';
+};
+declare function mergeVersionOverrides(base?: VersionOverrides, overrides?: VersionOverrides): VersionOverrides | undefined;
+declare class RequestContext<Values extends Record<string, any> | unknown = unknown> {
+    private registry;
+    constructor(iterable?: Values extends Record<string, any> ? RecordToTuple<Partial<Values>> : Iterable<readonly [string, unknown]>);
+    /**
+     * set a value with strict typing if `Values` is a Record and the key exists in it.
+     */
+    set<K extends Values extends Record<string, any> ? keyof Values : string>(key: K, value: Values extends Record<string, any> ? (K extends keyof Values ? Values[K] : never) : unknown): void;
+    /**
+     * Get a value with its type
+     */
+    get<K extends Values extends Record<string, any> ? keyof Values : string, R = Values extends Record<string, any> ? (K extends keyof Values ? Values[K] : never) : unknown>(key: K): R;
+    /**
+     * Check if a key exists in the container
+     */
+    has<K extends Values extends Record<string, any> ? keyof Values : string>(key: K): boolean;
+    /**
+     * Delete a value by key
+     */
+    delete<K extends Values extends Record<string, any> ? keyof Values : string>(key: K): boolean;
+    /**
+     * Clear all values from the container
+     */
+    clear(): void;
+    /**
+     * Get all keys in the container
+     */
+    keys(): IterableIterator<Values extends Record<string, any> ? keyof Values : string>;
+    /**
+     * Get all values in the container
+     */
+    values(): IterableIterator<Values extends Record<string, any> ? Values[keyof Values] : unknown>;
+    /**
+     * Get all entries in the container.
+     * Returns a discriminated union of tuples for proper type narrowing when iterating.
+     */
+    entries(): IterableIterator<Values extends Record<string, any> ? {
+        [K in keyof Values]: [K, Values[K]];
+    }[keyof Values] : [string, unknown]>;
+    /**
+     * Get the size of the container
+     */
+    size(): number;
+    /**
+     * Execute a function for each entry in the container.
+     * The callback receives properly typed key-value pairs.
+     */
+    forEach<K extends Values extends Record<string, any> ? keyof Values : string>(callbackfn: (value: Values extends Record<string, any> ? (K extends keyof Values ? Values[K] : unknown) : unknown, key: K, map: Map<string, unknown>) => void): void;
+    /**
+     * Custom JSON serialization method.
+     * Converts the internal Map to a plain object for proper JSON serialization.
+     * Non-serializable values (functions, symbols, RPC proxies, in-value
+     * circular references, and values whose serialization re-enters this
+     * `toJSON` via cross-context back-references) are skipped to prevent
+     * serialization errors when storing to database.
+     *
+     * Reentry safety: if a stored value's `isSerializable` probe re-enters
+     * `toJSON()` on this same instance (through a chain of RequestContexts
+     * holding references to each other), we throw `CyclicRequestContextToJSONError`.
+     * Inner `isSerializable` calls re-throw the marker; the outermost
+     * `isSerializable` swallows it and filters the offending key, the same
+     * way it filters in-value circular references today.
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * Check if a value can be safely serialized to JSON.
+     *
+     * Re-throws `CyclicRequestContextToJSONError` when called from a nested
+     * `toJSON()` (`_toJSONDepth > 1`), so the marker propagates up to the
+     * outermost `toJSON()`'s `isSerializable`, which then swallows it and
+     * filters the offending key. This is what lets the outermost call return
+     * a clean JSON-safe dict for cross-context cycles.
+     */
+    private isSerializable;
+    /**
+     * Get all values as a typed object for destructuring.
+     * Returns Record<string, any> when untyped, or the Values type when typed.
+     *
+     * @example
+     * ```typescript
+     * const ctx = new RequestContext<{ userId: string; apiKey: string }>();
+     * ctx.set('userId', 'user-123');
+     * ctx.set('apiKey', 'key-456');
+     * const { userId, apiKey } = ctx.all;
+     * ```
+     */
+    get all(): Values extends Record<string, any> ? Values : Record<string, any>;
+}
+
+export { MASTRA_AUTH_TOKEN_KEY, MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, MASTRA_VERSIONS_KEY, RequestContext, type VersionOverrides, type VersionSelector, mergeVersionOverrides };

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/routes/index.d.ts

@@ -0,0 +1,110 @@
+import * as z from '../../../zod/v4/index.d.cts';
+import { RequestContext } from '../request-context/index.js';
+import { ToolsInput } from '../types/index.js';
+
+interface OpenAPIRoute {
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    deprecated?: boolean;
+    requestParams?: {
+        path?: z.ZodSchema;
+        query?: z.ZodSchema;
+    };
+    requestBody?: {
+        content: {
+            'application/json': {
+                schema: z.ZodSchema;
+            };
+        };
+    };
+    responses: {
+        [statusCode: string]: {
+            description: string;
+            content?: {
+                'application/json': {
+                    schema: z.ZodSchema;
+                };
+            };
+        };
+    };
+}
+interface RouteOpenAPIConfig {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    pathParamSchema?: z.ZodSchema;
+    queryParamSchema?: z.ZodSchema;
+    bodySchema?: z.ZodSchema;
+    responseSchema?: z.ZodSchema;
+    deprecated?: boolean;
+}
+declare function generateRouteOpenAPI({ method, path, summary, description, tags, pathParamSchema, queryParamSchema, bodySchema, responseSchema, deprecated, }: RouteOpenAPIConfig): OpenAPIRoute;
+type ResponseType = 'stream' | 'json' | 'datastream-response' | 'mcp-http' | 'mcp-sse';
+type InferParams<TPathSchema extends z.ZodTypeAny | undefined, TQuerySchema extends z.ZodTypeAny | undefined, TBodySchema extends z.ZodTypeAny | undefined> = (TPathSchema extends z.ZodTypeAny ? z.infer<TPathSchema> : {}) & (TQuerySchema extends z.ZodTypeAny ? z.infer<TQuerySchema> : {}) & (TBodySchema extends z.ZodTypeAny ? z.infer<TBodySchema> : {});
+interface RouteSchemas<TPathSchema = unknown, TQuerySchema = unknown, TBodySchema = unknown, TResponseSchema = unknown> {
+    readonly pathParams: TPathSchema;
+    readonly queryParams: TQuerySchema;
+    readonly body: TBodySchema;
+    readonly response: TResponseSchema;
+}
+type ServerContext = {
+    mastra: any;
+    requestContext: RequestContext;
+    registeredTools?: ToolsInput;
+    taskStore?: unknown;
+    abortSignal: AbortSignal;
+    routePrefix?: string;
+};
+type ServerRouteHandler<TParams = Record<string, unknown>, TResponse = unknown, TResponseType extends ResponseType = 'json'> = (params: TParams & ServerContext) => Promise<TResponseType extends 'stream' ? ReadableStream : TResponseType extends 'datastream-response' ? Response : TResponse>;
+type ValidationErrorHook = (error: z.ZodError) => {
+    status?: number;
+    body?: unknown;
+} | void;
+type ServerRoute<TParams = Record<string, unknown>, TResponse = unknown, TResponseType extends ResponseType = ResponseType, TSchemas extends RouteSchemas = RouteSchemas, TMethod extends string = string, TPath extends string = string> = {
+    method: TMethod;
+    path: TPath;
+    responseType: TResponseType;
+    streamFormat?: 'sse' | 'stream';
+    sseFlushOnConnect?: boolean;
+    handler(params: TParams & ServerContext): ReturnType<ServerRouteHandler<TParams, TResponse, TResponseType>>;
+    pathParamSchema?: z.ZodSchema;
+    queryParamSchema?: z.ZodSchema;
+    bodySchema?: z.ZodSchema;
+    responseSchema?: z.ZodSchema;
+    openapi?: OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresAuth?: boolean;
+    requiresPermission?: any;
+    fga?: any;
+    onValidationError?: ValidationErrorHook;
+    readonly __schemas?: TSchemas;
+};
+interface RouteConfig<TPathSchema extends z.ZodTypeAny | undefined = undefined, TQuerySchema extends z.ZodTypeAny | undefined = undefined, TBodySchema extends z.ZodTypeAny | undefined = undefined, TResponseSchema extends z.ZodTypeAny | undefined = undefined, TResponseType extends ResponseType = 'json', TMethod extends string = string, TPath extends string = string> {
+    method: TMethod;
+    path: TPath;
+    responseType: TResponseType;
+    streamFormat?: 'sse' | 'stream';
+    sseFlushOnConnect?: boolean;
+    handler: ServerRouteHandler<InferParams<TPathSchema, TQuerySchema, TBodySchema>, TResponseSchema extends z.ZodTypeAny ? z.infer<TResponseSchema> : unknown, TResponseType>;
+    pathParamSchema?: TPathSchema;
+    queryParamSchema?: TQuerySchema;
+    bodySchema?: TBodySchema;
+    responseSchema?: TResponseSchema;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    deprecated?: boolean;
+    maxBodySize?: number;
+    requiresAuth?: boolean;
+    requiresPermission?: any;
+    fga?: any;
+    onValidationError?: ValidationErrorHook;
+}
+declare function createRoute<TPathSchema extends z.ZodTypeAny | undefined = undefined, TQuerySchema extends z.ZodTypeAny | undefined = undefined, TBodySchema extends z.ZodTypeAny | undefined = undefined, TResponseSchema extends z.ZodTypeAny | undefined = undefined, TResponseType extends ResponseType = 'json', TMethod extends string = string, TPath extends string = string>(config: RouteConfig<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema, TResponseType, TMethod, TPath>): ServerRoute<InferParams<TPathSchema, TQuerySchema, TBodySchema>, TResponseSchema extends z.ZodTypeAny ? z.infer<TResponseSchema> : unknown, TResponseType, RouteSchemas<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema>, TMethod, TPath>;
+declare function createPublicRoute<TPathSchema extends z.ZodTypeAny | undefined = undefined, TQuerySchema extends z.ZodTypeAny | undefined = undefined, TBodySchema extends z.ZodTypeAny | undefined = undefined, TResponseSchema extends z.ZodTypeAny | undefined = undefined, TResponseType extends ResponseType = 'json', TMethod extends string = string, TPath extends string = string>(config: Omit<RouteConfig<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema, TResponseType, TMethod, TPath>, 'requiresAuth'>): ServerRoute<InferParams<TPathSchema, TQuerySchema, TBodySchema>, TResponseSchema extends z.ZodTypeAny ? z.infer<TResponseSchema> : unknown, TResponseType, RouteSchemas<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema>, TMethod, TPath>;
+
+export { type InferParams, type OpenAPIRoute, type ResponseType, type RouteSchemas, type ServerContext, type ServerRoute, type ServerRouteHandler, type ValidationErrorHook, createPublicRoute, createRoute, generateRouteOpenAPI };

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+type ToolsInput = Record<string, any>;
+
+export type { ToolsInput };

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/checks.d.ts

@@ -0,0 +1 @@
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.js";

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/coerce.d.ts

@@ -0,0 +1,17 @@
+import * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+export interface ZodCoercedString<T = unknown> extends schemas._ZodString<core.$ZodStringInternals<T>> {
+}
+export declare function string<T = unknown>(params?: string | core.$ZodStringParams): ZodCoercedString<T>;
+export interface ZodCoercedNumber<T = unknown> extends schemas._ZodNumber<core.$ZodNumberInternals<T>> {
+}
+export declare function number<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T>;
+export interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<core.$ZodBooleanInternals<T>> {
+}
+export declare function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T>;
+export interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<core.$ZodBigIntInternals<T>> {
+}
+export declare function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T>;
+export interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<core.$ZodDateInternals<T>> {
+}
+export declare function date<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T>;

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/compat.d.ts

@@ -0,0 +1,50 @@
+import * as core from "../core/index.js";
+import type { ZodType } from "./schemas.js";
+export type { 
+/** @deprecated Use `z.output<T>` instead. */
+output as TypeOf, 
+/** @deprecated Use `z.output<T>` instead. */
+output as Infer, 
+/** @deprecated Use `z.core.$$ZodFirstPartyTypes` instead */
+$ZodTypes as ZodFirstPartySchemaTypes, } from "../core/index.js";
+/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
+export declare const ZodIssueCode: {
+    readonly invalid_type: "invalid_type";
+    readonly too_big: "too_big";
+    readonly too_small: "too_small";
+    readonly invalid_format: "invalid_format";
+    readonly not_multiple_of: "not_multiple_of";
+    readonly unrecognized_keys: "unrecognized_keys";
+    readonly invalid_union: "invalid_union";
+    readonly invalid_key: "invalid_key";
+    readonly invalid_element: "invalid_element";
+    readonly invalid_value: "invalid_value";
+    readonly custom: "custom";
+};
+/** @deprecated Use `z.$ZodFlattenedError` */
+export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
+/** @deprecated Use `z.$ZodFormattedError` */
+export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<core.output<T>, U>;
+/** Use `z.$brand` instead */
+export type BRAND<T extends string | number | symbol = string | number | symbol> = {
+    [core.$brand]: {
+        [k in T]: true;
+    };
+};
+export { $brand, config } from "../core/index.js";
+/** @deprecated Use `z.config(params)` instead. */
+export declare function setErrorMap(map: core.$ZodErrorMap): void;
+/** @deprecated Use `z.config()` instead. */
+export declare function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined;
+export type { 
+/** @deprecated Use z.ZodType (without generics) instead. */
+ZodType as ZodTypeAny, 
+/** @deprecated Use `z.ZodType` */
+ZodType as ZodSchema, 
+/** @deprecated Use `z.ZodType` */
+ZodType as Schema, };
+/** Included for Zod 3 compatibility */
+export type ZodRawShape = core.$ZodShape;
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+export declare enum ZodFirstPartyTypeKind {
+}

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/errors.d.ts

@@ -0,0 +1,30 @@
+import * as core from "../core/index.js";
+import { $ZodError } from "../core/index.js";
+/** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
+export type ZodIssue = core.$ZodIssue;
+/** An Error-like class used to store Zod validation issues.  */
+export interface ZodError<T = unknown> extends $ZodError<T> {
+    /** @deprecated Use the `z.treeifyError(err)` function instead. */
+    format(): core.$ZodFormattedError<T>;
+    format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;
+    /** @deprecated Use the `z.treeifyError(err)` function instead. */
+    flatten(): core.$ZodFlattenedError<T>;
+    flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;
+    /** @deprecated Push directly to `.issues` instead. */
+    addIssue(issue: core.$ZodIssue): void;
+    /** @deprecated Push directly to `.issues` instead. */
+    addIssues(issues: core.$ZodIssue[]): void;
+    /** @deprecated Check `err.issues.length === 0` instead. */
+    isEmpty: boolean;
+}
+export declare const ZodError: core.$constructor<ZodError>;
+export declare const ZodRealError: core.$constructor<ZodError>;
+export type { 
+/** @deprecated Use `z.core.$ZodFlattenedError` instead. */
+$ZodFlattenedError as ZodFlattenedError, 
+/** @deprecated Use `z.core.$ZodFormattedError` instead. */
+$ZodFormattedError as ZodFormattedError, 
+/** @deprecated Use `z.core.$ZodErrorMap` instead. */
+$ZodErrorMap as ZodErrorMap, } from "../core/index.js";
+/** @deprecated Use `z.core.$ZodRawIssue` instead. */
+export type IssueData = core.$ZodRawIssue;

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/external.d.ts

@@ -0,0 +1,16 @@
+export * as core from "../core/index.js";
+export * from "./schemas.js";
+export * from "./checks.js";
+export * from "./errors.js";
+export * from "./parse.js";
+export * from "./compat.js";
+export type { infer, output, input } from "../core/index.js";
+export type { JSONType } from "../core/util.js";
+export { globalRegistry, type GlobalMeta, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from "../core/index.js";
+export { toJSONSchema } from "../core/json-schema-processors.js";
+export { fromJSONSchema } from "./from-json-schema.js";
+export * as locales from "../locales/index.js";
+export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.js";
+export * as iso from "./iso.js";
+export type { ZodCoercedString, ZodCoercedNumber, ZodCoercedBigInt, ZodCoercedBoolean, ZodCoercedDate, } from "./coerce.js";
+export * as coerce from "./coerce.js";

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/from-json-schema.d.ts

@@ -0,0 +1,12 @@
+import type * as JSONSchema from "../core/json-schema.js";
+import { type $ZodRegistry } from "../core/registries.js";
+import type { ZodType } from "./schemas.js";
+type JSONSchemaVersion = "draft-2020-12" | "draft-7" | "draft-4" | "openapi-3.0";
+interface FromJSONSchemaParams {
+    defaultTarget?: JSONSchemaVersion;
+    registry?: $ZodRegistry<any>;
+}
+/**
+ * Converts a JSON Schema to a Zod schema. This function should be considered semi-experimental. It's behavior is liable to change. */
+export declare function fromJSONSchema(schema: JSONSchema.JSONSchema | boolean, params?: FromJSONSchemaParams): ZodType;
+export {};

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/index.d.ts

@@ -0,0 +1,4 @@
+import * as z from "./external.js";
+export { z };
+export * from "./external.js";
+export default z;

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/iso.d.ts

@@ -0,0 +1,22 @@
+import * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+export interface ZodISODateTime extends schemas.ZodStringFormat {
+    _zod: core.$ZodISODateTimeInternals;
+}
+export declare const ZodISODateTime: core.$constructor<ZodISODateTime>;
+export declare function datetime(params?: string | core.$ZodISODateTimeParams): ZodISODateTime;
+export interface ZodISODate extends schemas.ZodStringFormat {
+    _zod: core.$ZodISODateInternals;
+}
+export declare const ZodISODate: core.$constructor<ZodISODate>;
+export declare function date(params?: string | core.$ZodISODateParams): ZodISODate;
+export interface ZodISOTime extends schemas.ZodStringFormat {
+    _zod: core.$ZodISOTimeInternals;
+}
+export declare const ZodISOTime: core.$constructor<ZodISOTime>;
+export declare function time(params?: string | core.$ZodISOTimeParams): ZodISOTime;
+export interface ZodISODuration extends schemas.ZodStringFormat {
+    _zod: core.$ZodISODurationInternals;
+}
+export declare const ZodISODuration: core.$constructor<ZodISODuration>;
+export declare function duration(params?: string | core.$ZodISODurationParams): ZodISODuration;

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/parse.d.ts

@@ -0,0 +1,31 @@
+import * as core from "../core/index.js";
+import { type ZodError } from "./errors.js";
+export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+export type ZodSafeParseSuccess<T> = {
+    success: true;
+    data: T;
+    error?: never;
+};
+export type ZodSafeParseError<T> = {
+    success: false;
+    data?: never;
+    error: ZodError<T>;
+};
+export declare const parse: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
+    callee?: core.util.AnyFunc;
+    Err?: core.$ZodErrorClass;
+}) => core.output<T>;
+export declare const parseAsync: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
+    callee?: core.util.AnyFunc;
+    Err?: core.$ZodErrorClass;
+}) => Promise<core.output<T>>;
+export declare const safeParse: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
+export declare const safeParseAsync: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;
+export declare const encode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.input<T>;
+export declare const decode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.output<T>;
+export declare const encodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.input<T>>;
+export declare const decodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.output<T>>;
+export declare const safeEncode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.input<T>>;
+export declare const safeDecode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
+export declare const safeEncodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.input<T>>>;
+export declare const safeDecodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;