effect 4.0.1 → 4.0.2

package/src/ai/internal/mcpRuntime.ts

@@ -17,6 +17,7 @@ import * as Predicate from "../../Predicate.ts"
 import * as Result from "../../Result.ts"
 import * as RpcGroup from "../../rpc/RpcGroup.ts"
 import type * as RpcMessage from "../../rpc/RpcMessage.ts"
+import type * as Scope from "../../Scope.ts"
 import type * as PublicMcpProtocol from "../McpProtocol.ts"
 import * as PublicMcpSchema from "../McpSchema.ts"
 import type * as McpCore from "./mcpCore.ts"
@@ -175,6 +176,10 @@ export interface ServerRuntimeShape {
     fallback: LogLevel.LogLevel
   ) => LogLevel.LogLevel
   readonly disconnect: (clientId: number) => void
+  readonly terminateHttpSession: (headers: Headers.Headers) => Effect.Effect<HttpServerResponse.HttpServerResponse>
+  readonly onSessionTerminated: (
+    listener: (binding: RequestBinding) => Effect.Effect<void>
+  ) => Effect.Effect<void, never, Scope.Scope>
   readonly deliveryClientIds: () => Iterable<number>
   readonly canDeliver: (
     clientId: number,
@@ -228,9 +233,36 @@ export const make = Effect.fnUntraced(function*(
     statelessProtocol = protocol
   }
   const registry = yield* McpProtocolRegistry.make(protocols)
-  const selectHttpProtocol = (headers: Headers.Headers, input: unknown): HttpProtocolSelection => {
+  const sessionTerminationListeners = new Set<(binding: RequestBinding) => Effect.Effect<void>>()
+  const unsupportedProtocolVersion = (requested: string) => ({
+    code: UNSUPPORTED_PROTOCOL_VERSION_ERROR_CODE,
+    message: `Unsupported protocol version '${requested}'`,
+    data: { supported: protocolVersions, requested }
+  })
+  const selectHttpSession = (headers: Headers.Headers, isInitialize: boolean): HttpProtocolSelection => {
     const protocolVersion = headers[MCP_PROTOCOL_VERSION_HEADER]
     const sessionId = headers[MCP_SESSION_ID_HEADER]
+    const binding = sessionId === undefined ? undefined : stateful?.resolveSessionId(sessionId)
+    if (sessionId !== undefined && binding === undefined) {
+      return { _tag: "Rejected", status: 404 }
+    }
+    if (!isInitialize && protocolVersion !== undefined) {
+      if (!protocolVersions.includes(protocolVersion)) {
+        return { _tag: "Rejected", status: 400, error: unsupportedProtocolVersion(protocolVersion) }
+      }
+      if (
+        binding?.protocol.runtime.transport.http.requiresVersionHeader === true &&
+        protocolVersion !== binding.protocol.protocolVersion
+      ) {
+        return headerMismatch(
+          `MCP-Protocol-Version header '${protocolVersion}' does not match negotiated protocol version '${binding.protocol.protocolVersion}'`
+        )
+      }
+    }
+    return { _tag: "Accepted", binding, protocol: binding?.protocol }
+  }
+  const selectHttpProtocol = (headers: Headers.Headers, input: unknown): HttpProtocolSelection => {
+    const protocolVersion = headers[MCP_PROTOCOL_VERSION_HEADER]
     const inputRecord = asRecord(input)
     const metadata = asRecord(asRecord(inputRecord?.params)?._meta)
     const claim = protocolVersionClaim(metadata)
@@ -272,18 +304,7 @@ export const make = Effect.fnUntraced(function*(
         }
       }
       if (statelessProtocol === undefined || protocolVersion !== statelessProtocol.protocolVersion) {
-        return {
-          _tag: "Rejected",
-          status: 400,
-          error: {
-            code: UNSUPPORTED_PROTOCOL_VERSION_ERROR_CODE,
-            message: `Unsupported protocol version '${protocolVersion}'`,
-            data: {
-              supported: protocolVersions,
-              requested: protocolVersion
-            }
-          }
-        }
+        return { _tag: "Rejected", status: 400, error: unsupportedProtocolVersion(protocolVersion) }
       }
       const method = inputRecord?.method
       if (typeof method !== "string" || headers[MCP_METHOD_HEADER] !== method) {
@@ -299,25 +320,7 @@ export const make = Effect.fnUntraced(function*(
       }
       return { _tag: "Accepted", binding: undefined, protocol: statelessProtocol }
     }
-    const binding = sessionId === undefined ? undefined : stateful?.resolveSessionId(sessionId)
-    if (sessionId !== undefined && binding === undefined) {
-      return { _tag: "Rejected", status: 404 }
-    }
-    if (
-      !isInitialize &&
-      protocolVersion !== undefined &&
-      !registry.protocols.some((protocol) => protocol.protocolVersion === protocolVersion)
-    ) {
-      return { _tag: "Rejected", status: 400 }
-    }
-    if (
-      !isInitialize &&
-      binding?.protocol.runtime.transport.http.requiresVersionHeader === true &&
-      protocolVersion !== binding.protocol.protocolVersion
-    ) {
-      return { _tag: "Rejected", status: 400 }
-    }
-    return { _tag: "Accepted", binding, protocol: binding?.protocol }
+    return selectHttpSession(headers, isInitialize)
   }
   return ServerRuntime.of({
     protocols: registry.protocols,
@@ -362,11 +365,7 @@ export const make = Effect.fnUntraced(function*(
         return yield* Effect.die("MCP stateless runtime invariant failed")
       }
       if (requestedVersion !== undefined && requestedVersion !== protocol.protocolVersion) {
-        return yield* new McpProtocol.ProtocolError({
-          code: UNSUPPORTED_PROTOCOL_VERSION_ERROR_CODE,
-          message: `Unsupported protocol version '${requestedVersion}'`,
-          data: { supported: protocolVersions, requested: requestedVersion }
-        })
+        return yield* new McpProtocol.ProtocolError(unsupportedProtocolVersion(requestedVersion))
       }
       const decodedProfile = yield* statelessDescriptor.profileFromRequestMetadata(metadata)
       const profile: McpCore.NegotiatedProtocolProfile<string> = {
@@ -394,12 +393,14 @@ export const make = Effect.fnUntraced(function*(
       })
       if (Result.isFailure(parsed)) {
         const version = headers[MCP_PROTOCOL_VERSION_HEADER]
-        if (version !== undefined && !registry.protocols.some((protocol) => protocol.protocolVersion === version)) {
-          return reject(400)
+        if (version !== undefined && !protocolVersions.includes(version)) {
+          return reject(400, unsupportedProtocolVersion(version))
         }
         const admission = selectHttpProtocol(headers, undefined)
-        return admission._tag === "Rejected" && admission.error === undefined
-          ? reject(admission.status)
+        // Session and protocol-header errors take precedence over parse errors.
+        return admission._tag === "Rejected" &&
+            (admission.error === undefined || admission.error.code === PublicMcpSchema.HEADER_MISMATCH_ERROR_CODE)
+          ? reject(admission.status, admission.error)
           : reject(200, new PublicMcpSchema.ParseError({ message: "Parse error" }))
       }
       const input = parsed.success
@@ -444,8 +445,21 @@ export const make = Effect.fnUntraced(function*(
       }
       const isInitialize = Predicate.hasProperty(input, "method") && input.method === "initialize"
       const hasSession = headers[MCP_SESSION_ID_HEADER] !== undefined
-      if (isInitialize ? hasSession : !hasSession && admission.protocol?.runtime._tag !== "Stateless") {
-        return reject(400)
+      if (isInitialize && hasSession) {
+        return reject(
+          400,
+          new PublicMcpSchema.InvalidRequest({ message: "initialize must not include an MCP-Session-Id header" }),
+          id
+        )
+      }
+      if (!isInitialize && !hasSession && admission.protocol?.runtime._tag !== "Stateless") {
+        return reject(
+          400,
+          stateful === undefined ? undefined : new PublicMcpSchema.InvalidRequest({
+            message: "MCP-Session-Id header is required; send initialize to start a session"
+          }),
+          id
+        )
       }
       if (
         isRequest && admission.protocol?.runtime._tag === "Stateless" &&
@@ -464,6 +478,33 @@ export const make = Effect.fnUntraced(function*(
     },
     effectLogLevel: (clientId, headers, fallback) => stateful?.effectLogLevel(clientId, headers, fallback) ?? fallback,
     disconnect: (clientId) => stateful?.disconnect(clientId),
+    terminateHttpSession: (headers) =>
+      Effect.suspend(() => {
+        const sessionId = headers[MCP_SESSION_ID_HEADER]
+        if (sessionId === undefined) {
+          return Effect.succeed(HttpServerResponse.empty({ status: 400 }))
+        }
+        const selection = selectHttpSession(headers, false)
+        if (selection._tag === "Rejected") {
+          return Effect.succeed(HttpServerResponse.empty({ status: selection.status }))
+        }
+        const binding = selection.binding!
+        stateful!.terminateSession(sessionId)
+        return Effect.as(
+          Effect.forEach(sessionTerminationListeners, (listener) => listener(binding), { discard: true }),
+          HttpServerResponse.empty({ status: 204 })
+        )
+      }),
+    onSessionTerminated: (listener) =>
+      Effect.acquireRelease(
+        Effect.sync(() => {
+          sessionTerminationListeners.add(listener)
+        }),
+        () =>
+          Effect.sync(() => {
+            sessionTerminationListeners.delete(listener)
+          })
+      ),
     deliveryClientIds: () => stateful?.initializedClientIds() ?? [],
     canDeliver: (clientId, headers, notification, fallback) =>
       stateful?.canDeliver(clientId, headers, notification, fallback) ?? true,

package/src/ai/internal/mcpStatefulRuntime.ts

@@ -47,6 +47,7 @@ export interface StatefulRuntime {
   readonly registerConnection: (clientId: number, registration: Registration) => Binding
   readonly resolve: (clientId: number, headers: Headers.Headers) => Binding | undefined
   readonly resolveSessionId: (sessionId: string) => Binding | undefined
+  readonly terminateSession: (sessionId: string) => boolean
   readonly setLogLevel: (
     level: PublicMcpSchema.LoggingLevel,
     clientId: number,
@@ -123,6 +124,7 @@ export const make = (): StatefulRuntime => {
     },
     resolve: resolveSession,
     resolveSessionId: (sessionId) => bySessionId.get(sessionId),
+    terminateSession: (sessionId) => bySessionId.delete(sessionId),
     setLogLevel: (level, clientId, headers) =>
       Effect.sync(() => {
         const session = resolveSession(clientId, headers)

package/src/cluster/K8sHttpClient.ts

@@ -56,11 +56,21 @@ export const layer: Layer.Layer<
   Effect.gen(function*() {
     const fs = yield* FileSystem.FileSystem
     const token = yield* fs.readFileString("/var/run/secrets/kubernetes.io/serviceaccount/token").pipe(
-      Effect.option
+      Effect.map((token) => token.trim()),
+      Effect.option,
+      Effect.cachedWithTTL("1 minute")
     )
     return (yield* HttpClient.HttpClient).pipe(
       HttpClient.mapRequest(HttpClientRequest.prependUrl("https://kubernetes.default.svc/api")),
-      token._tag === "Some" ? HttpClient.mapRequest(HttpClientRequest.bearerToken(token.value.trim())) : identity,
+      HttpClient.mapRequestEffect((request) =>
+        Effect.map(
+          token,
+          Option.match({
+            onNone: () => request,
+            onSome: (token) => HttpClientRequest.bearerToken(request, token)
+          })
+        )
+      ),
       HttpClient.filterStatusOk,
       HttpClient.retryTransient({
         schedule: Schedule.spaced(5000)

package/src/encoding/Base64.ts

@@ -1,6 +1,7 @@
 /**
  * Base64 encoding and decoding helpers.
  *
+ * @stability stable
  * @since 4.0.0
  */
 import * as Result from "../Result.ts"
@@ -34,6 +35,7 @@ import { EncodingError } from "./EncodingError.ts"
  * @see {@link decode} for decoding standard Base64 to bytes
  * @see {@link decodeString} for decoding standard Base64 to UTF-8 text
  *
+ * @stability stable
  * @category encoding
  * @since 4.0.0
  */
@@ -62,6 +64,7 @@ export const encode: (input: Uint8Array | string) => string = (input) =>
  * Base64.decode("SGVsbG8=") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111]))
  * ```
  *
+ * @stability stable
  * @category decoding
  * @since 4.0.0
  */
@@ -138,6 +141,7 @@ export const decode = (str: string): Result.Result<Uint8Array, EncodingError> =>
  * Base64.decodeString("aGVsbG8=") // => Result.succeed("hello")
  * ```
  *
+ * @stability stable
  * @category decoding
  * @since 4.0.0
  */

package/src/encoding/Base64Url.ts

@@ -1,6 +1,7 @@
 /**
  * URL-safe Base64 encoding and decoding helpers.
  *
+ * @stability stable
  * @since 4.0.0
  */
 import * as Result from "../Result.ts"
@@ -34,6 +35,7 @@ import { EncodingError } from "./EncodingError.ts"
  * @see {@link decode} for decoding URL-safe Base64 to bytes
  * @see {@link decodeString} for decoding URL-safe Base64 to UTF-8 text
  *
+ * @stability stable
  * @category encoding
  * @since 4.0.0
  */
@@ -62,6 +64,7 @@ export const encode: (input: Uint8Array | string) => string = (input) =>
  * Base64Url.decode("SGVsbG8_") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111, 63]))
  * ```
  *
+ * @stability stable
  * @category decoding
  * @since 4.0.0
  */
@@ -116,6 +119,7 @@ export const decode = (str: string): Result.Result<Uint8Array, EncodingError> =>
  * Base64Url.decodeString("aGVsbG8_") // => Result.succeed("hello?")
  * ```
  *
+ * @stability stable
  * @category decoding
  * @since 4.0.0
  */

package/src/encoding/EncodingError.ts

@@ -1,6 +1,7 @@
 /**
  * Shared error type for encoding and decoding operations.
  *
+ * @stability stable
  * @since 4.0.0
  */
 import * as Data from "../Data.ts"
@@ -22,6 +23,7 @@ import { hasProperty } from "../Predicate.ts"
  *
  * @see {@link isEncodingError} for the public guard that checks this marker
  *
+ * @stability stable
  * @category type IDs
  * @since 4.0.0
  */
@@ -34,6 +36,7 @@ export const EncodingErrorTypeId = "~effect/encoding/EncodingError" as const
  *
  * Use to type the marker carried by `EncodingError` values.
  *
+ * @stability stable
  * @category type IDs
  * @since 4.0.0
  */
@@ -55,6 +58,7 @@ export type EncodingErrorTypeId = typeof EncodingErrorTypeId
  *
  * @see {@link isEncodingError} for checking whether a value is an EncodingError
  *
+ * @stability stable
  * @category errors
  * @since 4.0.0
  */
@@ -92,6 +96,7 @@ export class EncodingError extends Data.TaggedError("EncodingError")<{
  * @see {@link EncodingError} for the structured error produced by failed
  * encoding and decoding operations
  *
+ * @stability stable
  * @category guards
  * @since 4.0.0
  */

package/src/encoding/Hex.ts

@@ -1,6 +1,7 @@
 /**
  * Hexadecimal encoding, decoding, and random value helpers.
  *
+ * @stability stable
  * @since 4.0.0
  */
 import * as Result from "../Result.ts"
@@ -26,6 +27,7 @@ import { EncodingError } from "./EncodingError.ts"
  * Hex.encode(bytes) // => "48656c6c6f"
  * ```
  *
+ * @stability stable
  * @category encoding
  * @since 4.0.0
  */
@@ -47,6 +49,7 @@ export const encode: (input: Uint8Array | string) => string = (input) =>
  * security-sensitive values, use the `Crypto.Crypto` service's `randomBytes`
  * method and encode the result with {@link encode}.
  *
+ * @stability stable
  * @category encoding
  * @since 4.0.0
  */
@@ -173,6 +176,7 @@ const random32 = (): string => {
  * Hex.decode("48656c6c6f") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111]))
  * ```
  *
+ * @stability stable
  * @category decoding
  * @since 4.0.0
  */
@@ -233,6 +237,7 @@ export const decode = (str: string): Result.Result<Uint8Array, EncodingError> =>
  * Hex.decodeString("68656c6c6f") // => Result.succeed("hello")
  * ```
  *
+ * @stability stable
  * @category decoding
  * @since 4.0.0
  */

package/src/encoding/Toml.ts

@@ -283,7 +283,7 @@ class TomlParser {
     if (multiline) {
       this.expect("\"")
       this.expect("\"")
-      if (this.peek() === "\n") this.advance()
+      this.advance(this.input.startsWith("\r\n", this.index) ? 2 : this.peek() === "\n" ? 1 : 0)
     }
     let output = ""
     while (!this.done) {
@@ -347,7 +347,7 @@ class TomlParser {
     if (multiline) {
       this.expect("'")
       this.expect("'")
-      if (this.peek() === "\n") this.advance()
+      this.advance(this.input.startsWith("\r\n", this.index) ? 2 : this.peek() === "\n" ? 1 : 0)
     }
     const start = this.index
     while (!this.done) {

package/src/encoding/Yaml.ts

@@ -523,6 +523,12 @@ class YamlParser {
     }
     this.index = end
 
+    let contentEnd = content.length
+    while (contentEnd > 0 && content[contentEnd - 1].length === 0) contentEnd--
+    const trailingBreaks = Math.max(0, content.length - contentEnd - (end === this.lines.length ? 1 : 0)) +
+      (contentEnd > 0 && start + contentEnd < this.lines.length ? 1 : 0)
+    content.length = contentEnd
+
     let output = ""
     if (style === "|") {
       output = content.join("\n")
@@ -543,11 +549,9 @@ class YamlParser {
           previousMoreIndented = moreIndented
         }
       }
-      output += "\n".repeat(blankLines)
     }
-    if (chomp === "keep") return output.endsWith("\n") ? output : `${output}\n`
-    output = output.replace(/\n+$/, "")
-    return chomp === "strip" ? output : `${output}\n`
+    if (chomp === "keep") return output + "\n".repeat(trailingBreaks)
+    return chomp === "clip" && contentEnd > 0 && trailingBreaks > 0 ? `${output}\n` : output
   }
 
   private skipBlankLines(): number {

package/src/encoding/index.ts

@@ -6,21 +6,25 @@
 // @barrel: Auto-generated exports. Do not edit manually.
 
 /**
+ * @stability stable
  * @since 4.0.0
  */
 export * as Base64 from "./Base64.ts"
 
 /**
+ * @stability stable
  * @since 4.0.0
  */
 export * as Base64Url from "./Base64Url.ts"
 
 /**
+ * @stability stable
  * @since 4.0.0
  */
 export * as EncodingError from "./EncodingError.ts"
 
 /**
+ * @stability stable
  * @since 4.0.0
  */
 export * as Hex from "./Hex.ts"

package/src/eventlog/SqlEventJournal.ts

@@ -56,7 +56,7 @@ export const make = (options?: {
       pg: () =>
         sql`
           CREATE TABLE IF NOT EXISTS ${entryTableSql} (
-            id UUID PRIMARY KEY,
+            id BYTEA PRIMARY KEY,
             event TEXT NOT NULL,
             primary_key TEXT NOT NULL,
             payload BYTEA NOT NULL,
@@ -95,8 +95,8 @@ export const make = (options?: {
       pg: () =>
         sql`
           CREATE TABLE IF NOT EXISTS ${remotesTableSql} (
-            remote_id UUID NOT NULL,
-            entry_id UUID NOT NULL,
+            remote_id BYTEA NOT NULL,
+            entry_id BYTEA NOT NULL,
             sequence INT NOT NULL,
             PRIMARY KEY (remote_id, entry_id)
           )`,
@@ -343,12 +343,26 @@ const SqlUint8Array = Schema.Union([Schema.Uint8Array, ArrayBuffer]).pipe(
 
 const SqlEntryId = SqlUint8Array.pipe(Schema.decodeTo(EventJournal.EntryId))
 
+const SqlNatural = Schema.Union([
+  Schema.Natural,
+  Schema.FiniteFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0)),
+  Schema.BigInt.pipe(
+    Schema.decodeTo(
+      Schema.Natural,
+      SchemaTransformation.transform({
+        decode: Number,
+        encode: BigInt
+      })
+    )
+  )
+])
+
 const EntryRow = Schema.Struct({
   id: SqlEntryId,
   event: Schema.String,
   primary_key: Schema.String,
   payload: SqlUint8Array,
-  timestamp: Schema.Int
+  timestamp: SqlNatural
 })
 
 const EntryRowArray = Schema.Array(EntryRow)