effect 4.0.0-beta.102 → 4.0.0-beta.104

package/src/unstable/ai/Tool.ts

@@ -171,7 +171,7 @@ export type NeedsApproval<Params extends Schema.Constraint> =
  *
  * **Example** (Defining a weather lookup tool)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -188,6 +188,7 @@ export type NeedsApproval<Params extends Schema.Constraint> =
  *     humidity: Schema.Number
  *   })
  * })
+ * const result = [GetWeather.name, GetWeather.failureMode] // => ["GetWeather", "error"]
  * ```
  *
  * @category models
@@ -365,7 +366,7 @@ export interface Tool<
  *
  * **Example** (Defining a provider-defined web search tool)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -384,7 +385,8 @@ export interface Tool<
  *       snippet: Schema.String
  *     }))
  *   })
- * })
+ * })({ query: "Effect" })
+ * const result = [WebSearch.name, WebSearch.providerName] // => ["OpenAiWebSearch", "web_search"]
  * ```
  *
  * @category models
@@ -457,7 +459,7 @@ export interface ProviderDefined<
  *
  * **Example** (Defining dynamic tools)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -480,6 +482,8 @@ export interface ProviderDefined<
  *     required: ["query"]
  *   }
  * })
+ *
+ * const result = [Calculator.name, McpTool.name] // => ["Calculator", "McpTool"]
  * ```
  *
  * @category models
@@ -524,7 +528,7 @@ export interface Dynamic<
  *
  * **Example** (Checking for user-defined tools)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -554,8 +558,7 @@ export interface Dynamic<
  *   })
  * })
  *
- * console.log(Tool.isUserDefined(UserDefinedTool)) // true
- * console.log(Tool.isUserDefined(ProviderDefinedTool)) // false
+ * const result = [Tool.isUserDefined(UserDefinedTool), Tool.isUserDefined(ProviderDefinedTool)] // => [true, false]
  * ```
  *
  * @category guards
@@ -569,7 +572,7 @@ export const isUserDefined = (u: unknown): u is Tool<string, any, any> =>
  *
  * **Example** (Checking for provider-defined tools)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -599,8 +602,7 @@ export const isUserDefined = (u: unknown): u is Tool<string, any, any> =>
  *   })
  * })
  *
- * console.log(Tool.isProviderDefined(UserDefinedTool)) // false
- * console.log(Tool.isProviderDefined(ProviderDefinedTool)) // true
+ * const result = [Tool.isProviderDefined(UserDefinedTool), Tool.isProviderDefined(ProviderDefinedTool)] // => [false, false]
  * ```
  *
  * @category guards
@@ -615,7 +617,7 @@ export const isProviderDefined = (
  *
  * **Example** (Checking for dynamic tools)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -628,8 +630,7 @@ export const isProviderDefined = (
  *   success: Schema.Number
  * })
  *
- * console.log(Tool.isDynamic(DynamicTool)) // true
- * console.log(Tool.isDynamic(UserDefinedTool)) // false
+ * const result = [Tool.isDynamic(DynamicTool), Tool.isDynamic(UserDefinedTool)] // => [true, false]
  * ```
  *
  * @category guards
@@ -1185,7 +1186,7 @@ const dynamicProto = <
  *
  * **Example** (Creating a tool without parameters)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -1194,6 +1195,7 @@ const dynamicProto = <
  *   description: "Returns the current timestamp",
  *   success: Schema.Number
  * })
+ * GetCurrentTime.name // => "GetCurrentTime"
  * ```
  *
  * @category constructors
@@ -1291,7 +1293,7 @@ export const make = <
  *
  * **Example** (Creating a dynamic tool)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -1314,6 +1316,8 @@ export const make = <
  *     required: ["query"]
  *   }
  * })
+ *
+ * const result = [Calculator.name, McpTool.name] // => ["Calculator", "McpTool"]
  * ```
  *
  * @category constructors
@@ -1336,7 +1340,7 @@ export const dynamic: {
    *
    * **Example** (Creating a dynamic tool)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { Tool } from "effect/unstable/ai"
    *
@@ -1359,6 +1363,8 @@ export const dynamic: {
    *     required: ["query"]
    *   }
    * })
