effect 4.0.5 → 4.0.7

package/src/ai/Tool.ts

@@ -115,7 +115,9 @@ export type DynamicTypeId = "~effect/ai/Tool/Dynamic"
  * execution will be returned in the error channel of the calling effect.
  *
  * If set to `"return"`, errors that occur during tool call handler execution
- * will be captured and returned as part of the tool call result.
+ * will be captured and returned as part of the tool call result. Like
+ * `Effect.catch`, only the first typed failure is returned, and a cause
+ * containing a defect is raised as a defect.
  *
  * @stability unstable
  * @category models
@@ -246,7 +248,9 @@ export interface Tool<
    * effect.
    *
    * If set to `"return"`, errors that occur during tool call handler execution
-   * will be captured and returned as part of the tool call result.
+   * will be captured and returned as part of the tool call result. Like
+   * `Effect.catch`, only the first typed failure is returned, and a cause
+   * containing a defect is raised as a defect.
    */
   readonly failureMode: FailureMode
 
@@ -286,6 +290,12 @@ export interface Tool<
    */
   readonly needsApproval?: boolean | NeedsApprovalFunction<any> | undefined
 
+  /**
+   * Maps a successful tool result to the content sent to the model in place
+   * of the encoded result. `setSuccess` removes the mapping.
+   */
+  readonly toModelOutput?: ((result: any) => ReadonlyArray<Prompt.ToolModelOutputPart>) | undefined
+
   /**
    * Set whether user approval is required before executing this tool.
    */
@@ -951,6 +961,20 @@ export type ResultDecodingServices<T> = T extends Tool<
 > ? _Config["success"]["DecodingServices"] | _Config["failure"]["DecodingServices"]
   : never
 
+/**
+ * Extracts the services required to decode tool parameters.
+ *
+ * @stability unstable
+ * @category utility types
+ * @since 4.0.0
+ */
+export type ParametersDecodingServices<T> = T extends Tool<
+  infer _Name,
+  infer _Config,
+  infer _Requirements
+> ? _Config["parameters"]["DecodingServices"]
+  : never
+
 /**
  * Extracts the services required to encode tool parameters.
  *
@@ -1012,6 +1036,10 @@ export interface HandlerResult<Tool extends Any> {
    * into subsequent requests to the large language model.
    */
   readonly encodedResult: unknown
+  /**
+   * The output of the tool's `toModelOutput` mapping for a successful result.
+   */
+  readonly modelOutput?: ReadonlyArray<Prompt.ToolModelOutputPart> | undefined
   /**
    * Whether the result of executing the tool call handler was an error or not.
    */
@@ -1113,7 +1141,7 @@ const Proto = {
     return clone(this, { parametersSchema, jsonSchema: undefined })
   },
   setSuccess(this: Any, successSchema: Schema.Constraint) {
-    return clone(this, { successSchema })
+    return clone(this, { successSchema, toModelOutput: undefined })
   },
   setFailure(this: Any, failureSchema: Schema.Constraint) {
     return clone(this, { failureSchema })
@@ -1154,6 +1182,7 @@ const userDefinedProto = <
   readonly annotations: Context.Context<never>
   readonly failureMode: Mode
   readonly needsApproval?: NeedsApproval<Parameters> | undefined
+  readonly toModelOutput?: ((result: any) => ReadonlyArray<Prompt.ToolModelOutputPart>) | undefined
 }): Tool<
   Name,
   {
@@ -1216,6 +1245,7 @@ const dynamicProto = <
   readonly annotations: Context.Context<never>
   readonly failureMode: Mode
   readonly needsApproval?: NeedsApproval<any> | undefined
+  readonly toModelOutput?: ((result: any) => ReadonlyArray<Prompt.ToolModelOutputPart>) | undefined
   readonly jsonSchema: JsonSchema.JsonSchema | undefined
 }): Dynamic<
   Name,
@@ -1295,7 +1325,9 @@ export const make = <
    * execution will be returned in the error channel of the calling effect.
    *
    * If set to `"return"`, errors that occur during tool call handler execution
-   * will be captured and returned as part of the tool call result.
+   * will be captured and returned as part of the tool call result. Like
+   * `Effect.catch`, only the first typed failure is returned, and a cause
+   * containing a defect is raised as a defect.
    */
   readonly failureMode?: Mode
   /**
@@ -1313,6 +1345,12 @@ export const make = <
    *   dynamically determine if approval is needed.
    */
   readonly needsApproval?: NeedsApproval<Parameters> | undefined
