effect 4.0.5 → 4.0.7

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(
@@ -774,11 +770,19 @@ const runWithRuntime = Effect.fnUntraced(function*(
     clientStates.delete(clientId)
     runtime.disconnect(clientId)
   }
-  const sendRequestError = (clientId: number, requestId: string | number, error: unknown) =>
+  // The exit is sent already encoded, so it must carry only the JSON-RPC error members.
+  const sendRequestError = (
+    clientId: number,
+    requestId: string | number,
+    { code, data, message }: { readonly code: number; readonly message: string; readonly data?: unknown }
+  ) =>
     protocol.send(clientId, {
       _tag: "Exit",
       requestId,
-      exit: { _tag: "Failure", cause: [{ _tag: "Fail", error }] }
+      exit: {
+        _tag: "Failure",
+        cause: [{ _tag: "Fail", error: data === undefined ? { code, message } : { code, message, data } }]
+      }
     })
   const removeReverseRequestClient = (requestId: string, key: McpClientKey) => {
     const waiting = reverseRequestClients.get(requestId)
@@ -916,18 +920,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 +967,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,
@@ -1007,16 +1008,9 @@ const runWithRuntime = Effect.fnUntraced(function*(
           response.exit._tag === "Failure" &&
           !response.exit.cause.some((failure) => failure._tag === "Fail")
         ) {
-          return protocol.send(clientId, {
-            _tag: "Exit",
-            requestId: response.requestId,
-            exit: {
-              _tag: "Failure",
-              cause: [{
-                _tag: "Fail",
-                error: new InternalError({ message: "Internal error" })
-              }]
-            }
+          return sendRequestError(clientId, response.requestId, {
+            code: McpSchema.INTERNAL_ERROR_CODE,
+            message: "Internal error"
           })
         }
       }
@@ -1033,7 +1027,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 +1089,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 +1105,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)
@@ -1909,7 +1901,7 @@ const normalizeMcpJsonRpcResponse = (response: unknown): unknown => {
 function mcpJsonRpcSerialization(options?: {
   readonly contentType?: string | undefined
 }): RpcSerialization.RpcSerialization["Service"] {
-  const serialization = RpcSerialization.jsonRpc(options)
+  const serialization = RpcSerialization.jsonRpc({ ...options, controlMessages: false })
   return RpcSerialization.RpcSerialization.of({
     ...serialization,
     makeUnsafe: () => {
@@ -2192,10 +2184,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