effect 4.0.0 → 4.0.1

package/src/Stream.ts

@@ -13861,41 +13861,40 @@ export const scan: {
   f: (s: S, a: A) => S
 ): Stream<S, E, R> =>
   suspend(() => {
-    let isFirst = true
-    return fromChannel(Channel.mapAccum(self.channel, initial, (state, arr) => {
-      const states = Arr.empty</**
-       * Accumulates state across the stream, emitting the initial state and each updated state.
-       *
-       * **Example** (Scanning stream state)
-       *
-       * ```ts import.meta.vitest
-       * import { Effect, Stream } from "effect"
-       *
-       * const program = Effect.gen(function*() {
-       *   const values = yield* Stream.make(1, 2, 3).pipe(
-       *     Stream.scan(() => 0, (acc, n) => acc + n),
-       *     Stream.runCollect
-       *   )
-       *   values // => [ 0, 1, 3, 6 ]
-       * })
-       *
-       * await Effect.runPromise(program)
-       * ```
-       *
-       * @category accumulation
-       * @since 2.0.0
-       */
-      S>() as Arr.NonEmptyArray<S>
-      if (isFirst) {
-        isFirst = false
-        states.push(state)
-      }
-      for (let index = 0; index < arr.length; index++) {
-        state = f(state, arr[index])
-        states.push(state)
-      }
-      return [state, Arr.of(states)]
-    }));
+    const seed = initial()
+    return concat(
+      succeed(seed),
+      fromChannel(Channel.mapAccum(self.channel, () => seed, (state, arr) => {
+        const states = Arr.empty</**
+         * Accumulates state across the stream, emitting the initial state and each updated state.
+         *
+         * **Example** (Scanning stream state)
+         *
+         * ```ts import.meta.vitest
+         * import { Effect, Stream } from "effect"
+         *
+         * const program = Effect.gen(function*() {
+         *   const values = yield* Stream.make(1, 2, 3).pipe(
+         *     Stream.scan(() => 0, (acc, n) => acc + n),
+         *     Stream.runCollect
+         *   )
+         *   values // => [ 0, 1, 3, 6 ]
+         * })
+         *
+         * await Effect.runPromise(program)
+         * ```
+         *
+         * @category accumulation
+         * @since 2.0.0
+         */
+        S>() as Arr.NonEmptyArray<S>
+        for (let index = 0; index < arr.length; index++) {
+          state = f(state, arr[index])
+          states.push(state)
+        }
+        return [state, Arr.of(states)]
+      }))
+    );
   }))
 
 /**
@@ -14329,37 +14328,36 @@ const throttleShapeEffect = <A, E, R, E2, R2>(
       const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
       const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst
       let tokens = units
-      let timestampMs = clock.currentTimeMillisUnsafe()
+      let timestampNanos = clock.monotonicTimeNanosUnsafe()
 
       return Effect.succeed(Effect.flatMap(pull, (arr) =>
         Effect.flatMap(cost(arr), (weight) => {
-          const currentMs = clock.currentTimeMillisUnsafe()
-          const elapsed = currentMs - timestampMs
+          const currentNanos = clock.monotonicTimeNanosUnsafe()
+          const elapsed = Number(currentNanos - timestampNanos) / 1_000_000
           const cycles = elapsed / durationMs
           const sum = tokens + (cycles * units)
-          const available = sum < 0 ? max : Math.min(sum, max)
+          const available = Math.min(sum, max)
           const remaining = available - weight
 
           if (remaining >= 0) {
             tokens = remaining
-            timestampMs = currentMs
+            timestampNanos = currentNanos
             return Effect.succeed(arr)
           }
 
-          // Calculate delay needed
           const waitCycles = -remaining / units
           const delayMs = Math.max(0, waitCycles * durationMs)
 
           if (delayMs > 0) {
             return Effect.flatMap(Effect.sleep(delayMs), () => {
               tokens = remaining
-              timestampMs = currentMs
+              timestampNanos = currentNanos
               return Effect.succeed(arr)
             })
           }
 
           tokens = remaining
-          timestampMs = currentMs
+          timestampNanos = currentNanos
           return Effect.succeed(arr)
         })))
     }))
@@ -14629,8 +14627,9 @@ export const grouped: {
  *
  * **Details**
  *
- * Finite fractional chunk sizes are rounded down. `NaN` and non-positive sizes
- * are treated as `1`.
+ * The duration starts when the first element of a group arrives, so an idle
+ * stream does not wake up. Finite fractional chunk sizes are rounded down.
+ * `NaN` and non-positive sizes are treated as `1`.
  *
  * **Example** (Grouping elements by size or time)
  *
@@ -14658,8 +14657,9 @@ export const groupedWithin: {
    *
    * **Details**
    *
-   * Finite fractional chunk sizes are rounded down. `NaN` and non-positive sizes
-   * are treated as `1`.
+   * The duration starts when the first element of a group arrives, so an idle
+   * stream does not wake up. Finite fractional chunk sizes are rounded down.
+   * `NaN` and non-positive sizes are treated as `1`.
    *
    * **Example** (Grouping elements by size or time)
    *
@@ -14687,8 +14687,9 @@ export const groupedWithin: {
    *
    * **Details**
    *
-   * Finite fractional chunk sizes are rounded down. `NaN` and non-positive sizes
-   * are treated as `1`.
+   * The duration starts when the first element of a group arrives, so an idle
+   * stream does not wake up. Finite fractional chunk sizes are rounded down.
+   * `NaN` and non-positive sizes are treated as `1`.
    *
    * **Example** (Grouping elements by size or time)
    *
@@ -15439,6 +15440,18 @@ export const aggregate: {
  * **Details**
  *
  * The schedule can flush the current aggregation even if the sink has not finished.
+ * It is stepped at most once per aggregation, when the aggregation receives its
+ * first element, with the previous aggregation's output as input. An aggregation
+ * the sink completes immediately, such as one built from leftovers, may finish
+ * without stepping the schedule.
+ *
+ * Time between aggregations is hidden from the schedule, so an idle stream does
+ * not run it. Time-based schedules such as `Schedule.fixed` and
+ * `Schedule.upTo({ duration })` only count time spent aggregating; use
+ * `Schedule.spaced` for a flush timer.
+ *
+ * When the schedule ends, the stream emits the current aggregation and any sink
+ * leftovers, then ends without pulling more from upstream.
  *
  * **Example** (Aggregating with a sink and schedule)
  *
@@ -15468,6 +15481,18 @@ export const aggregateWithin: {
    * **Details**
    *
    * The schedule can flush the current aggregation even if the sink has not finished.
+   * It is stepped at most once per aggregation, when the aggregation receives its
+   * first element, with the previous aggregation's output as input. An aggregation
+   * the sink completes immediately, such as one built from leftovers, may finish
+   * without stepping the schedule.
+   *
+   * Time between aggregations is hidden from the schedule, so an idle stream does
+   * not run it. Time-based schedules such as `Schedule.fixed` and
+   * `Schedule.upTo({ duration })` only count time spent aggregating; use
+   * `Schedule.spaced` for a flush timer.
+   *
+   * When the schedule ends, the stream emits the current aggregation and any sink
+   * leftovers, then ends without pulling more from upstream.
    *
    * **Example** (Aggregating with a sink and schedule)
    *
@@ -15500,6 +15525,18 @@ export const aggregateWithin: {
    * **Details**
    *
    * The schedule can flush the current aggregation even if the sink has not finished.
+   * It is stepped at most once per aggregation, when the aggregation receives its
+   * first element, with the previous aggregation's output as input. An aggregation
+   * the sink completes immediately, such as one built from leftovers, may finish
+   * without stepping the schedule.
+   *
+   * Time between aggregations is hidden from the schedule, so an idle stream does
+   * not run it. Time-based schedules such as `Schedule.fixed` and
+   * `Schedule.upTo({ duration })` only count time spent aggregating; use
+   * `Schedule.spaced` for a flush timer.
+   *
+   * When the schedule ends, the stream emits the current aggregation and any sink
+   * leftovers, then ends without pulling more from upstream.
    *
    * **Example** (Aggregating with a sink and schedule)
    *
@@ -15543,6 +15580,18 @@ export const aggregateWithin: {
      * **Details**
      *
      * The schedule can flush the current aggregation even if the sink has not finished.
+     * It is stepped at most once per aggregation, when the aggregation receives its
+     * first element, with the previous aggregation's output as input. An aggregation
+     * the sink completes immediately, such as one built from leftovers, may finish
+     * without stepping the schedule.
+     *
+     * Time between aggregations is hidden from the schedule, so an idle stream does
+     * not run it. Time-based schedules such as `Schedule.fixed` and
+     * `Schedule.upTo({ duration })` only count time spent aggregating; use
+     * `Schedule.spaced` for a flush timer.
+     *
+     * When the schedule ends, the stream emits the current aggregation and any sink
+     * leftovers, then ends without pulling more from upstream.
      *
      * **Example** (Aggregating with a sink and schedule)
      *
@@ -15571,6 +15620,18 @@ export const aggregateWithin: {
      * **Details**
      *
      * The schedule can flush the current aggregation even if the sink has not finished.
+     * It is stepped at most once per aggregation, when the aggregation receives its
+     * first element, with the previous aggregation's output as input. An aggregation
+     * the sink completes immediately, such as one built from leftovers, may finish
+     * without stepping the schedule.
+     *
+     * Time between aggregations is hidden from the schedule, so an idle stream does
+     * not run it. Time-based schedules such as `Schedule.fixed` and
+     * `Schedule.upTo({ duration })` only count time spent aggregating; use
+     * `Schedule.spaced` for a flush timer.
+     *
+     * When the schedule ends, the stream emits the current aggregation and any sink
+     * leftovers, then ends without pulling more from upstream.
      *
      * **Example** (Aggregating with a sink and schedule)
      *
@@ -15597,25 +15658,41 @@ export const aggregateWithin: {
       capacity: 0
     })
 
-    // upstream -> buffer
     yield* pull.pipe(
       pullLatch.whenOpen,
       Effect.flatMap((arr) => {
         pullLatch.closeUnsafe()
         return Queue.offer(buffer, arr)
       }),
-      Effect.forever, // don't disable autoYield to prevent choking the schedule
+      Effect.forever, // Keep autoYield enabled so the schedule can run.
       Effect.catchCause((cause) => Queue.failCause(buffer, cause)),
       Effect.forkIn(scope)
     )
 
-    // schedule -> buffer
+    // The schedule clock excludes time between aggregations.
+    const clock = yield* Clock
+    const step = yield* Schedule.toStep(schedule)
+    const hasInput = Latch.makeUnsafe(false)
+    let scheduleTime = clock.currentTimeMillisUnsafe()
+    let openedAt = 0
     let lastOutput = Option.none</**
      * Aggregates elements with a sink, emitting each result when the sink completes or the schedule triggers.
      *
      * **Details**
      *
      * The schedule can flush the current aggregation even if the sink has not finished.
+     * It is stepped at most once per aggregation, when the aggregation receives its
+     * first element, with the previous aggregation's output as input. An aggregation
+     * the sink completes immediately, such as one built from leftovers, may finish
+     * without stepping the schedule.
+     *
+     * Time between aggregations is hidden from the schedule, so an idle stream does
+     * not run it. Time-based schedules such as `Schedule.fixed` and
+     * `Schedule.upTo({ duration })` only count time spent aggregating; use
+     * `Schedule.spaced` for a flush timer.
+     *
+     * When the schedule ends, the stream emits the current aggregation and any sink
+     * leftovers, then ends without pulling more from upstream.
      *
      * **Example** (Aggregating with a sink and schedule)
      *
@@ -15640,58 +15717,51 @@ export const aggregateWithin: {
      */
     B>()
     let leftover: Arr.NonEmptyReadonlyArray<A2> | undefined
