effect 4.0.0-beta.85 → 4.0.0-beta.86

package/src/testing/TestSchema.ts

@@ -12,6 +12,7 @@
 import * as assert from "node:assert"
 import type * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
+import { pipe } from "../Function.ts"
 import * as Record from "../Record.ts"
 import * as Result from "../Result.ts"
 import * as Schema from "../Schema.ts"
@@ -48,7 +49,7 @@ import * as FastCheck from "../testing/FastCheck.ts"
  * @category testing
  * @since 4.0.0
  */
-export class Asserts<S extends Schema.Top> {
+export class Asserts<S extends Schema.Constraint> {
   /**
    * Static helpers for comparing schema AST structures.
    *
@@ -313,7 +314,7 @@ export class Asserts<S extends Schema.Top> {
  * @category testing
  * @since 4.0.0
  */
-export class Decoding<S extends Schema.Top> {
+export class Decoding<S extends Schema.Constraint> {
   readonly schema: S
   readonly decodeUnknownEffect: (
     input: unknown,
@@ -350,16 +351,16 @@ export class Decoding<S extends Schema.Top> {
    *
    * @see {@link fail} for asserting decoding failures
    */
-  async succeed<S extends Schema.Decoder<unknown, never>>(
+  async succeed<S extends Schema.ConstraintDecoder<unknown, never>>(
     this: Decoding<S>,
     input: unknown
   ): Promise<void>
-  async succeed<S extends Schema.Decoder<unknown, never>>(
+  async succeed<S extends Schema.ConstraintDecoder<unknown, never>>(
     this: Decoding<S>,
     input: unknown,
     expected: S["Type"]
   ): Promise<void>
-  async succeed<S extends Schema.Decoder<unknown, never>>(
+  async succeed<S extends Schema.ConstraintDecoder<unknown, never>>(
     this: Decoding<S>,
     input: unknown,
     expected?: S["Type"]
@@ -393,7 +394,7 @@ export class Decoding<S extends Schema.Top> {
    *
    * @see {@link succeed} for asserting successful decoding
    */
-  async fail<S extends Schema.Decoder<unknown, never>>(
+  async fail<S extends Schema.ConstraintDecoder<unknown, never>>(
     this: Decoding<S>,
     input: unknown,
     message: string
@@ -420,7 +421,7 @@ export class Decoding<S extends Schema.Top> {
     implementation: Service
   ): Decoding<Schema.middlewareDecoding<S, Exclude<S["DecodingServices"], Id>>> {
     return new Decoding(
-      this.schema.pipe(Schema.middlewareDecoding(Effect.provideService(service, implementation))),
+      pipe(this.schema, Schema.middlewareDecoding(Effect.provideService(service, implementation))),
       this.options
     )
   }
@@ -453,7 +454,7 @@ export class Decoding<S extends Schema.Top> {
  * @category testing
  * @since 4.0.0
  */
-export class Encoding<S extends Schema.Top> {
+export class Encoding<S extends Schema.Constraint> {
   readonly schema: S
   readonly encodeUnknownEffect: (
     input: unknown,
@@ -490,16 +491,16 @@ export class Encoding<S extends Schema.Top> {
    *
    * @see {@link fail} for asserting encoding failures
    */
-  async succeed<S extends Schema.Encoder<unknown, never>>(
+  async succeed<S extends Schema.ConstraintEncoder<unknown, never>>(
     this: Encoding<S>,
     input: unknown
   ): Promise<void>
-  async succeed<S extends Schema.Encoder<unknown, never>>(
+  async succeed<S extends Schema.ConstraintEncoder<unknown, never>>(
     this: Encoding<S>,
     input: unknown,
     expected: S["Encoded"]
   ): Promise<void>
-  async succeed<S extends Schema.Encoder<unknown, never>>(
+  async succeed<S extends Schema.ConstraintEncoder<unknown, never>>(
     this: Encoding<S>,
     input: unknown,
     expected?: S["Encoded"]
@@ -533,7 +534,7 @@ export class Encoding<S extends Schema.Top> {
    *
    * @see {@link succeed} for asserting successful encoding
    */
-  async fail<S extends Schema.Encoder<unknown, never>>(
+  async fail<S extends Schema.ConstraintEncoder<unknown, never>>(
     this: Encoding<S>,
     input: unknown,
     message: string
@@ -560,7 +561,7 @@ export class Encoding<S extends Schema.Top> {
     implementation: Service
   ): Encoding<Schema.middlewareEncoding<S, Exclude<S["EncodingServices"], Id>>> {
     return new Encoding(
-      this.schema.pipe(Schema.middlewareEncoding(Effect.provideService(service, implementation))),
+      pipe(this.schema, Schema.middlewareEncoding(Effect.provideService(service, implementation))),
       this.options
     )
   }

package/src/unstable/ai/AnthropicStructuredOutput.ts

@@ -54,9 +54,9 @@ import * as Tool from "./Tool.ts"
  * @since 4.0.0
  */
 export function toCodecAnthropic<T, E, RD, RE>(
-  schema: Schema.Codec<T, E, RD, RE>
+  schema: Schema.ConstraintCodec<T, E, RD, RE>
 ): {
-  readonly codec: Schema.Codec<T, unknown, RD, RE>
+  readonly codec: Schema.ConstraintCodec<T, unknown, RD, RE>
   readonly jsonSchema: JsonSchema.JsonSchema
 } {
   const to = schema.ast

package/src/unstable/ai/Chat.ts

@@ -336,7 +336,7 @@ export interface Service {
    */
   readonly generateObject: <
     ObjectEncoded extends Record<string, any>,
-    ObjectSchema extends Schema.Encoder<ObjectEncoded, unknown>,
+    ObjectSchema extends Schema.Codec<unknown, ObjectEncoded, unknown, unknown>,
     Options extends NoExcessProperties<LanguageModel.GenerateObjectOptions<any, ObjectSchema>, Options>
   >(
     options: Options & LanguageModel.GenerateObjectOptions<LanguageModel.ExtractTools<Options>, ObjectSchema>

package/src/unstable/ai/LanguageModel.ts

@@ -124,7 +124,7 @@ export interface Service {
    */
   readonly generateObject: <
     ObjectEncoded extends Record<string, any>,
-    StructuredOutputSchema extends Schema.Encoder<ObjectEncoded, unknown>,
+    StructuredOutputSchema extends Schema.Codec<unknown, ObjectEncoded, unknown, unknown>,
     Options extends NoExcessProperties<
       GenerateObjectOptions<any, StructuredOutputSchema>,
       Options
@@ -191,8 +191,8 @@ export interface Service {
  * @category models
  * @since 4.0.0
  */
-export type CodecTransformer = <T, E, RD, RE>(schema: Schema.Codec<T, E, RD, RE>) => {
-  readonly codec: Schema.Codec<T, unknown, RD, RE>
+export type CodecTransformer = <T, E, RD, RE>(schema: Schema.ConstraintCodec<T, E, RD, RE>) => {
+  readonly codec: Schema.ConstraintCodec<T, unknown, RD, RE>
   readonly jsonSchema: JsonSchema.JsonSchema
 }
 
@@ -835,7 +835,7 @@ export const make: (params: {
 
   const generateObject = <
     ObjectEncoded extends Record<string, any>,
-    StructuredOutputSchema extends Schema.Encoder<ObjectEncoded, unknown>,
+    StructuredOutputSchema extends Schema.Codec<unknown, ObjectEncoded, unknown, unknown>,
     Options extends NoExcessProperties<
       GenerateObjectOptions<any, StructuredOutputSchema>,
       Options
@@ -1691,7 +1691,7 @@ export const generateText: {
  */
 export const generateObject = <
   ObjectEncoded extends Record<string, any>,
-  StructuredOutputSchema extends Schema.Encoder<ObjectEncoded, unknown>,
+  StructuredOutputSchema extends Schema.Codec<unknown, ObjectEncoded, unknown, unknown>,
   Options extends NoExcessProperties<
     GenerateObjectOptions<any, StructuredOutputSchema>,
     Options
@@ -2161,7 +2161,7 @@ const resolveToolkit = <Tools extends Record<string, Tool.Any>, E, R>(
     : Effect.succeed(toolkit as unknown as Toolkit.WithHandler<Tools>)) as any
 
 /** @internal */
-export const getObjectName = <StructuredOutputSchema extends Schema.Top>(
+export const getObjectName = <StructuredOutputSchema extends Schema.Constraint>(
   objectName: string | undefined,
   schema: StructuredOutputSchema
 ): string => {
@@ -2179,7 +2179,7 @@ export const getObjectName = <StructuredOutputSchema extends Schema.Top>(
 }
 
 const resolveStructuredOutput = Effect.fnUntraced(function*<
-  StructuredOutputSchema extends Schema.Top
+  StructuredOutputSchema extends Schema.Constraint
 >(response: ReadonlyArray<Response.AllParts<any>>, schema: StructuredOutputSchema) {
   const texts: Array<string> = []
   for (const part of response) {

package/src/unstable/ai/McpSchema.ts

@@ -35,7 +35,7 @@ import * as RpcMiddleware from "../rpc/RpcMiddleware.ts"
  * @category models
  * @since 4.0.0
  */
-export interface optionalWithDefault<S extends Schema.Top & Schema.WithoutConstructorDefault>
+export interface optionalWithDefault<S extends Schema.Constraint & Schema.WithoutConstructorDefault>
   extends Schema.withConstructorDefault<Schema.decodeTo<Schema.toType<Schema.optionalKey<S>>, Schema.optionalKey<S>>>
 {}
 
@@ -51,7 +51,7 @@ export interface optionalWithDefault<S extends Schema.Top & Schema.WithoutConstr
  * @category schemas
  * @since 4.0.0
  */
-export const optionalWithDefault = <S extends Schema.Top & Schema.WithoutConstructorDefault>(
+export const optionalWithDefault = <S extends Schema.Constraint & Schema.WithoutConstructorDefault>(
   schema: S,
   defaultValue: () => Schema.optionalKey<S>["Type"]
 ): optionalWithDefault<S> => {
@@ -78,7 +78,9 @@ export const optionalWithDefault = <S extends Schema.Top & Schema.WithoutConstru
  * @category schemas
  * @since 4.0.0
  */
-export const optional = <S extends Schema.Top>(schema: S): Schema.decodeTo<Schema.optional<S>, Schema.optionalKey<S>> =>
+export const optional = <S extends Schema.Constraint>(
+  schema: S
+): Schema.decodeTo<Schema.optional<S>, Schema.optionalKey<S>> =>
   Schema.optionalKey(schema).pipe(
     Schema.decodeTo(Schema.optional(schema), {
       decode: SchemaGetter.passthrough() as any,
@@ -2460,7 +2462,7 @@ const ParamSchemaTypeId = "~effect/ai/McpSchema/ParamSchema"
  * @category parameters
  * @since 4.0.0
  */
-export function isParam(schema: Schema.Top): schema is Param<string, Schema.Top> {
+export function isParam(schema: Schema.Constraint): schema is Param<string, Schema.Top> {
   return Predicate.hasProperty(schema, ParamSchemaTypeId)
 }
 
@@ -2475,18 +2477,11 @@ export function isParam(schema: Schema.Top): schema is Param<string, Schema.Top>
  * @category parameters
  * @since 4.0.0
  */
-export interface Param<Name extends string, S extends Schema.Top> extends
-  Schema.Bottom<
-    S["Type"],
-    S["Encoded"],
-    S["DecodingServices"],
-    S["EncodingServices"],
+export interface Param<Name extends string, S extends Schema.Constraint> extends
+  Schema.BottomLazy<
     S["ast"],
     Param<Name, S>,
-    S["~type.make.in"],
-    S["Iso"],
     S["~type.parameters"],
-    S["~type.make"],
     S["~type.mutability"],
     S["~type.optionality"],
     S["~type.constructor.default"],
@@ -2494,7 +2489,14 @@ export interface Param<Name extends string, S extends Schema.Top> extends
     S["~encoded.optionality"]
   >
 {
+  readonly "Type": S["Type"]
+  readonly "Encoded": S["Encoded"]
+  readonly "DecodingServices": S["DecodingServices"]
+  readonly "EncodingServices": S["EncodingServices"]
   readonly "Rebuild": Param<Name, S>
+  readonly "~type.make.in": S["~type.make.in"]
+  readonly "~type.make": S["~type.make"]
+  readonly "Iso": S["Iso"]
   readonly [ParamSchemaTypeId]: typeof ParamSchemaTypeId
   readonly name: Name
   readonly schema: S
@@ -2506,7 +2508,7 @@ export interface Param<Name extends string, S extends Schema.Top> extends
  * @category parameters
  * @since 4.0.0
  */
-export function param<const Name extends string, S extends Schema.Top>(
+export function param<const Name extends string, S extends Schema.Constraint>(
   name: Name,
   schema: S
 ): Param<Name, S> {

package/src/unstable/ai/McpServer.ts

@@ -782,7 +782,7 @@ export type ValidateCompletions<Completions, Keys extends string> =
  * @category models
  * @since 4.0.0
  */
-export type ResourceCompletions<Schemas extends ReadonlyArray<Schema.Top>> = {
+export type ResourceCompletions<Schemas extends ReadonlyArray<Schema.Constraint>> = {
   readonly [
     K in Extract<keyof Schemas, `${number}`> as Schemas[K] extends Param<infer Id, infer _S> ? Id
       : `param${K}`
@@ -848,7 +848,7 @@ export const registerResource: {
    * @category resources
    * @since 4.0.0
    */
-  <const Schemas extends ReadonlyArray<Schema.Top>>(segments: TemplateStringsArray, ...schemas: Schemas): <
+  <const Schemas extends ReadonlyArray<Schema.Constraint>>(segments: TemplateStringsArray, ...schemas: Schemas): <
     E,
     R,
     const Completions extends Partial<ResourceCompletions<Schemas>> = {}
@@ -1035,7 +1035,7 @@ export const resource: {
    * @category resources
    * @since 4.0.0
    */
-  <const Schemas extends ReadonlyArray<Schema.Top>>(segments: TemplateStringsArray, ...schemas: Schemas): <
+  <const Schemas extends ReadonlyArray<Schema.Constraint>>(segments: TemplateStringsArray, ...schemas: Schemas): <
     E,
     R,
     const Completions extends Partial<ResourceCompletions<Schemas>> = {}
@@ -1112,7 +1112,7 @@ export const registerPrompt = <
   }
 ): Effect.Effect<void, never, Exclude<Schema.Struct.DecodingServices<Params> | R, McpServerClient> | McpServer> => {
   const args = Arr.empty<typeof PromptArgument.Type>()
-  const props: Record<string, Schema.Top> = options.parameters ?? {}
+  const props: Record<string, Schema.Constraint> = options.parameters ?? {}
   for (const [name, prop] of Object.entries(props)) {
     args.push({
       name,
@@ -1236,14 +1236,14 @@ export const prompt = <
  * @category elicitation
  * @since 4.0.0
  */
-export const elicit: <S extends Schema.Encoder<Record<string, unknown>, unknown>>(options: {
+export const elicit: <S extends Schema.ConstraintEncoder<Record<string, unknown>, unknown>>(options: {
   readonly message: string
   readonly schema: S
 }) => Effect.Effect<
   S["Type"],
   ElicitationDeclined,
   McpServerClient | S["DecodingServices"]
-> = Effect.fnUntraced(function*<S extends Schema.Encoder<Record<string, unknown>, unknown>>(options: {
+> = Effect.fnUntraced(function*<S extends Schema.ConstraintEncoder<Record<string, unknown>, unknown>>(options: {
   readonly message: string
   readonly schema: S
 }) {
@@ -1297,7 +1297,7 @@ const makeUriMatcher = <A>() => {
   return { add, find } as const
 }
 
-const compileUriTemplate = (segments: TemplateStringsArray, ...schemas: ReadonlyArray<Schema.Top>) => {
+const compileUriTemplate = (segments: TemplateStringsArray, ...schemas: ReadonlyArray<Schema.Constraint>) => {
   let routerPath = segments[0].replace(":", "::")
   let uriPath = segments[0]
   const params: Record<string, Schema.Top> = {}

package/src/unstable/ai/OpenAiStructuredOutput.ts

@@ -51,9 +51,9 @@ import * as Tool from "./Tool.ts"
  * @since 4.0.0
  */
 export function toCodecOpenAI<T, E, RD, RE>(
-  schema: Schema.Codec<T, E, RD, RE>
+  schema: Schema.ConstraintCodec<T, E, RD, RE>
 ): {
-  codec: Schema.Codec<T, unknown, RD, RE>
+  codec: Schema.ConstraintCodec<T, unknown, RD, RE>
   jsonSchema: JsonSchema.JsonSchema
 } {
   const to = schema.ast

package/src/unstable/ai/Response.ts

@@ -1382,7 +1382,7 @@ export interface ToolCallPartMetadata extends ProviderMetadata {}
  * @category schemas
  * @since 4.0.0
  */
-export const ToolCallPart: <const Name extends string, Params extends Schema.Top>(
+export const ToolCallPart: <const Name extends string, Params extends Schema.Constraint>(
   name: Name,
   params: Params
 ) => Schema.Struct<
@@ -1397,7 +1397,7 @@ export const ToolCallPart: <const Name extends string, Params extends Schema.Top
       Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>
     >
   }
-> = <const Name extends string, Params extends Schema.Top>(
+> = <const Name extends string, Params extends Schema.Constraint>(
   name: Name,
   params: Params
 ) =>
@@ -1595,7 +1595,11 @@ export interface ToolResultPartMetadata extends ProviderMetadata {}
  * @category schemas
  * @since 4.0.0
  */
-export const ToolResultPart: <const Name extends string, Success extends Schema.Top, Failure extends Schema.Top>(
+export const ToolResultPart: <
+  const Name extends string,
+  Success extends Schema.Constraint,
+  Failure extends Schema.Constraint
+>(
   name: Name,
   success: Success,
   failure: Failure
@@ -1633,8 +1637,8 @@ export const ToolResultPart: <const Name extends string, Success extends Schema.
   >
 > = <
   const Name extends string,
-  Success extends Schema.Top,
-  Failure extends Schema.Top
+  Success extends Schema.Constraint,
+  Failure extends Schema.Constraint
 >(
   name: Name,
   success: Success,

package/src/unstable/ai/Tool.ts

@@ -139,7 +139,7 @@ export interface NeedsApprovalContext {
  * @category models
  * @since 4.0.0
  */
-export type NeedsApprovalFunction<Params extends Schema.Top> = (
+export type NeedsApprovalFunction<Params extends Schema.Constraint> = (
   params: Params["Type"],
   context: NeedsApprovalContext
 ) => boolean | Effect.Effect<boolean>
@@ -156,7 +156,7 @@ export type NeedsApprovalFunction<Params extends Schema.Top> = (
  * @category models
  * @since 4.0.0
  */
-export type NeedsApproval<Params extends Schema.Top> =
+export type NeedsApproval<Params extends Schema.Constraint> =
   | boolean
   | NeedsApprovalFunction<Params>
 
@@ -196,9 +196,9 @@ export type NeedsApproval<Params extends Schema.Top> =
 export interface Tool<
   out Name extends string,
   out Config extends {
-    readonly parameters: Schema.Top
-    readonly success: Schema.Top
-    readonly failure: Schema.Top
+    readonly parameters: Schema.Constraint
+    readonly success: Schema.Constraint
+    readonly failure: Schema.Constraint
     readonly failureMode: FailureMode
   },
   out Requirements = never
@@ -290,7 +290,7 @@ export interface Tool<
   /**
    * Set the schema to use to validate the result of a tool call when successful.
    */
-  setSuccess<SuccessSchema extends Schema.Top>(
+  setSuccess<SuccessSchema extends Schema.Constraint>(
     schema: SuccessSchema
   ): Tool<
     Name,
@@ -306,7 +306,7 @@ export interface Tool<
   /**
    * Set the schema to use to validate the result of a tool call when it fails.
    */
-  setFailure<FailureSchema extends Schema.Top>(
+  setFailure<FailureSchema extends Schema.Constraint>(
     schema: FailureSchema
   ): Tool<
     Name,
@@ -322,7 +322,7 @@ export interface Tool<
   /**
    * Set the schema to use to validate the parameters of a tool call.
    */
-  setParameters<ParametersSchema extends Schema.Top>(
+  setParameters<ParametersSchema extends Schema.Constraint>(
     schema: ParametersSchema
   ): Tool<
     Name,
@@ -387,10 +387,10 @@ export interface ProviderDefined<
   out Identifier extends `${string}.${string}`,
   out Name extends string,
   out Config extends {
-    readonly args: Schema.Top
-    readonly parameters: Schema.Top
-    readonly success: Schema.Top
-    readonly failure: Schema.Top
+    readonly args: Schema.Constraint
+    readonly parameters: Schema.Constraint
+    readonly success: Schema.Constraint
+    readonly failure: Schema.Constraint
     readonly failureMode: FailureMode
   },
   out RequiresHandler extends boolean = false
@@ -481,9 +481,9 @@ export interface ProviderDefined<
 export interface Dynamic<
   out Name extends string,
   out Config extends {
-    readonly parameters: Schema.Top | JsonSchema.JsonSchema
-    readonly success: Schema.Top
-    readonly failure: Schema.Top
+    readonly parameters: Schema.Constraint | JsonSchema.JsonSchema
+    readonly success: Schema.Constraint
+    readonly failure: Schema.Constraint
     readonly failureMode: FailureMode
   },
   out Requirements = never
@@ -491,7 +491,7 @@ export interface Dynamic<
   Tool<
     Name,
     {
-      readonly parameters: Config["parameters"] extends Schema.Top ? Config["parameters"] : typeof Schema.Unknown
+      readonly parameters: Config["parameters"] extends Schema.Constraint ? Config["parameters"] : typeof Schema.Unknown
       readonly success: Config["success"]
       readonly failure: Config["failure"]
       readonly failureMode: Config["failureMode"]
@@ -505,7 +505,7 @@ export interface Dynamic<
    * The raw JSON Schema for parameters. Present when `parameters` was provided
    * as a JSON Schema, `undefined` when an Effect Schema was used.
    */
-  readonly jsonSchema: Config["parameters"] extends Schema.Top ? undefined : JsonSchema.JsonSchema
+  readonly jsonSchema: Config["parameters"] extends Schema.Constraint ? undefined : JsonSchema.JsonSchema
 }
 
 // =============================================================================
@@ -1036,16 +1036,16 @@ const Proto = {
   addDependency(this: Any) {
     return userDefinedProto({ ...this })
   },
-  setParameters(this: Any, parametersSchema: Schema.Top) {
+  setParameters(this: Any, parametersSchema: Schema.Constraint) {
     return userDefinedProto({
       ...this,
       parametersSchema
     })
   },
-  setSuccess(this: Any, successSchema: Schema.Top) {
+  setSuccess(this: Any, successSchema: Schema.Constraint) {
     return userDefinedProto({ ...this, successSchema })
   },
-  setFailure(this: Any, failureSchema: Schema.Top) {
+  setFailure(this: Any, failureSchema: Schema.Constraint) {
     return userDefinedProto({ ...this, failureSchema })
   },
   annotate<I, S>(this: Any, tag: Context.Key<I, S>, value: S) {
@@ -1074,9 +1074,9 @@ const DynamicProto = {
 
 const userDefinedProto = <
   const Name extends string,
-  Parameters extends Schema.Top,
-  Success extends Schema.Top,
-  Failure extends Schema.Top,
+  Parameters extends Schema.Constraint,
+  Success extends Schema.Constraint,
+  Failure extends Schema.Constraint,
   Mode extends FailureMode
 >(options: {
   readonly name: Name
@@ -1104,10 +1104,10 @@ const userDefinedProto = <
 const providerDefinedProto = <
   const Identifier extends `${string}.${string}`,
   const Name extends string,
-  Args extends Schema.Top,
-  Parameters extends Schema.Top,
-  Success extends Schema.Top,
-  Failure extends Schema.Top,
+  Args extends Schema.Constraint,
+  Parameters extends Schema.Constraint,
+  Success extends Schema.Constraint,
+  Failure extends Schema.Constraint,
   RequiresHandler extends boolean,
   Mode extends FailureMode
 >(options: {
@@ -1136,9 +1136,9 @@ const providerDefinedProto = <
 
 const dynamicProto = <
   const Name extends string,
-  Parameters extends Schema.Top | JsonSchema.JsonSchema,
-  Success extends Schema.Top,
-  Failure extends Schema.Top,
+  Parameters extends Schema.Constraint | JsonSchema.JsonSchema,
+  Success extends Schema.Constraint,
+  Failure extends Schema.Constraint,
   Mode extends FailureMode
 >(options: {
   readonly name: Name
@@ -1194,9 +1194,9 @@ const dynamicProto = <
  */
 export const make = <
   const Name extends string,
-  Parameters extends Schema.Top = typeof EmptyParams,
-  Success extends Schema.Top = typeof Schema.Void,
-  Failure extends Schema.Top = typeof Schema.Never,
+  Parameters extends Schema.Constraint = typeof EmptyParams,
+  Success extends Schema.Constraint = typeof Schema.Void,
+  Failure extends Schema.Constraint = typeof Schema.Never,
   Mode extends FailureMode | undefined = undefined,
   Dependencies extends Array<Context.Key<any, any> | Context.Key<never, any>> = []
 >(name: Name, options?: {
@@ -1361,21 +1361,23 @@ export const dynamic: {
     const Name extends string,
     const Options extends {
       readonly description?: string | undefined
-      readonly parameters?: Schema.Top | JsonSchema.JsonSchema | undefined
-      readonly success?: Schema.Top | undefined
-      readonly failure?: Schema.Top | undefined
+      readonly parameters?: Schema.Constraint | JsonSchema.JsonSchema | undefined
+      readonly success?: Schema.Constraint | undefined
+      readonly failure?: Schema.Constraint | undefined
       readonly failureMode?: FailureMode | undefined
       readonly needsApproval?: NeedsApproval<any> | undefined
     }
   >(name: Name, options?: Options): Dynamic<
     Name,
     {
-      readonly parameters: Options extends { readonly parameters: infer P } ? P extends Schema.Top ? P
+      readonly parameters: Options extends { readonly parameters: infer P } ? P extends Schema.Constraint ? P
         : P extends JsonSchema.JsonSchema ? P
         : typeof Schema.Unknown
         : typeof Schema.Unknown
-      readonly success: Options extends { readonly success: infer S extends Schema.Top } ? S : typeof Schema.Unknown
-      readonly failure: Options extends { readonly failure: infer F extends Schema.Top } ? F : typeof Schema.Never
+      readonly success: Options extends { readonly success: infer S extends Schema.Constraint } ? S
+        : typeof Schema.Unknown
+      readonly failure: Options extends { readonly failure: infer F extends Schema.Constraint } ? F
+        : typeof Schema.Never
       readonly failureMode: Options extends { readonly failureMode: infer M extends FailureMode } ? M : "error"
     }
   >
@@ -1383,9 +1385,9 @@ export const dynamic: {
   const Name extends string,
   const Options extends {
     readonly description?: string | undefined
-    readonly parameters?: Schema.Top | JsonSchema.JsonSchema | undefined
-    readonly success?: Schema.Top | undefined
-    readonly failure?: Schema.Top | undefined
+    readonly parameters?: Schema.Constraint | JsonSchema.JsonSchema | undefined
+    readonly success?: Schema.Constraint | undefined
+    readonly failure?: Schema.Constraint | undefined
     readonly failureMode?: FailureMode | undefined
     readonly needsApproval?: NeedsApproval<any> | undefined
   }
@@ -1449,10 +1451,10 @@ export const dynamic: {
 export const providerDefined = <
   const Identifier extends `${string}.${string}`,
   const Name extends string,
-  Args extends Schema.Top = typeof Schema.Void,
-  Parameters extends Schema.Top = typeof Schema.Void,
-  Success extends Schema.Top = typeof Schema.Void,
-  Failure extends Schema.Top = typeof Schema.Never,
+  Args extends Schema.Constraint = typeof Schema.Void,
+  Parameters extends Schema.Constraint = typeof Schema.Void,
+  Success extends Schema.Constraint = typeof Schema.Void,
+  Failure extends Schema.Constraint = typeof Schema.Never,
   RequiresHandler extends boolean = false
 >(options: {
   /**
@@ -1705,7 +1707,7 @@ export const getJsonSchema = <Tool extends Any>(tool: Tool, options?: {
  * @category converting
  * @since 4.0.0
  */
-export const getJsonSchemaFromSchema = <S extends Schema.Top>(schema: S, options?: {
+export const getJsonSchemaFromSchema = <S extends Schema.Constraint>(schema: S, options?: {
   readonly transformer?: CodecTransformer
 }): JsonSchema.JsonSchema => {
   if (Predicate.isNotUndefined(options?.transformer)) {