+   *
+   * const result = [Calculator.name, McpTool.name] // => ["Calculator", "McpTool"]
    * ```
    *
    * @category constructors
@@ -1430,7 +1436,7 @@ export const dynamic: {
  *
  * **Example** (Creating a provider-defined tool)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -1449,7 +1455,8 @@ export const dynamic: {
  *       content: Schema.String
  *     }))
  *   })
- * })
+ * })({ query: "Effect" })
+ * const result = [WebSearch.name, WebSearch.providerName] // => ["OpenAiWebSearch", "web_search"]
  * ```
  *
  * @category constructors
@@ -1627,7 +1634,7 @@ export class NameMapper<Tools extends ReadonlyArray<Any>> {
  *
  * **Example** (Reading a tool description)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Tool } from "effect/unstable/ai"
  *
  * const myTool = Tool.make("example", {
@@ -1635,7 +1642,7 @@ export class NameMapper<Tools extends ReadonlyArray<Any>> {
  * })
  *
  * const description = Tool.getDescription(myTool)
- * console.log(description) // "This is an example tool"
+ * description // => "This is an example tool"
  * ```
  *
  * @category getters
@@ -1666,7 +1673,7 @@ export const getDescription = <Tool extends Any>(tool: Tool): string | undefined
  *
  * **Example** (Generating a tool JSON schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
@@ -1678,15 +1685,10 @@ export const getDescription = <Tool extends Any>(tool: Tool): string | undefined
  * })
  *
  * const jsonSchema = Tool.getJsonSchema(weatherTool)
- * console.log(jsonSchema)
- * // {
- * //   type: "object",
- * //   properties: {
- * //     location: { type: "string" },
- * //     units: { type: "string", enum: ["celsius", "fahrenheit"] }
- * //   },
- * //   required: ["location", "units"]
- * // }
+ * jsonSchema.type // => "object"
+ * if (typeof jsonSchema.properties === "object" && jsonSchema.properties !== null) {
+ *   Object.keys(jsonSchema.properties) // => ["location", "units"]
+ * }
  * ```
  *
  * @category getters
@@ -1744,14 +1746,16 @@ const getJsonSchemaFromSchemaWith = <S extends Schema.Constraint>(
  *
  * **Example** (Annotating a tool title)
  *
- * ```ts
+ * ```ts import.meta.vitest
+ * import { Context } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
  * const myTool = Tool.make("calculate_tip")
  *   .annotate(Tool.Title, "Tip Calculator")
+ * Context.getUnsafe(myTool.annotations, Tool.Title) // => "Tip Calculator"
  * ```
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export class Title extends Context.Service<Title, string>()("effect/ai/Tool/Title") {}
@@ -1761,14 +1765,16 @@ export class Title extends Context.Service<Title, string>()("effect/ai/Tool/Titl
  *
  * **Example** (Annotating MCP metadata)
  *
- * ```ts
+ * ```ts import.meta.vitest
+ * import { Context } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
  * const myCalculatorUi = Tool.make("calculator_ui", {})
  *   .annotate(Tool.Meta, { ui: { resourceUri: "ui://example/calculator-ui" } })
+ * "ui" in Context.getUnsafe(myCalculatorUi.annotations, Tool.Meta) // => true
  * ```
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export class Meta extends Context.Service<Meta, Record<string, unknown>>()("effect/ai/Tool/Meta") {}
@@ -1783,14 +1789,16 @@ export class Meta extends Context.Service<Meta, Record<string, unknown>>()("effe
  *
  * **Example** (Marking a tool as read-only)
  *
- * ```ts
+ * ```ts import.meta.vitest
+ * import { Context } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
  * const readOnlyTool = Tool.make("get_user_info")
  *   .annotate(Tool.Readonly, true)
+ * Context.get(readOnlyTool.annotations, Tool.Readonly) // => true
  * ```
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const Readonly = Context.Reference<boolean>("effect/ai/Tool/Readonly", {
@@ -1807,14 +1815,16 @@ export const Readonly = Context.Reference<boolean>("effect/ai/Tool/Readonly", {
  *
  * **Example** (Marking a tool as non-destructive)
  *
- * ```ts
+ * ```ts import.meta.vitest
+ * import { Context } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
  * const safeTool = Tool.make("search_database")
  *   .annotate(Tool.Destructive, false)
+ * Context.get(safeTool.annotations, Tool.Destructive) // => false
  * ```
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const Destructive = Context.Reference<boolean>("effect/ai/Tool/Destructive", {
@@ -1832,14 +1842,16 @@ export const Destructive = Context.Reference<boolean>("effect/ai/Tool/Destructiv
  *
  * **Example** (Marking a tool as idempotent)
  *
- * ```ts
+ * ```ts import.meta.vitest
+ * import { Context } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
  * const idempotentTool = Tool.make("get_current_time")
  *   .annotate(Tool.Idempotent, true)
+ * Context.get(idempotentTool.annotations, Tool.Idempotent) // => true
  * ```
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const Idempotent = Context.Reference<boolean>("effect/ai/Tool/Idempotent", {
@@ -1857,14 +1869,16 @@ export const Idempotent = Context.Reference<boolean>("effect/ai/Tool/Idempotent"
  *
  * **Example** (Disabling open-world access)
  *
- * ```ts
+ * ```ts import.meta.vitest
+ * import { Context } from "effect"
  * import { Tool } from "effect/unstable/ai"
  *
  * const restrictedTool = Tool.make("internal_operation")
  *   .annotate(Tool.OpenWorld, false)
+ * Context.get(restrictedTool.annotations, Tool.OpenWorld) // => false
  * ```
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const OpenWorld = Context.Reference<boolean>("effect/ai/Tool/OpenWorld", {
@@ -1886,14 +1900,15 @@ export const OpenWorld = Context.Reference<boolean>("effect/ai/Tool/OpenWorld",
  *
  * **Example** (Disabling strict JSON schema mode)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Tool } from "effect/unstable/ai"
  *
  * const flexibleTool = Tool.make("search")
  *   .annotate(Tool.Strict, false)
+ * Tool.getStrictMode(flexibleTool) // => false
  * ```
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const Strict = Context.Reference<boolean | undefined>("effect/ai/Tool/Strict", {

package/src/unstable/ai/Toolkit.ts

@@ -33,8 +33,8 @@ const TypeId = "~effect/ai/Toolkit" as const
  *
  * **Example** (Defining AI toolkits)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Schema } from "effect"
  * import { Tool, Toolkit } from "effect/unstable/ai"
  *
  * const SearchDocs = Tool.make("SearchDocs", {
@@ -51,8 +51,12 @@ const TypeId = "~effect/ai/Toolkit" as const
  *
  * const AiToolkit = Toolkit.make(SearchDocs, SummarizeText)
  *
- * console.log(Object.keys(AiToolkit.tools))
- * // ["SearchDocs", "SummarizeText"]
+ * const ready = AiToolkit.pipe(Effect.provide(AiToolkit.toLayer({
+ *   SearchDocs: ({ query }) => Effect.succeed([query]),
+ *   SummarizeText: ({ text }) => Effect.succeed(text)
+ * })))
+ *
+ * Object.keys((await Effect.runPromise(ready)).tools) // => ["SearchDocs", "SummarizeText"]
  * ```
  *
  * @category models
@@ -459,8 +463,8 @@ export const empty: Toolkit<{}> = makeProto({})
  *
  * **Example** (Creating a toolkit)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Schema } from "effect"
  * import { Tool, Toolkit } from "effect/unstable/ai"
  *
  * const GetCurrentTime = Tool.make("GetCurrentTime", {
@@ -478,6 +482,12 @@ export const empty: Toolkit<{}> = makeProto({})
  * })
  *
  * const toolkit = Toolkit.make(GetCurrentTime, GetWeather)
+ * const ready = toolkit.pipe(Effect.provide(toolkit.toLayer({
+ *   GetCurrentTime: () => Effect.succeed(0),
+ *   get_weather: () => Effect.succeed({ temperature: 20, condition: "clear" })
+ * })))
+ *
+ * Object.keys((await Effect.runPromise(ready)).tools) // => ["GetCurrentTime", "get_weather"]
  * ```
  *
  * @category constructors
@@ -530,8 +540,8 @@ export type MergedTools<Toolkits extends ReadonlyArray<Any>> = SimplifyRecord<
  *
  * **Example** (Merging toolkits)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Schema } from "effect"
  * import { Tool, Toolkit } from "effect/unstable/ai"
  *
  * const mathToolkit = Toolkit.make(
@@ -545,6 +555,14 @@ export type MergedTools<Toolkits extends ReadonlyArray<Any>> = SimplifyRecord<
  * )
  *
  * const combined = Toolkit.merge(mathToolkit, utilityToolkit)
+ * const ready = combined.pipe(Effect.provide(combined.toLayer({
+ *   add: () => Effect.succeed(1),
+ *   subtract: () => Effect.succeed(0),
+ *   get_time: () => Effect.succeed(0),
+ *   get_weather: () => Effect.succeed("clear")
+ * })))
+ *
+ * Object.keys((await Effect.runPromise(ready)).tools) // => ["add", "subtract", "get_time", "get_weather"]
  * ```
  *
  * @category constructors

package/src/unstable/ai/index.ts

@@ -34,6 +34,11 @@ export * as IdGenerator from "./IdGenerator.ts"
  */
 export * as LanguageModel from "./LanguageModel.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as McpProtocol from "./McpProtocol.ts"
+
 /**
  * @since 4.0.0
  */

package/src/unstable/ai/internal/mcpProtocol.ts

@@ -0,0 +1,85 @@
+import type * as Effect from "../../../Effect.ts"
+import * as Schema from "../../../Schema.ts"
+import type * as Rpc from "../../rpc/Rpc.ts"
+import type * as RpcGroup from "../../rpc/RpcGroup.ts"
+
+export interface PayloadCodecs {
+  readonly decode: (input: unknown) => Effect.Effect<unknown, Schema.SchemaError>
+  readonly encode: (input: unknown) => Effect.Effect<unknown, Schema.SchemaError>
+}
+
+/** @internal */
+export interface AnyProtocolAdapter {
+  readonly protocolVersion: string
+  readonly transport: {
+    readonly acceptsJsonRpcBatches: boolean
+    readonly requiresVersionHeader: boolean
+  }
+  readonly clientRpcs: RpcGroup.Any
+  readonly clientNotificationRpcs: RpcGroup.Any
+  readonly serverRequestRpcs: RpcGroup.Any
+  readonly serverNotificationRpcs: RpcGroup.Any
+  readonly payloadCodecs: (rpc: Rpc.AnyWithProps) => PayloadCodecs
+}
+
+export interface ProtocolAdapter<
+  out Version extends string = string,
+  ClientRpcs extends Rpc.Any = Rpc.Any,
+  ClientNotificationRpcs extends ClientRpcs = ClientRpcs,
+  ServerRequestRpcs extends Rpc.Any = Rpc.Any,
+  ServerNotificationRpcs extends Rpc.Any = Rpc.Any
+> {
+  readonly protocolVersion: Version
+  readonly transport: {
+    readonly acceptsJsonRpcBatches: boolean
+    readonly requiresVersionHeader: boolean
+  }
+  readonly clientRpcs: RpcGroup.RpcGroup<ClientRpcs>
+  readonly clientNotificationRpcs: RpcGroup.RpcGroup<ClientNotificationRpcs>
+  readonly serverRequestRpcs: RpcGroup.RpcGroup<ServerRequestRpcs>
+  readonly serverNotificationRpcs: RpcGroup.RpcGroup<ServerNotificationRpcs>
+  readonly payloadCodecs: (rpc: Rpc.AnyWithProps) => PayloadCodecs
+}
+
+/** @internal */
+export const make = <
+  const Version extends string,
+  ClientRpcs extends Rpc.Any,
+  ClientNotificationRpcs extends ClientRpcs,
+  ServerRequestRpcs extends Rpc.Any,
+  ServerNotificationRpcs extends Rpc.Any
+>(options: {
+  readonly protocolVersion: Version
+  readonly transport: {
+    readonly acceptsJsonRpcBatches: boolean
+    readonly requiresVersionHeader: boolean
+  }
+  readonly clientRpcs: RpcGroup.RpcGroup<ClientRpcs>
+  readonly clientNotificationRpcs: RpcGroup.RpcGroup<ClientNotificationRpcs>
+  readonly serverRequestRpcs: RpcGroup.RpcGroup<ServerRequestRpcs>
+  readonly serverNotificationRpcs: RpcGroup.RpcGroup<ServerNotificationRpcs>
+}): ProtocolAdapter<
+  Version,
+  ClientRpcs,
+  ClientNotificationRpcs,
+  ServerRequestRpcs,
+  ServerNotificationRpcs
+> => {
+  const payloadCodecsCache = new WeakMap<Rpc.AnyWithProps, PayloadCodecs>()
+  const payloadCodecs = (rpc: Rpc.AnyWithProps): PayloadCodecs => {
+    let codecs = payloadCodecsCache.get(rpc)
+    if (codecs === undefined) {
+      const schema = Schema.toCodecJson(rpc.payloadSchema)
+      codecs = {
+        decode: Schema.decodeUnknownEffect(schema) as PayloadCodecs["decode"],
+        encode: Schema.encodeUnknownEffect(schema) as PayloadCodecs["encode"]
+      }
+      payloadCodecsCache.set(rpc, codecs)
+    }
+    return codecs
+  }
+  return {
+    ...options,
+    payloadCodecs
+  }
+}

package/src/unstable/ai/internal/mcpProtocolRegistry.ts

@@ -0,0 +1,70 @@
+import type { NonEmptyReadonlyArray } from "../../../Array.ts"
+import * as Cause from "../../../Cause.ts"
+import * as Effect from "../../../Effect.ts"
+import type * as RpcGroup from "../../rpc/RpcGroup.ts"
+import type * as RpcMessage from "../../rpc/RpcMessage.ts"
+import type * as McpProtocol from "./mcpProtocol.ts"
+
+type AnyRpcGroup = RpcGroup.RpcGroup<any>
+
+const prefix = (protocol: McpProtocol.AnyProtocolAdapter): string =>
+  `@effect/mcp/${encodeURIComponent(protocol.protocolVersion)}/`
+
+const asRpcGroup = (group: RpcGroup.Any): AnyRpcGroup => group as unknown as AnyRpcGroup
+
+/** @internal */
+export interface ProtocolRegistry<
+  Protocol extends McpProtocol.AnyProtocolAdapter = McpProtocol.AnyProtocolAdapter
+> {
+  readonly protocols: NonEmptyReadonlyArray<Protocol>
+  readonly clientRpcs: AnyRpcGroup
+  readonly select: (offeredVersion: string) => Protocol
+  readonly routeClientRequest: (
+    protocol: Protocol,
+    request: RpcMessage.RequestEncoded
+  ) => RpcMessage.RequestEncoded
+}
+
+/** @internal */
+export const make = Effect.fnUntraced(function*<
+  const Protocols extends NonEmptyReadonlyArray<McpProtocol.AnyProtocolAdapter>
+>(
+  protocols: Protocols
+) {
+  type Protocol = Protocols[number]
+
+  if (protocols.length === 0) {
+    return yield* new Cause.IllegalArgumentError(
+      "MCP protocol declaration must contain at least one MCP protocol"
+    )
+  }
+
+  const snapshot = Object.freeze(Array.from(protocols)) as NonEmptyReadonlyArray<Protocol>
+  const byVersion = new Map<string, Protocol>()
+  for (const protocol of snapshot) {
+    if (byVersion.has(protocol.protocolVersion)) {
+      return yield* new Cause.IllegalArgumentError(
+        `Duplicate MCP protocol version: ${protocol.protocolVersion}`
+      )
+    }
+    byVersion.set(protocol.protocolVersion, protocol)
+  }
+
+  let clientRpcs = asRpcGroup(snapshot[0].clientRpcs).prefix(prefix(snapshot[0]))
+  for (let i = 1; i < snapshot.length; i++) {
+    clientRpcs = clientRpcs.merge(asRpcGroup(snapshot[i].clientRpcs).prefix(prefix(snapshot[i])))
+  }
+
+  return {
+    protocols: snapshot,
+    clientRpcs,
+    select: (offeredVersion: string) => byVersion.get(offeredVersion) ?? snapshot[0],
+    routeClientRequest: (
+      protocol: Protocol,
+      request: RpcMessage.RequestEncoded
+    ) => ({
+      ...request,
+      tag: `${prefix(protocol)}${request.tag}`
+    })
+  } satisfies ProtocolRegistry<Protocol>
+})

package/src/unstable/ai/internal/structured-output.ts

@@ -34,12 +34,9 @@ export function toCodec<T, E, RD, RE>(
 }
 
 function transform(root: SchemaAST.AST): SchemaAST.AST {
-  const cache = new Map<SchemaAST.AST, SchemaAST.AST>()
+  let cache: Map<SchemaAST.AST, SchemaAST.AST> | undefined
 
   function recur(ast: SchemaAST.AST): SchemaAST.AST {
-    const cached = cache.get(ast)
-    if (cached !== undefined) return cached
-
     switch (ast._tag) {
       case "Union": {
         const types = SchemaAST.mapOrSame(ast.types, recur)
@@ -60,13 +57,12 @@ function transform(root: SchemaAST.AST): SchemaAST.AST {
         if (ast.elements.length > 0 || ast.rest.length > 1) {
           return tupleToObject(ast, recur)
         }
-        const elements = SchemaAST.mapOrSame(ast.elements, recur)
         const rest = SchemaAST.mapOrSame(ast.rest, recur)
         const checks = prepareChecks(ast.checks)
-        if (elements === ast.elements && rest === ast.rest && checks === ast.checks) return ast
+        if (rest === ast.rest && checks === ast.checks) return ast
         return new SchemaAST.Arrays(
           ast.isMutable,
-          elements,
+          ast.elements,
           rest,
           ast.annotations,
           checks,
@@ -93,24 +89,16 @@ function transform(root: SchemaAST.AST): SchemaAST.AST {
             ? propertySignature
             : new SchemaAST.PropertySignature(propertySignature.name, type)
         })
-        const indexSignatures = SchemaAST.mapOrSame(ast.indexSignatures, (indexSignature) => {
-          const parameter = recur(indexSignature.parameter)
-          const type = recur(indexSignature.type)
-          return parameter === indexSignature.parameter && type === indexSignature.type
-            ? indexSignature
-            : new SchemaAST.IndexSignature(parameter, type, indexSignature.merge)
-        })
         const checks = prepareChecks(ast.checks)
         if (
           propertySignatures === ast.propertySignatures &&
-          indexSignatures === ast.indexSignatures &&
           checks === ast.checks
         ) {
           return ast
         }
         return new SchemaAST.Objects(
           propertySignatures,
-          indexSignatures,
+          ast.indexSignatures,
           ast.annotations,
           checks,
           ast.encoding,
@@ -119,6 +107,8 @@ function transform(root: SchemaAST.AST): SchemaAST.AST {
         )
       }
       case "Suspend": {
+        const cached = cache?.get(ast)
+        if (cached !== undefined) return cached
         const out = new SchemaAST.Suspend(
           () => recur(ast.thunk()),
           ast.annotations,
@@ -126,6 +116,7 @@ function transform(root: SchemaAST.AST): SchemaAST.AST {
           ast.encoding,
           ast.context
         )
+        if (cache === undefined) cache = new Map()
         cache.set(ast, out)
         return out
       }
@@ -170,13 +161,16 @@ function tupleToObject(ast: SchemaAST.Arrays, recur: (ast: SchemaAST.AST) => Sch
     ast,
     SchemaTransformation.transform({
       decode: (object) => {
-        let tuple: Array<unknown> = []
+        const tuple: Array<unknown> = []
         for (let index = 0; index < ast.elements.length; index++) {
           const key = String(index)
           if (object[key] !== undefined) tuple.push(object[key])
         }
         if (REST_PROPERTY_NAME in object) {
-          tuple = [...tuple, ...object[REST_PROPERTY_NAME]]
+          const rest = object[REST_PROPERTY_NAME]
+          for (let index = 0; index < rest.length; index++) {
+            tuple.push(rest[index])
+          }
         }
         for (let index = 1; index < ast.rest.length; index++) {
           tuple.push(object[`${TAIL_PROPERTY_PREFIX}${index - 1}__`])
@@ -235,6 +229,7 @@ function objectToEntries(
 }
 
 function unionOrSingle(types: ReadonlyArray<SchemaAST.AST>): SchemaAST.AST {
+  if (types.length === 1) return types[0]
   const unique = Array.from(new Set(types))
   return unique.length === 1 ? unique[0] : new SchemaAST.Union(unique, "anyOf")
 }