-    let sinkHasInput = false
-    const step = yield* Schedule.toStepWithSleep(schedule)
-    const stepLoop = Effect.suspend(function loop(): Pull.Pull<void, E3, C | void, R3> {
-      return Effect.flatMap(step(lastOutput), () => !sinkHasInput ? loop() : Queue.offer(buffer, scheduleStep))
-    })
-    const stepToBuffer: Pull.Pull<never, E3, void, R3> = stepLoop.pipe(
-      Effect.flatMap(() => Effect.never),
-      Pull.catchDone(() => Cause.done())
-    )
-
-    // buffer -> sink
-    const pullFromBuffer: Pull.Pull<
-      Arr.NonEmptyReadonlyArray<A>,
-      E
-    > = Queue.take(buffer).pipe(
-      Effect.flatMap((arr) => {
-        if (arr === scheduleStep) {
-          return Cause.done()
-        }
-        sinkHasInput = true
-        return Effect.succeed(arr)
-      })
+    const onInput = <X>(chunk: X): Effect.Effect<X> => {
+      if (hasInput.openUnsafe()) {
+        openedAt = clock.currentTimeMillisUnsafe()
+      }
+      return Effect.succeed(chunk)
+    }
+    const stepToBuffer: Pull.Pull<never, E3, void, R3> = hasInput.await.pipe(
+      Effect.flatMap(() => step(scheduleTime, lastOutput)),
+      Effect.flatMap(([, delay]) => Effect.sleep(delay)),
+      Effect.flatMap(() => Queue.offer(buffer, scheduleStep)),
+      // End input so the sink drains leftovers without further upstream pulls.
+      Pull.catchDone(() => Queue.end(buffer)),
+      Effect.flatMap(() => Effect.never)
     )
 
     const sinkUpstream = Effect.suspend((): Pull.Pull<Arr.NonEmptyReadonlyArray<A | A2>, E> => {
       if (leftover !== undefined) {
         const chunk = leftover
         leftover = undefined
-        sinkHasInput = true
-        return Effect.succeed(chunk)
+        return onInput(chunk)
+      }
+      if (buffer.state._tag === "Open") {
+        pullLatch.openUnsafe()
       }
-      pullLatch.openUnsafe()
-      return pullFromBuffer
+      return Effect.flatMap(Queue.take(buffer), (arr) => arr === scheduleStep ? Cause.done() : onInput(arr))
     })
-    const catchSinkHalt = Effect.flatMap(([value, leftover_]: Sink.End<B, A2>) => {
-      // ignore the last output if the upstream only pulled a halt
-      if (!sinkHasInput && buffer.state._tag === "Done") return Cause.done()
+    const emit = Effect.flatMap(([value, leftover_]: Sink.End<B, A2>) => {
+      if (hasInput.isOpen()) {
+        scheduleTime += clock.currentTimeMillisUnsafe() - openedAt
+      } else if (buffer.state._tag === "Done") {
+        return Cause.done()
+      }
       lastOutput = Option.some(value)
       leftover = leftover_
       return Effect.succeed(Arr.of(value))
     })
 
-    return Effect.suspend(() => {
-      // if the buffer has exited and there is no more data to process
+    return Effect.suspend((): Pull.Pull<Arr.NonEmptyReadonlyArray<B>, E | E2 | E3, void, R2 | R3> => {
       if (buffer.state._tag === "Done" && leftover === undefined) {
         return buffer.state.exit as Exit.Exit<never, Cause.Done<void> | E>
       }
-      sinkHasInput = leftover !== undefined
-      return Effect.succeed(Effect.suspend(() => sink.transform(sinkUpstream as any, scope)))
-    }).pipe(
-      Effect.flatMap((pull) => Effect.raceFirst(catchSinkHalt(pull), stepToBuffer))
-    )
+      hasInput.closeUnsafe()
+      const pull = emit(Effect.suspend(() => sink.transform(sinkUpstream as any, scope)))
+      return buffer.state._tag === "Open" ? Effect.raceFirst(pull, stepToBuffer) : pull
+    })
   }))))
 
 /**

package/src/ai/LanguageModel.ts

@@ -107,6 +107,13 @@ export const TypeId: TypeId = "~effect/ai/LanguageModel"
 export interface LanguageModel {
   readonly [TypeId]: TypeId
 
+  /**
+   * Whether the effective provider configuration supports system messages in
+   * history. Evaluate in the request's context to respect scoped overrides.
+   * Placement restrictions may apply; an absent capability means unknown support.
+   */
+  readonly supportsSystemMessagesInHistory?: Effect.Effect<boolean> | undefined
+
   /**
    * Generate text using the language model.
    */
