effect 4.0.5 → 4.0.6

package/src/ai/McpServer.ts

@@ -424,214 +424,210 @@ export class McpServer extends Context.Service<McpServer, {
       get tools() {
         return tools
       },
-      addTool: (options) =>
-        Effect.gen(function*() {
-          const existingIndex = tools.findIndex(({ tool }) => tool.name === options.tool.name)
-          if (existingIndex === -1) {
-            tools.push(options)
-          } else {
-            tools[existingIndex] = options
-          }
-          const enabledWhen = Context.getOrUndefined(options.annotations, EnabledWhen)
-          yield* internalCore.tools.register({
-            descriptor: new McpTool({
-              ...options.tool,
-              title: options.tool.title ?? options.tool.annotations?.title
-            }),
-            isVisible: (profile) =>
-              enabledWhen === undefined || enabledWhen(
-                {
-                  protocolVersion: profile.protocolVersion,
-                  capabilities: profile.clientCapabilities,
-                  clientInfo: profile.clientInfo
-                }
-              ),
-            handle: (call, invocation) =>
-              provideInvocationContext(options.handle(call.arguments), invocation).pipe(
-                Effect.catchTags({
-                  InternalError: (error) =>
-                    Effect.fail(
-                      new McpCore.ToolExecutionError({
-                        name: options.tool.name,
-                        message: error.message
-                      })
-                    ),
-                  InvalidParams: (error) =>
-                    Effect.fail(
-                      new (invocation.requestContext.requestState === undefined &&
-                          invocation.requestContext.inputResponses === undefined
-                        ? McpCore.InvalidToolInput
-                        : McpCore.InvalidToolContinuation)({
-                        name: options.tool.name,
-                        message: error.message
-                      })
-                    )
-                }),
-                Effect.map((result) =>
-                  Predicate.isTagged(result, "InputRequired")
-                    ? McpCore.OperationOutcome.InputRequired(result)
-                    : McpCore.OperationOutcome.Complete(result)
-                )
+      addTool: Effect.fnUntraced(function*(options) {
+        const existingIndex = tools.findIndex(({ tool }) => tool.name === options.tool.name)
+        if (existingIndex === -1) {
+          tools.push(options)
+        } else {
+          tools[existingIndex] = options
+        }
+        const enabledWhen = Context.getOrUndefined(options.annotations, EnabledWhen)
+        yield* internalCore.tools.register({
+          descriptor: new McpTool({
+            ...options.tool,
+            title: options.tool.title ?? options.tool.annotations?.title
+          }),
+          isVisible: (profile) =>
+            enabledWhen === undefined || enabledWhen(
+              {
+                protocolVersion: profile.protocolVersion,
+                capabilities: profile.clientCapabilities,
+                clientInfo: profile.clientInfo
+              }
+            ),
+          handle: (call, invocation) =>
+            provideInvocationContext(options.handle(call.arguments), invocation).pipe(
+              Effect.catchTags({
+                InternalError: (error) =>
+                  Effect.fail(
+                    new McpCore.ToolExecutionError({
+                      name: options.tool.name,
+                      message: error.message
+                    })
+                  ),
+                InvalidParams: (error) =>
+                  Effect.fail(
+                    new (invocation.requestContext.requestState === undefined &&
+                        invocation.requestContext.inputResponses === undefined
+                      ? McpCore.InvalidToolInput
+                      : McpCore.InvalidToolContinuation)({
+                      name: options.tool.name,
+                      message: error.message
+                    })
+                  )
+              }),
+              Effect.map((result) =>
+                Predicate.isTagged(result, "InputRequired")
+                  ? McpCore.OperationOutcome.InputRequired(result)
+                  : McpCore.OperationOutcome.Complete(result)
               )
-          })
-          yield* notifications.client["notifications/tools/list_changed"]({})
-        }),
-      callTool: (request) =>
-        Effect.gen(function*() {
-          const client = yield* McpServerClient
-          const result = yield* internalCore.tools.call(
-            request,
-            McpProtocolInternal.invocationFromClient(client)
-          ).pipe(
-            Effect.mapError((error) =>
-              new InvalidParams({
-                message: error._tag === "ToolNotFound"
-                  ? `Tool '${error.name}' not found`
-                  : error.message
-              })
             )
+        })
+        yield* notifications.client["notifications/tools/list_changed"]({})
+      }),
+      callTool: Effect.fnUntraced(function*(request) {
+        const client = yield* McpServerClient
+        const result = yield* internalCore.tools.call(
+          request,
+          McpProtocolInternal.invocationFromClient(client)
+        ).pipe(
+          Effect.mapError((error) =>
+            new InvalidParams({
+              message: error._tag === "ToolNotFound"
+                ? `Tool '${error.name}' not found`
+                : error.message
+            })
           )
-          if (result._tag === "InputRequired") {
-            return yield* new InvalidParams({ message: "Client input is not supported by this MCP protocol" })
-          }
-          return result.value
-        }),
+        )
+        if (result._tag === "InputRequired") {
+          return yield* new InvalidParams({ message: "Client input is not supported by this MCP protocol" })
+        }
+        return result.value
+      }),
       get resources() {
         return resources
       },
       get resourceTemplates() {
         return resourceTemplates
       },
-      addResource: (options) =>
-        Effect.gen(function*() {
-          const existingIndex = resources.findIndex(({ resource }) => resource.uri === options.resource.uri)
-          if (existingIndex === -1) {
-            resources.push(options)
-          } else {
-            resources[existingIndex] = options
-          }
-          yield* internalCore.resources.register({
-            descriptor: options.resource,
-            isVisible: (profile) => {
-              const enabledWhen = Context.getOrUndefined(options.annotations, EnabledWhen)
-              return enabledWhen === undefined || enabledWhen({
-                protocolVersion: profile.protocolVersion,
-                capabilities: profile.clientCapabilities,
-                clientInfo: profile.clientInfo
-              })
-            },
-            read: (invocation) => provideInvocationContext(options.handle, invocation)
-          })
-          yield* notifications.client["notifications/resources/list_changed"]({})
-        }),
-      addResourceTemplate: ({ annotations, completions, handle, routerPath, template }) =>
-        Effect.gen(function*() {
-          const existingIndex = resourceTemplates.findIndex(({ template: current }) =>
-            current.uriTemplate === template.uriTemplate
+      addResource: Effect.fnUntraced(function*(options) {
+        const existingIndex = resources.findIndex(({ resource }) => resource.uri === options.resource.uri)
+        if (existingIndex === -1) {
+          resources.push(options)
+        } else {
+          resources[existingIndex] = options
+        }
+        yield* internalCore.resources.register({
+          descriptor: options.resource,
+          isVisible: (profile) => {
+            const enabledWhen = Context.getOrUndefined(options.annotations, EnabledWhen)
+            return enabledWhen === undefined || enabledWhen({
+              protocolVersion: profile.protocolVersion,
+              capabilities: profile.clientCapabilities,
+              clientInfo: profile.clientInfo
+            })
+          },
+          read: (invocation) => provideInvocationContext(options.handle, invocation)
+        })
+        yield* notifications.client["notifications/resources/list_changed"]({})
+      }),
+      addResourceTemplate: Effect.fnUntraced(function*({ annotations, completions, handle, routerPath, template }) {
+        const existingIndex = resourceTemplates.findIndex(({ template: current }) =>
+          current.uriTemplate === template.uriTemplate
+        )
+        if (existingIndex === -1) {
+          resourceTemplates.push({ template, annotations })
+        } else {
+          resourceTemplates[existingIndex] = { template, annotations }
+        }
+        const templateMatcher = makeUriMatcher<true>()
+        templateMatcher.add(routerPath, true)
+        yield* internalCore.resources.registerTemplate({
+          descriptor: template,
+          isVisible: (profile) => {
+            const enabledWhen = Context.getOrUndefined(annotations, EnabledWhen)
+            return enabledWhen === undefined || enabledWhen({
+              protocolVersion: profile.protocolVersion,
+              capabilities: profile.clientCapabilities,
+              clientInfo: profile.clientInfo
+            })
+          },
+          match: (uri) => {
+            const match = templateMatcher.find(uri)
+            if (match === undefined) {
+              return undefined
+            }
+            const params: Array<string> = []
+            for (const key of Object.keys(match.params)) {
+              params[Number(key)] = match.params[key]!
+            }
+            return params
+          },
+          read: (uri, params, invocation) => provideInvocationContext(handle(uri, Array.from(params)), invocation)
+        })
+        for (const [param, handle] of Object.entries(completions)) {
+          yield* internalCore.completions.register(
+            `resource/${template.uriTemplate}/${param}`,
+            (request, invocation) =>
+              provideInvocationContext(handle(request.argument.value, request.context), invocation).pipe(
+                Effect.map((result) => ({
+                  values: result.completion.values,
+                  total: result.completion.total,
+                  hasMore: result.completion.hasMore,
+                  metadata: result._meta
+                }))
+              )
           )
-          if (existingIndex === -1) {
-            resourceTemplates.push({ template, annotations })
-          } else {
-            resourceTemplates[existingIndex] = { template, annotations }
-          }
-          const templateMatcher = makeUriMatcher<true>()
-          templateMatcher.add(routerPath, true)
-          yield* internalCore.resources.registerTemplate({
-            descriptor: template,
-            isVisible: (profile) => {
-              const enabledWhen = Context.getOrUndefined(annotations, EnabledWhen)
-              return enabledWhen === undefined || enabledWhen({
-                protocolVersion: profile.protocolVersion,
-                capabilities: profile.clientCapabilities,
-                clientInfo: profile.clientInfo
-              })
-            },
-            match: (uri) => {
-              const match = templateMatcher.find(uri)
-              if (match === undefined) {
-                return undefined
-              }
-              const params: Array<string> = []
-              for (const key of Object.keys(match.params)) {
-                params[Number(key)] = match.params[key]!
-              }
-              return params
-            },
-            read: (uri, params, invocation) => provideInvocationContext(handle(uri, Array.from(params)), invocation)
-          })
-          for (const [param, handle] of Object.entries(completions)) {
-            yield* internalCore.completions.register(
-              `resource/${template.uriTemplate}/${param}`,
-              (request, invocation) =>
-                provideInvocationContext(handle(request.argument.value, request.context), invocation).pipe(
-                  Effect.map((result) => ({
-                    values: result.completion.values,
-                    total: result.completion.total,
-                    hasMore: result.completion.hasMore,
-                    metadata: result._meta
-                  }))
-                )
-            )
-          }
-          yield* notifications.client["notifications/resources/list_changed"]({})
-        }),
-      findResource: (uri) =>
-        Effect.gen(function*() {
-          const client = yield* McpServerClient
-          return yield* internalCore.resources.read(
-            uri,
-            McpProtocolInternal.invocationFromClient(client)
-          ).pipe(
-            Effect.catchTag("ResourceNotFound", (error) =>
-              Effect.fail(new InvalidParams({ message: `Resource '${error.uri}' not found` })))
+        }
+        yield* notifications.client["notifications/resources/list_changed"]({})
+      }),
+      findResource: Effect.fnUntraced(function*(uri) {
+        const client = yield* McpServerClient
+        return yield* internalCore.resources.read(
+          uri,
+          McpProtocolInternal.invocationFromClient(client)
+        ).pipe(
+          Effect.catchTag(
+            "ResourceNotFound",
+            (error) => Effect.fail(new InvalidParams({ message: `Resource '${error.uri}' not found` }))
           )
-        }),
+        )
+      }),
       get prompts() {
         return prompts
       },
-      addPrompt: (options) =>
-        Effect.gen(function*() {
-          const existingIndex = prompts.findIndex(({ prompt }) => prompt.name === options.prompt.name)
-          if (existingIndex === -1) {
-            prompts.push(options)
-          } else {
-            prompts[existingIndex] = options
-          }
-          yield* internalCore.prompts.register({
-            descriptor: options.prompt,
-            isVisible: (profile) => {
-              const enabledWhen = Context.getOrUndefined(options.annotations, EnabledWhen)
-              return enabledWhen === undefined || enabledWhen({
-                protocolVersion: profile.protocolVersion,
-                capabilities: profile.clientCapabilities,
-                clientInfo: profile.clientInfo
-              })
-            },
-            get: (params, invocation) =>
-              provideInvocationContext(options.handle(params), invocation).pipe(
-                Effect.map((result) =>
-                  Predicate.isTagged(result, "InputRequired")
-                    ? McpCore.OperationOutcome.InputRequired(result)
-                    : McpCore.OperationOutcome.Complete(result)
-                )
+      addPrompt: Effect.fnUntraced(function*(options) {
+        const existingIndex = prompts.findIndex(({ prompt }) => prompt.name === options.prompt.name)
+        if (existingIndex === -1) {
+          prompts.push(options)
+        } else {
+          prompts[existingIndex] = options
+        }
+        yield* internalCore.prompts.register({
+          descriptor: options.prompt,
+          isVisible: (profile) => {
+            const enabledWhen = Context.getOrUndefined(options.annotations, EnabledWhen)
+            return enabledWhen === undefined || enabledWhen({
+              protocolVersion: profile.protocolVersion,
+              capabilities: profile.clientCapabilities,
+              clientInfo: profile.clientInfo
+            })
+          },
+          get: (params, invocation) =>
+            provideInvocationContext(options.handle(params), invocation).pipe(
+              Effect.map((result) =>
+                Predicate.isTagged(result, "InputRequired")
+                  ? McpCore.OperationOutcome.InputRequired(result)
+                  : McpCore.OperationOutcome.Complete(result)
               )
-          })
-          for (const [param, handle] of Object.entries(options.completions)) {
-            yield* internalCore.completions.register(
-              `prompt/${options.prompt.name}/${param}`,
-              (request, invocation) =>
-                provideInvocationContext(handle(request.argument.value, request.context), invocation).pipe(
-                  Effect.map((result) => ({
-                    values: result.completion.values,
-                    total: result.completion.total,
-                    hasMore: result.completion.hasMore,
-                    metadata: result._meta
-                  }))
-                )
             )
-          }
-          yield* notifications.client["notifications/prompts/list_changed"]({})
-        }),
+        })
+        for (const [param, handle] of Object.entries(options.completions)) {
+          yield* internalCore.completions.register(
+            `prompt/${options.prompt.name}/${param}`,
+            (request, invocation) =>
+              provideInvocationContext(handle(request.argument.value, request.context), invocation).pipe(
+                Effect.map((result) => ({
+                  values: result.completion.values,
+                  total: result.completion.total,
+                  hasMore: result.completion.hasMore,
+                  metadata: result._meta
+                }))
+              )
+          )
+        }
+        yield* notifications.client["notifications/prompts/list_changed"]({})
+      }),
       getPromptResult: Effect.fnUntraced(function*({ arguments: params, name }) {
         const client = yield* McpServerClient
         const outcome = yield* internalCore.prompts.get(
@@ -916,18 +912,15 @@ const runWithRuntime = Effect.fnUntraced(function*(
     const isInitialize = rpc._tag.endsWith("/initialize")
     if (!isInitialize && !session) {
       const fiber = Fiber.getCurrent()!
-      const httpRequest = Context.getOrUndefined(fiber.context, HttpServerRequest.HttpServerRequest)
-      if (httpRequest) {
-        appendPreResponseHandlerUnsafe(
-          httpRequest,
-          () =>
-            Effect.succeed(
-              HttpServerResponse.empty({
-                status: headers[MCP_SESSION_ID_HEADER] === undefined ? 400 : 404
-              })
-            )
-        )
-      }
+      appendPreResponseHandlerUnsafe(
+        fiber.context,
+        () =>
+          Effect.succeed(
+            HttpServerResponse.empty({
+              status: headers[MCP_SESSION_ID_HEADER] === undefined ? 400 : 404
+            })
+          )
+      )
       return Effect.die(new Error(`Mcp-Session-Id does not exist`))
     }
     // RPC middleware erases the correlation between the initialize tag
@@ -966,7 +959,7 @@ const runWithRuntime = Effect.fnUntraced(function*(
             clientInfo: profile.clientInfo,
             initializePayload,
             requestMetadata: Predicate.isReadonlyObject(payload) && Predicate.isReadonlyObject(payload._meta)
-              ? payload._meta as Schema.JsonObject
+              ? payload._meta as Readonly<Record<string, unknown>>
               : undefined,
             getClient: RcMap.get(
               clients,
@@ -1033,7 +1026,7 @@ const runWithRuntime = Effect.fnUntraced(function*(
           ? Context.getOrUndefined(fiber.context, HttpServerRequest.HttpServerRequest)
           : undefined
         if (httpRequest !== undefined && request._tag !== "Eof") {
-          appendPreResponseHandlerUnsafe(httpRequest, (_, response) =>
+          appendPreResponseHandlerUnsafe(fiber.context, (_, response) =>
             Effect.succeed(
               response.status === 200 &&
                 response.body._tag === "Uint8Array" &&
@@ -1095,7 +1088,7 @@ const runWithRuntime = Effect.fnUntraced(function*(
                 )
               }
               if (httpRequest !== undefined && session !== undefined) {
-                appendPreResponseHandlerUnsafe(httpRequest, (_, res) =>
+                appendPreResponseHandlerUnsafe(fiber.context, (_, res) =>
                   Effect.succeed(
                     runtime.resolveRequest(clientId, headers) === undefined
                       ? HttpServerResponse.empty({ status: 404 })
@@ -1111,17 +1104,15 @@ const runWithRuntime = Effect.fnUntraced(function*(
               const isClientNotification = selectedProtocol.clientNotificationRpcs.requests.has(request.tag)
               if (rpc && isClientNotification && request.isNotification) {
                 if (!session && selectedProtocol.runtime._tag === "Stateful") {
-                  if (httpRequest) {
-                    appendPreResponseHandlerUnsafe(
-                      httpRequest,
-                      () =>
-                        Effect.succeed(
-                          HttpServerResponse.empty({
-                            status: headers[MCP_SESSION_ID_HEADER] === undefined ? 400 : 404
-                          })
-                        )
-                    )
-                  }
+                  appendPreResponseHandlerUnsafe(
+                    fiber.context,
+                    () =>
+                      Effect.succeed(
+                        HttpServerResponse.empty({
+                          status: headers[MCP_SESSION_ID_HEADER] === undefined ? 400 : 404
+                        })
+                      )
+                  )
                   return
                 }
                 const decode = selectedProtocol.payloadCodecs(rpc).decode(request.payload)
@@ -2192,10 +2183,16 @@ const isParameterValidationError = (
 ): error is AiError.AiError & { readonly reason: AiError.ToolParameterValidationError } =>
   AiError.isAiError(error) && error.reason._tag === "ToolParameterValidationError"
 
-// MCP requires an object root, so a top-level `$ref` is inlined.
+// MCP requires an object root. A non-recursive root is compiled inline rather
+// than as a definition; a recursive root keeps its definition and the top-level
+// `$ref` is inlined.
 const toolJsonSchema = (schema: Schema.Constraint, strict: boolean): JsonSchema.JsonSchema => {
+  const root = SchemaAST.getContextOwner(SchemaAST.getLastEncoding(Schema.toCodecJson(schema).ast))
   const document = InternalStructuredOutput.resolveTopLevelReference(
-    Schema.toJsonSchemaDocument(schema, { onExcessProperty: strict ? "error" : "ignore" })
+    Schema.toJsonSchemaDocument(schema, {
+      onExcessProperty: strict ? "error" : "ignore",
+      referencePolicy: ({ ast, identifier, occurrences }) => ast === root && occurrences === 1 ? undefined : identifier
+    })
   )
   return Object.keys(document.definitions).length === 0
     ? document.schema

package/src/ai/Prompt.ts

@@ -465,9 +465,15 @@ export interface FilePartEncoded extends BasePartEncoded<"file", FilePartOptions
    */
   readonly fileName?: string | undefined
   /**
-   * File data as base64 string of data, a byte array, or a URL.
-   */
-  readonly data: string | Uint8Array | URL
+   * File data as a base64 string, a byte array, a URL, or the tagged JSON
+   * form that encoding produces for byte arrays and URLs.
+   */
+  readonly data:
+    | string
+    | Uint8Array
+    | URL
+    | { readonly _tag: "Uint8Array"; readonly base64: string }
+    | { readonly _tag: "URL"; readonly href: string }
 }
 
 /**
@@ -491,7 +497,18 @@ export const FilePart: Schema.Struct<{
   readonly type: Schema.Literal<"file">
   readonly mediaType: Schema.String
   readonly fileName: Schema.optional<Schema.String>
-  readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array, Schema.URL]>
+  readonly data: Schema.Union<
+    readonly [
+      Schema.String,
+      Schema.decodeTo<
+        Schema.Uint8Array,
+        Schema.TaggedStruct<"Uint8Array", { readonly base64: Schema.Uint8ArrayFromBase64 }>
+      >,
+      Schema.decodeTo<Schema.URL, Schema.TaggedStruct<"URL", { readonly href: Schema.URLFromString }>>,
+      Schema.Uint8Array,
+      Schema.URL
+    ]
+  >
   readonly "~effect/ai/Prompt/Part": Schema.withDecodingDefaultKey<Schema.Literal<"~effect/ai/Prompt/Part">>
   readonly options: Schema.withDecodingDefault<
     Schema.$Record<
@@ -504,7 +521,33 @@ export const FilePart: Schema.Struct<{
   type: Schema.Literal("file"),
   mediaType: Schema.String,
   fileName: Schema.optional(Schema.String),
-  data: Schema.Union([Schema.String, Schema.Uint8Array, Schema.URL])
+  // The tagged members come first so that encoding produces JSON-safe data,
+  // while the raw members keep decoding byte arrays and URLs directly
+  data: Schema.Union([
+    Schema.String,
+    Schema.TaggedStruct("Uint8Array", { base64: Schema.Uint8ArrayFromBase64 }).pipe(Schema.decodeTo(
+      Schema.Uint8Array,
+      SchemaTransformation.transform({
+        decode: ({ base64 }) => base64,
+        encode: (base64) => (({
+          _tag: "Uint8Array",
+          base64
+        }) as const)
+      })
+    )),
+    Schema.TaggedStruct("URL", { href: Schema.URLFromString }).pipe(Schema.decodeTo(
+      Schema.URL,
+      SchemaTransformation.transform({
+        decode: ({ href }) => href,
+        encode: (href) => (({
+          _tag: "URL",
+          href
+        }) as const)
+      })
+    )),
+    Schema.Uint8Array,
+    Schema.URL
+  ])
 }).annotate({ identifier: "FilePart" })
 
 /**
@@ -1407,36 +1450,7 @@ export const UserMessage: Schema.Struct<{
         never,
         never
       >,
-      Schema.$Array<
-        Schema.Union<
-          readonly [
-            Schema.Struct<{
-              readonly type: Schema.Literal<"text">
-              readonly text: Schema.String
-              readonly "~effect/ai/Prompt/Part": Schema.withDecodingDefaultKey<Schema.Literal<"~effect/ai/Prompt/Part">>
-              readonly options: Schema.withDecodingDefault<
-                Schema.$Record<
-                  Schema.String,
-                  Schema.NullOr<Schema.Codec<Schema.Json>>
-                >
-              >
-            }>,
-            Schema.Struct<{
-              readonly type: Schema.Literal<"file">
-              readonly mediaType: Schema.String
-              readonly fileName: Schema.optional<Schema.String>
-              readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array, Schema.URL]>
-              readonly "~effect/ai/Prompt/Part": Schema.withDecodingDefaultKey<Schema.Literal<"~effect/ai/Prompt/Part">>
-              readonly options: Schema.withDecodingDefault<
-                Schema.$Record<
-                  Schema.String,
-                  Schema.NullOr<Schema.Codec<Schema.Json>>
-                >
-              >
-            }>
-          ]
-        >
-      >
+      Schema.$Array<Schema.Union<readonly [typeof TextPart, typeof FilePart]>>
     ]
   >
   readonly "~effect/ai/Prompt/Message": Schema.withDecodingDefaultKey<Schema.Literal<"~effect/ai/Prompt/Message">>