effect 4.0.4 → 4.0.6

package/src/ai/internal/mcpCore.ts

@@ -7,7 +7,6 @@
 import * as Arr from "../../Array.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
-import type * as Schema from "../../Schema.ts"
 import type * as McpProtocol from "../McpProtocol.ts"
 import * as McpSchema from "../McpSchema.ts"
 
@@ -56,7 +55,7 @@ export interface NegotiatedProtocolProfile<out Version extends string = McpProto
     : McpSchema.Implementation | undefined
   readonly requestMetadata?:
     | (Version extends McpProtocol.StatefulProtocolVersion ? CanonicalRequestMetadata
-      : CanonicalRequestMetadata | Schema.JsonObject)
+      : CanonicalRequestMetadata | Readonly<Record<string, unknown>>)
     | undefined
 }
 
@@ -66,7 +65,7 @@ export interface NegotiatedProtocolProfile<out Version extends string = McpProto
  * @internal
  */
 export interface CanonicalServerCapabilities {
-  readonly experimental?: Readonly<Record<string, Schema.JsonObject>> | undefined
+  readonly experimental?: Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined
   readonly logging?: boolean | undefined
   readonly completions?: boolean | undefined
   readonly prompts?: Readonly<{ readonly listChanged?: boolean | undefined }> | undefined
@@ -77,7 +76,7 @@ export interface CanonicalServerCapabilities {
     }>
     | undefined
   readonly tools?: Readonly<{ readonly listChanged?: boolean | undefined }> | undefined
-  readonly extensions?: Schema.JsonObject | undefined
+  readonly extensions?: Readonly<Record<string, unknown>> | undefined
 }
 
 /**
@@ -303,7 +302,7 @@ export interface CompletionResult {
   readonly values: ReadonlyArray<string>
   readonly total?: number | undefined
   readonly hasMore?: boolean | undefined
-  readonly metadata?: Schema.JsonObject | undefined
+  readonly metadata?: Readonly<Record<string, unknown>> | undefined
 }
 
 /**
@@ -333,7 +332,7 @@ export type ClientNotification = Data.TaggedEnum<{
     readonly progress: number
     readonly total?: number | undefined
     readonly message?: string | undefined
-    readonly metadata?: Schema.JsonObject | undefined
+    readonly metadata?: Readonly<Record<string, unknown>> | undefined
   }
   RootsChanged: {}
 }>
@@ -349,7 +348,7 @@ export const ClientNotification = Data.taggedEnum<ClientNotification>()
 export interface Cancellation {
   readonly requestId: string | number
   readonly reason?: string | undefined
-  readonly metadata?: Schema.JsonObject | undefined
+  readonly metadata?: Readonly<Record<string, unknown>> | undefined
 }
 
 /**
@@ -359,25 +358,25 @@ export type ServerNotification = Data.TaggedEnum<{
   Cancelled: {
     readonly requestId: string | number
     readonly reason?: string | undefined
-    readonly metadata?: Schema.JsonObject | undefined
+    readonly metadata?: Readonly<Record<string, unknown>> | undefined
   }
   Progress: {
     readonly progressToken: string | number
     readonly progress: number
     readonly total?: number | undefined
     readonly message?: string | undefined
-    readonly metadata?: Schema.JsonObject | undefined
+    readonly metadata?: Readonly<Record<string, unknown>> | undefined
   }
   LoggingMessage: {
     readonly level: McpSchema.LoggingLevel
     readonly logger?: string | undefined
     readonly data: unknown
-    readonly metadata?: Schema.JsonObject | undefined
+    readonly metadata?: Readonly<Record<string, unknown>> | undefined
   }
-  ResourceUpdated: { readonly uri: string; readonly metadata?: Schema.JsonObject | undefined }
-  ResourcesChanged: { readonly metadata?: Schema.JsonObject | undefined }
-  ToolsChanged: { readonly metadata?: Schema.JsonObject | undefined }
-  PromptsChanged: { readonly metadata?: Schema.JsonObject | undefined }
+  ResourceUpdated: { readonly uri: string; readonly metadata?: Readonly<Record<string, unknown>> | undefined }
+  ResourcesChanged: { readonly metadata?: Readonly<Record<string, unknown>> | undefined }
+  ToolsChanged: { readonly metadata?: Readonly<Record<string, unknown>> | undefined }
+  PromptsChanged: { readonly metadata?: Readonly<Record<string, unknown>> | undefined }
   ElicitationComplete: { readonly elicitationId: string }
 }>
 

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

@@ -257,7 +257,7 @@ export const protocol = McpProtocol.make({
                 McpSchema.Tool.make({
                   name: tool.name,
                   description: tool.description,
-                  inputSchema: tool.inputSchema
+                  inputSchema: McpProtocol.projectLegacyToolInputSchema(tool.inputSchema)
                 })
               )
             })

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

@@ -279,7 +279,7 @@ export const protocol = McpProtocol.make({
             McpSchema.Tool.make({
               name: tool.name,
               description: tool.description,
-              inputSchema: tool.inputSchema,
+              inputSchema: McpProtocol.projectLegacyToolInputSchema(tool.inputSchema),
               annotations: tool.title === undefined && tool.annotations === undefined
                 ? undefined
                 : McpSchema.ToolAnnotations.make({

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

@@ -122,10 +122,10 @@ const projectResourceContents = (
     }
 
 const projectStructuredContent = (
-  content: Schema.Json | undefined
-): Schema.JsonObject | undefined => content === undefined || isJsonObject(content) ? content : undefined
+  content: unknown
+): Readonly<Record<string, unknown>> | undefined => content === undefined || isObject(content) ? content : undefined
 
-const isJsonObject = (value: Schema.Json): value is Schema.JsonObject => Predicate.isReadonlyObject(value)
+const isObject = (value: unknown): value is Readonly<Record<string, unknown>> => Predicate.isReadonlyObject(value)
 
 /**
  * @internal

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

@@ -112,10 +112,10 @@ const projectContent = Effect.fnUntraced(function*(content: PublicMcpSchema.Cont
 })
 
 const projectStructuredContent = (
-  content: Schema.Json | undefined
-): Schema.JsonObject | undefined => content === undefined || isJsonObject(content) ? content : undefined
+  content: unknown
+): Readonly<Record<string, unknown>> | undefined => content === undefined || isObject(content) ? content : undefined
 
-const isJsonObject = (value: Schema.Json): value is Schema.JsonObject => Predicate.isReadonlyObject(value)
+const isObject = (value: unknown): value is Readonly<Record<string, unknown>> => Predicate.isReadonlyObject(value)
 
 /**
  * @internal

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

@@ -26,7 +26,7 @@ import * as McpCore from "../mcpCore.ts"
 import * as McpProtocol from "../mcpProtocol.ts"
 import * as McpSchema from "../mcpSchema/v2026_07_28.ts"
 
-const InputResponses = Schema.Record(Schema.String, Schema.JsonObject)
+const InputResponses = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))
 const decodeRequestMetadata = Schema.decodeUnknownEffect(McpSchema.RequestMetaObject)
 const decodeCancellation = Schema.decodeUnknownEffect(McpSchema.CancelledNotification.payloadSchema)
 const isJson = Schema.is(Schema.Json)
@@ -92,8 +92,8 @@ export const profileFromRequestMetadata = Effect.fnUntraced(function*(metadata:
 
 const resultMetadata = (
   value: ObjectWithUndefined,
-  serverInfo: Schema.JsonObject
-): Schema.JsonObject => {
+  serverInfo: Readonly<Record<string, unknown>>
+): Readonly<Record<string, unknown>> => {
   const metadata: unknown = value._meta
   return {
     ...(Predicate.isReadonlyObject(metadata) ? metadata : {}),
@@ -103,7 +103,7 @@ const resultMetadata = (
 
 const projectInputRequired = (
   outcome: McpCore.InputRequiredFields,
-  serverInfo: Schema.JsonObject
+  serverInfo: Readonly<Record<string, unknown>>
 ) =>
   omitUndefined({
     _meta: { "io.modelcontextprotocol/serverInfo": serverInfo },
@@ -138,8 +138,8 @@ export const projectCallToolOutcome = Effect.fnUntraced(function*(
 const requiredCapabilitiesForInputRequests = (
   inputRequests: McpCore.InputRequiredFields["inputRequests"],
   capabilities: McpCore.NegotiatedProtocolProfile["clientCapabilities"]
-): Record<string, Schema.JsonObject> => {
-  const required: Record<string, Types.Mutable<Schema.JsonObject>> = {}
+): Record<string, Readonly<Record<string, unknown>>> => {
+  const required: Record<string, Record<string, unknown>> = {}
   for (const request of Object.values(inputRequests ?? {})) {
     Match.value(request).pipe(
       Match.when({ method: "roots/list" }, () => {
@@ -264,16 +264,14 @@ const projectError = (error: ProtocolError): McpSchema.McpError => {
   })
 }
 
-const failWithHttpStatus = Effect.fnUntraced(function*(status: number, error: McpProtocol.ProtocolError) {
-  const request = yield* Effect.serviceOption(HttpServerRequest.HttpServerRequest)
-  if (Option.isSome(request)) {
+const failWithHttpStatus = (status: number, error: McpProtocol.ProtocolError) =>
+  Effect.withFiber((fiber) => {
     appendPreResponseHandlerUnsafe(
-      request.value,
+      fiber.context,
       (_request, response) => Effect.succeed(HttpServerResponse.setStatus(response, status))
     )
-  }
-  return yield* error
-})
+    return Effect.fail(error)
+  })
 
 /**
  * @internal
@@ -327,7 +325,7 @@ export const makeHandlers = (
   // Older adapters accept arbitrary JSON; this binding requires extension settings objects.
   const extensions = context.serverInfo.extensions === undefined ? undefined : Record.filter(
     context.serverInfo.extensions,
-    (value): value is Schema.JsonObject => Predicate.isReadonlyObject(value)
+    (value): value is Readonly<Record<string, unknown>> => Predicate.isReadonlyObject(value)
   )
   const getDiscovery = Effect.map(context.registrationPresence, (presence) => {
     const capabilities: Types.Mutable<typeof McpSchema.ServerCapabilities.Type> = { completions: {}, logging: {} }

package/src/ai/internal/mcpProtocol.ts

@@ -19,8 +19,10 @@ import * as PublicMcpSchema from "../McpSchema.ts"
 import * as McpCore from "./mcpCore.ts"
 
 const LEGACY_RESOURCE_NOT_FOUND_ERROR_CODE = -32002
-const BASE64_SENTINEL_PREFIX = "=?base64?"
-const BASE64_SENTINEL_SUFFIX = "?="
+/** @internal */
+export const BASE64_SENTINEL_PREFIX = "=?base64?"
+/** @internal */
+export const BASE64_SENTINEL_SUFFIX = "?="
 // A leading U+FEFF belongs to the header value and must survive comparison with the JSON body.
 const routingHeaderDecoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true })
 