@@ -833,6 +840,9 @@ export const make: (params: {
    * for structured output generation.
    */
   readonly codecTransformer?: CodecTransformer | undefined
+
+  /** Whether the effective provider configuration supports system messages in history. */
+  readonly supportsSystemMessagesInHistory?: Effect.Effect<boolean> | undefined
 }) => Effect.Effect<LanguageModel> = Effect.fnUntraced(function*(params) {
   const codecTransformer = params.codecTransformer ?? defaultCodecTransformer
 
@@ -1749,6 +1759,7 @@ export const make: (params: {
 
   return LanguageModel.of({
     [TypeId]: TypeId,
+    supportsSystemMessagesInHistory: params.supportsSystemMessagesInHistory,
     generateText: generateText as LanguageModel["generateText"],
     generateObject: generateObject as LanguageModel["generateObject"],
     streamText: streamText as LanguageModel["streamText"]
@@ -2417,18 +2428,32 @@ const resolveToolCalls = <Tools extends Record<string, Tool.Any>>(
 // Utilities
 // =============================================================================
 
+// Stable parameter-mode copies let Response reuse each tool's part schemas.
+const parameterModeTools = new WeakMap<Tool.Any, { encoded?: Tool.Any; opaque?: Tool.Any }>()
+
+const withParameterMode = (tool: Tool.Any, mode: "encoded" | "opaque"): Tool.Any => {
+  let tools = parameterModeTools.get(tool)
+  if (tools === undefined) {
+    tools = {}
+    parameterModeTools.set(tool, tools)
+  }
+  return tools[mode] ??= tool.setParameters(
+    mode === "encoded" ? Schema.toEncoded(tool.parametersSchema) : Schema.Unknown
+  )
+}
+
 const makeToolkitWithEncodedParameters = <Tools extends Record<string, Tool.Any>>(
   toolkit: Toolkit.WithHandler<Tools>
 ): Toolkit.Any =>
   Toolkit.make(
-    ...Object.values(toolkit.tools).map((tool) => tool.setParameters(Schema.toEncoded(tool.parametersSchema)))
+    ...Object.values(toolkit.tools).map((tool) => withParameterMode(tool, "encoded"))
   )
 
 const makeToolkitWithOpaqueParameters = <Tools extends Record<string, Tool.Any>>(
   toolkit: Toolkit.WithHandler<Tools>
 ): Toolkit.Any =>
   Toolkit.make(
-    ...Object.values(toolkit.tools).map((tool) => tool.setParameters(Schema.Unknown))
+    ...Object.values(toolkit.tools).map((tool) => withParameterMode(tool, "opaque"))
   )
 
 // Provider-executed tools bypass Toolkit, so validate their parameters here.

package/src/ai/McpSchema.ts

@@ -86,10 +86,10 @@ export const optionalWithDefault = <S extends Schema.Constraint & Schema.Without
  */
 export const optional = <S extends Schema.Constraint>(
   schema: S
-): Schema.decodeTo<Schema.optional<S>, Schema.optionalKey<S>> =>
+): Schema.decodeTo<Schema.toType<Schema.optional<S>>, Schema.optionalKey<S>> =>
   Schema.optionalKey(schema).pipe(
-    Schema.decodeTo(Schema.optional(schema), {
-      decode: SchemaGetter.passthrough() as any,
+    Schema.decodeTo(Schema.toType(Schema.optional(schema)), {
+      decode: SchemaGetter.passthrough(),
       encode: SchemaGetter.transformOptional(Option.flatMap(Option.fromUndefinedOr))
     })
   )

package/src/ai/McpServer.ts

@@ -1620,7 +1620,7 @@ const layerMcpProtocolHttp = (options: {
           const hasMultipleMessages = response.body._tag === "Uint8Array" &&
             response.body.body.subarray(0, -1).includes(10)
           return admission.isSubscription || response.body._tag === "Stream" || hasMultipleMessages
-            ? toServerSentEvents(response)
+            ? toServerSentEvents(response, admission.isSubscription)
             : response
         })
         return yield* admission.acknowledge
@@ -1713,7 +1713,7 @@ function mcpJsonRpcSerialization(options?: {
   })
 }
 
-const toServerSentEvents = (response: HttpServerResponse.HttpServerResponse) => {
+const toServerSentEvents = (response: HttpServerResponse.HttpServerResponse, keepAlive: boolean) => {
   const encoder = new TextEncoder()
   const decoder = new TextDecoder()
   const frame = (data: Uint8Array) =>
@@ -1726,7 +1726,16 @@ const toServerSentEvents = (response: HttpServerResponse.HttpServerResponse) =>
     contentType: "text/event-stream"
   }
   if (response.body._tag === "Stream") {
-    return HttpServerResponse.stream(response.body.stream.pipe(Stream.map(frame)), options)
+    const events = response.body.stream.pipe(Stream.map(frame))
+    if (!keepAlive) {
+      return HttpServerResponse.stream(events, options)
+    }
+    // Keep a native timer pending so workerd does not treat idle subscriptions as hung requests.
+    const keepAliveComments = Stream.tick("15 seconds").pipe(
+      Stream.drop(1),
+      Stream.map(() => encoder.encode(": keepalive\n\n"))
+    )
+    return HttpServerResponse.stream(Stream.merge(events, keepAliveComments, { haltStrategy: "left" }), options)
   }
   if (response.body._tag === "Uint8Array") {
     return HttpServerResponse.uint8Array(frame(response.body.body), options)

package/src/ai/Response.ts

@@ -152,6 +152,24 @@ export type AllPartsEncoded =
   | FinishPartEncoded
   | ErrorPartEncoded
 
+// Tools are immutable, so response schemas can share their per-tool parts.
+const toolPartSchemaCache = new WeakMap<Tool.Any, {
+  readonly toolCall: Schema.Top
+  readonly toolResult: Schema.Top
+}>()
+
+const toolPartSchemas = (tool: Tool.Any) => {
+  let parts = toolPartSchemaCache.get(tool)
+  if (parts === undefined) {
+    parts = {
+      toolCall: ToolCallPart(tool.name, tool.parametersSchema),
+      toolResult: ToolResultPart(tool.name, tool.successSchema, Tool.failureResultSchema(tool))
+    }
+    toolPartSchemaCache.set(tool, parts)
+  }
+  return parts
+}
+
 /**
  * Creates a Schema for all response parts based on a toolkit.
  *
@@ -192,10 +210,9 @@ export const AllParts = <T extends Toolkit.Any | Toolkit.WithHandler<any>>(
   const toolCalls: Array<Schema.Top> = []
   const toolResults: Array<Schema.Top> = []
   for (const tool of Object.values(toolkit.tools as Record<string, Tool.Any>)) {
-    const toolCall = ToolCallPart(tool.name, tool.parametersSchema)
-    const toolResult = ToolResultPart(tool.name, tool.successSchema, Tool.failureResultSchema(tool))
-    toolCalls.push(toolCall)
-    toolResults.push(toolResult)
+    const parts = toolPartSchemas(tool)
+    toolCalls.push(parts.toolCall)
+    toolResults.push(parts.toolResult)
   }
   return Schema.Union([
     TextPart,
@@ -287,10 +304,9 @@ export const Part = <T extends Toolkit.Any | Toolkit.WithHandler<any>>(
   const toolCalls: Array<Schema.Top> = []
   const toolResults: Array<Schema.Top> = []
   for (const tool of Object.values(toolkit.tools as Record<string, Tool.Any>)) {
-    const toolCall = ToolCallPart(tool.name, tool.parametersSchema)
-    const toolResult = ToolResultPart(tool.name, tool.successSchema, Tool.failureResultSchema(tool))
-    toolCalls.push(toolCall)
-    toolResults.push(toolResult)
+    const parts = toolPartSchemas(tool)
+    toolCalls.push(parts.toolCall)
+    toolResults.push(parts.toolResult)
   }
   return Schema.Union([
     TextPart,
@@ -385,10 +401,9 @@ export const StreamPart = <T extends Toolkit.Any | Toolkit.WithHandler<any>>(
   const toolCalls: Array<Schema.Top> = []
   const toolResults: Array<Schema.Top> = []
   for (const tool of Object.values(toolkit.tools as Record<string, Tool.Any>)) {
-    const toolCall = ToolCallPart(tool.name, tool.parametersSchema)
-    const toolResult = ToolResultPart(tool.name, tool.successSchema, Tool.failureResultSchema(tool))
-    toolCalls.push(toolCall)
-    toolResults.push(toolResult)
+    const parts = toolPartSchemas(tool)
+    toolCalls.push(parts.toolCall)
+    toolResults.push(parts.toolResult)
   }
   return Schema.Union([
     TextStartPart,

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

@@ -53,6 +53,7 @@ const projectCapabilities = (
   capabilities: McpCore.CanonicalServerCapabilities
 ): typeof McpSchema.ServerCapabilities.Type => ({
   experimental: capabilities.experimental,
+  extensions: capabilities.extensions,
   logging: capabilities.logging ? {} : undefined,
   prompts: capabilities.prompts,
   resources: capabilities.resources,

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

@@ -134,6 +134,7 @@ export const protocol = McpProtocol.make({
               protocolVersion: McpSchema.protocolVersion,
               capabilities: ({
                 experimental: result.capabilities.experimental,
+                extensions: result.capabilities.extensions,
                 logging: result.capabilities.logging ? {} : undefined,
                 completions: result.capabilities.completions ? {} : undefined,
                 prompts: result.capabilities.prompts,

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

@@ -150,6 +150,7 @@ export const protocol = McpProtocol.make({
               protocolVersion: McpSchema.protocolVersion,
               capabilities: ({
                 experimental: result.capabilities.experimental,
+                extensions: result.capabilities.extensions,
                 logging: result.capabilities.logging ? {} : undefined,
                 completions: result.capabilities.completions ? {} : undefined,
                 prompts: result.capabilities.prompts,

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

@@ -145,6 +145,7 @@ export const protocol = McpProtocol.make({
               protocolVersion: McpSchema.protocolVersion,
               capabilities: ({
                 experimental: result.capabilities.experimental,
+                extensions: result.capabilities.extensions,
                 logging: result.capabilities.logging ? {} : undefined,
                 completions: result.capabilities.completions ? {} : undefined,
                 prompts: result.capabilities.prompts,

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

@@ -22,9 +22,9 @@ export const protocolVersion = "2024-11-05"
  */
 export const optional = <S extends Schema.Constraint>(
   schema: S
-): Schema.decodeTo<Schema.optional<S>, Schema.optionalKey<S>> =>
+): Schema.decodeTo<Schema.toType<Schema.optional<S>>, Schema.optionalKey<S>> =>
   Schema.optionalKey(schema).pipe(
-    Schema.decodeTo(Schema.optional(schema), {
+    Schema.decodeTo(Schema.toType(Schema.optional(schema)), {
       decode: SchemaGetter.passthrough(),
       encode: SchemaGetter.transformOptional(Option.flatMap(Option.fromUndefinedOr))
     })
@@ -111,6 +111,7 @@ 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)),
   roots: optional(Schema.Struct({
     listChanged: optional(Schema.Boolean)
@@ -122,6 +123,7 @@ export const ClientCapabilities = Schema.Struct({
  * @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),
   prompts: optional(Schema.Struct({