+  /**
+   * Maps a successful tool result to the content sent to the model in place
+   * of the encoded result, such as images or files. The application still
+   * receives the typed result.
+   */
+  readonly toModelOutput?: ((result: Success["Type"]) => ReadonlyArray<Prompt.ToolModelOutputPart>) | undefined
 }): Tool<
   Name,
   {
@@ -1333,7 +1371,8 @@ export const make = <
     failureSchema,
     failureMode: options?.failureMode ?? "error",
     annotations: Context.empty(),
-    needsApproval: options?.needsApproval as any
+    needsApproval: options?.needsApproval as any,
+    toModelOutput: options?.toModelOutput
   }) as any
 }
 
@@ -1441,6 +1480,7 @@ export const dynamic: {
       readonly failure?: Schema.Constraint | undefined
       readonly failureMode?: FailureMode | undefined
       readonly needsApproval?: NeedsApproval<any> | undefined
+      readonly toModelOutput?: ((result: any) => ReadonlyArray<Prompt.ToolModelOutputPart>) | undefined
     }
   >(name: Name, options?: Options): Dynamic<
     Name,
@@ -1465,6 +1505,7 @@ export const dynamic: {
     readonly failure?: Schema.Constraint | undefined
     readonly failureMode?: FailureMode | undefined
     readonly needsApproval?: NeedsApproval<any> | undefined
+    readonly toModelOutput?: ((result: any) => ReadonlyArray<Prompt.ToolModelOutputPart>) | undefined
   }
 >(name: Name, options?: Options): any => {
   const successSchema = options?.success ?? Schema.Unknown
@@ -1482,6 +1523,7 @@ export const dynamic: {
     failureMode: options?.failureMode ?? "error",
     annotations: Context.empty(),
     needsApproval: options?.needsApproval,
+    toModelOutput: options?.toModelOutput,
     jsonSchema
   })
 }
@@ -1578,7 +1620,9 @@ export const providerDefined = <
          * execution will be returned in the error channel of the calling effect.
          *
          * If set to `"return"`, errors that occur during tool call handler execution
-         * will be captured and returned as part of the tool call result.
+         * will be captured and returned as part of the tool call result. Like
+         * `Effect.catch`, only the first typed failure is returned, and a cause
+         * containing a defect is raised as a defect.
          */
         readonly failureMode?: Mode | undefined
       }

package/src/ai/Toolkit.ts

@@ -125,7 +125,8 @@ export interface HandlerContext<Tool extends Tool.Any> {
    * **Details**
    *
    * Preliminary results are streamed to the caller before the handler completes,
-   * enabling real-time progress updates for lengthy operations.
+   * enabling real-time progress updates for lengthy operations. Results are
+   * buffered without limit unless the caller provides `PreliminaryBuffer`.
    */
   readonly preliminary: (result: Tool.Success<Tool>) => Effect.Effect<void>
 }
@@ -296,9 +297,60 @@ export const FailureOrigin = Context.Reference<Tool.FailureOrigin>("effect/ai/To
   defaultValue: () => "result"
 })
 