@@ -120,6 +122,24 @@ export const requireCompleteOperation = <A>(
     ? Effect.succeed(outcome.value)
     : Effect.fail(new McpCore.UnsupportedByProtocol({ protocolVersion, feature: "Client input" }))
 
+/**
+ * Projects boolean property schemas to equivalent objects for pre-June adapters.
+ * Their dated tool descriptors require object-valued direct property schemas.
+ *
+ * @internal
+ */
+export const projectLegacyToolInputSchema = (inputSchema: PublicMcpSchema.ToolJson) => ({
+  ...inputSchema,
+  properties: inputSchema.properties === undefined
+    ? undefined
+    : Object.fromEntries<Readonly<Record<string, unknown>>>(
+      Object.entries(inputSchema.properties).map(([name, schema]) => [
+        name,
+        typeof schema === "boolean" ? schema ? {} : { not: {} } : schema
+      ])
+    )
+})
+
 /**
  * Unquotes an exact text mirror when the protocol drops string `structuredContent`.
  *

package/src/ai/internal/mcpRuntime.ts

@@ -31,7 +31,6 @@ const MCP_METHOD_HEADER = "mcp-method"
 const MCP_NAME_HEADER = "mcp-name"
 const PROTOCOL_VERSION_METADATA_KEY = "io.modelcontextprotocol/protocolVersion"
 const CLIENT_CAPABILITIES_METADATA_KEY = "io.modelcontextprotocol/clientCapabilities"
-const UNSUPPORTED_PROTOCOL_VERSION_ERROR_CODE = -32022
 
 const asRecord = (input: unknown): Record<string, unknown> | undefined =>
   typeof input === "object" && input !== null ? input as Record<string, unknown> : undefined
@@ -236,7 +235,7 @@ export const make = Effect.fnUntraced(function*(
   const registry = yield* McpProtocolRegistry.make(protocols)
   const sessionTerminationListeners = new Set<(binding: RequestBinding) => Effect.Effect<void>>()
   const unsupportedProtocolVersion = (requested: string) => ({
-    code: UNSUPPORTED_PROTOCOL_VERSION_ERROR_CODE,
+    code: PublicMcpSchema.UNSUPPORTED_PROTOCOL_VERSION_ERROR_CODE,
     message: `Unsupported protocol version '${requested}'`,
     data: { supported: protocolVersions, requested }
   })
@@ -345,7 +344,7 @@ export const make = Effect.fnUntraced(function*(
         const selected = selectStatefulProtocol(registry.protocols, offeredVersion)
         if (selected === undefined) {
           return yield* new McpProtocol.ProtocolError({
-            code: UNSUPPORTED_PROTOCOL_VERSION_ERROR_CODE,
+            code: PublicMcpSchema.UNSUPPORTED_PROTOCOL_VERSION_ERROR_CODE,
             message: `initialize is not supported by the configured MCP protocols (requested '${offeredVersion}')`
           })
         }
@@ -568,7 +567,7 @@ export const make = Effect.fnUntraced(function*(
                 const sessionId = crypto.randomUUID()
                 stateful.registerHttp(sessionId, registration)
                 appendPreResponseHandlerUnsafe(
-                  httpRequest,
+                  fiber.context,
                   (_request, response) =>
                     Effect.succeed(HttpServerResponse.setHeaders(response, {
                       [MCP_SESSION_ID_HEADER]: sessionId,

package/src/ai/internal/mcpSchema/v2024_11_05.ts

@@ -29,7 +29,14 @@ export const optional = <S extends Schema.Constraint>(
       encode: SchemaGetter.transformOptional(Option.flatMap(Option.fromUndefinedOr))
     })
   )
-const JsonObject = Schema.JsonObject
+
+/**
+ * Object checked one level deep. Payloads come from `JSON.parse` or are serialized
+ * through `Schema.toCodecJson`, so deep JSON validation would be redundant.
+ *
+ * @internal
+ */
+export const UnknownObject = Schema.Record(Schema.String, Schema.Unknown)
 
 /**
  * @internal
@@ -65,7 +72,7 @@ export const RequestMeta = Schema.Struct({
     Schema.Struct({
       progressToken: optional(ProgressToken)
     }),
-    [Schema.JsonObject]
+    [UnknownObject]
   ))
 })
 
@@ -73,14 +80,14 @@ export const RequestMeta = Schema.Struct({
  * @internal
  */
 export const NotificationMeta = Schema.Struct({
-  _meta: optional(JsonObject)
+  _meta: optional(UnknownObject)
 })
 
 /**
  * @internal
  */
 export const ResultMeta = Schema.Struct({
-  _meta: optional(JsonObject)
+  _meta: optional(UnknownObject)
 })
 
 /**
@@ -111,21 +118,21 @@ export const Implementation = Schema.Struct({
  * @internal
  */
 export const ClientCapabilities = Schema.Struct({
-  extensions: optional(Schema.Record(Schema.TemplateLiteral([Schema.String, "/", Schema.String]), Schema.Json)),
-  experimental: optional(Schema.Record(Schema.String, JsonObject)),
+  extensions: optional(Schema.Record(Schema.TemplateLiteral([Schema.String, "/", Schema.String]), Schema.Unknown)),
+  experimental: optional(Schema.Record(Schema.String, UnknownObject)),
   roots: optional(Schema.Struct({
     listChanged: optional(Schema.Boolean)
   })),
-  sampling: optional(JsonObject)
+  sampling: optional(UnknownObject)
 })
 
 /**
  * @internal
  */
 export const ServerCapabilities = Schema.Struct({
-  extensions: optional(Schema.Record(Schema.TemplateLiteral([Schema.String, "/", Schema.String]), Schema.Json)),
-  experimental: optional(Schema.Record(Schema.String, JsonObject)),
-  logging: optional(JsonObject),
+  extensions: optional(Schema.Record(Schema.TemplateLiteral([Schema.String, "/", Schema.String]), Schema.Unknown)),
+  experimental: optional(Schema.Record(Schema.String, UnknownObject)),
+  logging: optional(UnknownObject),
   prompts: optional(Schema.Struct({
     listChanged: optional(Schema.Boolean)
   })),
@@ -284,7 +291,7 @@ export const PromptMessage = Schema.Struct({
  */
 export const ToolInputSchema = Schema.Struct({
   type: Schema.Literal("object"),
-  properties: optional(Schema.Record(Schema.String, JsonObject)),
+  properties: optional(Schema.Record(Schema.String, UnknownObject)),
   required: optional(Schema.Array(Schema.String))
 })
 
@@ -582,7 +589,7 @@ export class CallTool extends Rpc.make("tools/call", {
   payload: {
     ...RequestMeta.fields,
     name: Schema.String,
-    arguments: optional(JsonObject)
+    arguments: optional(UnknownObject)
   }
 }) {}
 
@@ -610,7 +617,7 @@ export class CreateMessage extends Rpc.make("sampling/createMessage", {
     temperature: optional(Schema.Finite),
     maxTokens: Schema.Finite,
     stopSequences: optional(Schema.Array(Schema.String)),
-    metadata: optional(JsonObject)
+    metadata: optional(UnknownObject)
   }
 }) {}
 

package/src/ai/internal/mcpSchema/v2025_03_26.ts

@@ -21,6 +21,8 @@ export const protocolVersion = "2025-03-26"
 
 const optional = Previous.optional
 
+const UnknownObject = Previous.UnknownObject
+
 /**
  * @internal
  */
@@ -186,7 +188,7 @@ export class CallTool extends Rpc.make("tools/call", {
   payload: {
     ...Previous.RequestMeta.fields,
     name: Schema.String,
-    arguments: optional(Schema.JsonObject)
+    arguments: optional(UnknownObject)
   }
 }) {}
 
@@ -205,7 +207,7 @@ export class CreateMessage extends Rpc.make("sampling/createMessage", {
     temperature: optional(Schema.Finite),
     maxTokens: Schema.Finite,
     stopSequences: optional(Schema.Array(Schema.String)),
-    metadata: optional(Schema.JsonObject)
+    metadata: optional(UnknownObject)
   }
 }) {}
 

package/src/ai/internal/mcpSchema/v2025_06_18.ts

@@ -19,8 +19,8 @@ export * from "./v2025_03_26.ts"
 export const protocolVersion = "2025-06-18"
 
 const optional = Previous.optional
-const JsonObject = Schema.JsonObject
-const Meta = optional(JsonObject)
+const UnknownObject = Previous.UnknownObject
+const Meta = optional(UnknownObject)
 
 /**
  * @internal
@@ -218,10 +218,10 @@ export class Initialize extends Rpc.make("initialize", {
 const ToolJsonSchema = Schema.StructWithRest(
   Schema.Struct({
     type: Schema.Literal("object"),
-    properties: optional(Schema.Record(Schema.String, JsonObject)),
+    properties: optional(Schema.Record(Schema.String, Schema.Union([UnknownObject, Schema.Boolean]))),
     required: optional(Schema.Array(Schema.String))
   }),
-  [Schema.JsonObject]
+  [UnknownObject]
 )
 
 /**
@@ -243,7 +243,7 @@ export const Tool = Schema.Struct({
 export const CallToolResult = Schema.Struct({
   ...Previous.ResultMeta.fields,
   content: Schema.Array(ContentBlock),
-  structuredContent: optional(JsonObject),
+  structuredContent: optional(UnknownObject),
   isError: optional(Schema.Boolean)
 })
 
@@ -273,7 +273,7 @@ export class CreateMessage extends Rpc.make("sampling/createMessage", {
     temperature: optional(Schema.Finite),
     maxTokens: Schema.Finite,
     stopSequences: optional(Schema.Array(Schema.String)),
-    metadata: optional(JsonObject)
+    metadata: optional(UnknownObject)
   }
 }) {}
 
@@ -433,7 +433,7 @@ export class CallTool extends Rpc.make("tools/call", {
   payload: {
     ...Previous.RequestMeta.fields,
     name: Schema.String,
-    arguments: optional(JsonObject)
+    arguments: optional(UnknownObject)
   }
 }) {}
 

package/src/ai/internal/mcpSchema/v2025_11_25.ts

@@ -19,8 +19,8 @@ export * from "./v2025_06_18.ts"
 export const protocolVersion = "2025-11-25"
 
 const optional = Previous.optional
-const JsonObject = Schema.JsonObject
-const Meta = optional(JsonObject)
+const UnknownObject = Previous.UnknownObject
+const Meta = optional(UnknownObject)
 
 /**
  * @internal
@@ -48,12 +48,12 @@ export const Implementation = Schema.Struct({
 export const ClientCapabilities = Schema.Struct({
   ...Previous.ClientCapabilities.fields,
   sampling: optional(Schema.Struct({
-    context: optional(JsonObject),
-    tools: optional(JsonObject)
+    context: optional(UnknownObject),
+    tools: optional(UnknownObject)
   })),
   elicitation: optional(Schema.Struct({
-    form: optional(JsonObject),
-    url: optional(JsonObject)
+    form: optional(UnknownObject),
+    url: optional(UnknownObject)
   }))
 })
 
@@ -182,7 +182,7 @@ export const ToolUseContent = Schema.Struct({
   type: Schema.Literal("tool_use"),
   id: Schema.String,
   name: Schema.String,
-  input: JsonObject,
+  input: UnknownObject,
   _meta: Meta
 })
 
@@ -193,7 +193,7 @@ export const ToolResultContent = Schema.Struct({
   type: Schema.Literal("tool_result"),
   toolUseId: Schema.String,
   content: Schema.Array(ContentBlock),
-  structuredContent: optional(JsonObject),
+  structuredContent: optional(UnknownObject),
   isError: optional(Schema.Boolean),
   _meta: Meta
 })