+/**
+ * Limits how many preliminary results `Toolkit.handle` buffers per tool call.
+ *
+ * **Details**
+ *
+ * Defaults to `"unbounded"`. Provide it as a positive integer around `handle`,
+ * or around a program that calls it, and `HandlerContext.preliminary` suspends
+ * once that many results are unconsumed. Any other value is a defect.
+ *
+ * The bound only applies to the stream returned by `handle`. Consume that
+ * stream while the handler runs; waiting for the handler before reading it
+ * deadlocks once the buffer fills. `LanguageModel` moves results into its own
+ * buffers, so the bound does not limit memory end to end there.
+ *
+ * **Example** (Bounding preliminary results)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Schema, Stream } from "effect"
+ * import { Tool, Toolkit } from "effect/ai"
+ *
+ * const toolkit = Toolkit.make(Tool.make("Progress", { success: Schema.Number }))
+ *
+ * const program = Effect.gen(function*() {
+ *   const handlers = yield* toolkit
+ *   const stream = yield* handlers.handle("Progress", {}).pipe(
+ *     Effect.provideService(Toolkit.PreliminaryBuffer, 16)
+ *   )
+ *   const results = yield* Stream.runCollect(stream)
+ *   return results.length
+ * }).pipe(
+ *   Effect.provide(toolkit.toLayer({
+ *     Progress: Effect.fnUntraced(function*(_, ctx) {
+ *       for (let i = 0; i < 64; i++) yield* ctx.preliminary(i)
+ *       return 64
+ *     })
+ *   }))
+ * )
+ *
+ * await Effect.runPromise(program) // => 65
+ * ```
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.1.0
+ */
+export const PreliminaryBuffer = Context.Reference<number | "unbounded">("effect/ai/Toolkit/PreliminaryBuffer", {
+  defaultValue: () => "unbounded"
+})
+
 const failureCause = <E>(error: E, origin: Tool.FailureOrigin): Cause.Cause<E> =>
   Cause.annotate(Cause.fail(error), Context.make(FailureOrigin, origin))
 
+const failureOrigin = (error: unknown): Tool.FailureOrigin => Schema.isSchemaError(error) ? "result" : "handler"
+
 const Proto = {
   ...Effectable.Prototype({
     label: "Toolkit",
@@ -402,11 +454,15 @@ const Proto = {
         }
         const decodedParams = decodedParamsResult.success
 
+        const capacity = yield* PreliminaryBuffer
+        if (capacity !== "unbounded" && !(Number.isInteger(capacity) && capacity > 0)) {
+          return yield* Effect.die(`Tool "${name}": PreliminaryBuffer must be a positive integer, got ${capacity}`)
+        }
         const queue = yield* Queue.make<{
           readonly result: any
           readonly isFailure: boolean
           readonly preliminary: boolean
-        }, Cause.Done>()
+        }, Cause.Done>(capacity === "unbounded" ? undefined : { capacity })
         const context: HandlerContext<any> = {
           toolCallId,
           preliminary: (result) =>
@@ -448,18 +504,33 @@ const Proto = {
         }
 
         return Stream.fromQueue(queue).pipe(
-          Stream.catch((error) => {
-            const normalizedError = normalizeError(error)
-            const failureOrigin: Tool.FailureOrigin = Schema.isSchemaError(error) ? "result" : "handler"
-            return tool.failureMode === "error"
-              ? Stream.failCause(failureCause(normalizedError, failureOrigin))
-              : Stream.succeed({ result: normalizedError, isFailure: true, failureOrigin, preliminary: false })
-          }),
+          tool.failureMode === "error"
+            ? Stream.catchCause((cause) =>
+              Stream.failCause(Cause.map(
+                Cause.fromReasons(cause.reasons.map((reason) =>
+                  Cause.isFailReason(reason)
+                    ? reason.annotate(Context.make(FailureOrigin, failureOrigin(reason.error)), { overwrite: true })
+                    : reason
+                )),
+                normalizeError
+              ))
+            )
+            : Stream.catch((error) =>
+              Stream.succeed({
+                result: normalizeError(error),
+                isFailure: true,
+                failureOrigin: failureOrigin(error),
+                preliminary: false
+              })
+            ),
           Stream.mapEffect(Effect.fnUntraced(function*(output) {
             const encodedResult = yield* encodeResult(output.result, output.isFailure)
-            return { ...output, encodedResult }
+            if (output.isFailure || output.preliminary || tool.toModelOutput === undefined) {
+              return { ...output, encodedResult }
+            }
+            return { ...output, encodedResult, modelOutput: tool.toModelOutput(output.result) }
           })),
-          Stream.onEnd(Fiber.interrupt(fiber))
+          Stream.ensuring(Fiber.interrupt(fiber))
         ) satisfies Stream.Stream<Tool.HandlerResult<any>, any>
       })
 

package/src/ai/index.ts

@@ -53,6 +53,18 @@ export * as IdGenerator from "./IdGenerator.ts"
  */
 export * as LanguageModel from "./LanguageModel.ts"
 
+/**
+ * @stability experimental
+ * @since 4.0.6
+ */
+export * as McpClient from "./McpClient.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.6
+ */
+export * as McpClientError from "./McpClientError.ts"
+
 /**
  * @stability unstable
  * @since 4.0.0

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,