effect 4.0.0 → 4.0.2

package/src/ai/Telemetry.ts

@@ -27,50 +27,35 @@ import type * as Response from "./Response.ts"
  *
  * These attributes follow the OpenTelemetry generative AI semantic
  * conventions:
- * https://opentelemetry.io/docs/specs/semconv/attributes-registry/gen-ai/
+ * https://github.com/open-telemetry/semantic-conventions-genai
  *
  * @stability unstable
  * @category models
  * @since 4.0.0
  */
 export type GenAITelemetryAttributes = Struct.Simplify<
-  & AttributesWithPrefix<BaseAttributes, "gen_ai">
+  & AttributesWithPrefix<ProviderAttributes, "gen_ai.provider">
   & AttributesWithPrefix<OperationAttributes, "gen_ai.operation">
-  & AttributesWithPrefix<TokenAttributes, "gen_ai.token">
+  & AttributesWithPrefix<OutputAttributes, "gen_ai.output">
   & AttributesWithPrefix<UsageAttributes, "gen_ai.usage">
   & AttributesWithPrefix<RequestAttributes, "gen_ai.request">
   & AttributesWithPrefix<ResponseAttributes, "gen_ai.response">
 >
 
-/**
- * All telemetry attributes which are part of the GenAI specification.
- *
- * @stability unstable
- * @category models
- * @since 4.0.0
- */
-export type AllAttributes =
-  & BaseAttributes
-  & OperationAttributes
-  & TokenAttributes
-  & UsageAttributes
-  & RequestAttributes
-  & ResponseAttributes
-
 /**
  * Telemetry attributes which are part of the GenAI specification and are
- * namespaced by `gen_ai`.
+ * namespaced by `gen_ai.provider`.
  *
  * @stability unstable
  * @category models
- * @since 4.0.0
+ * @since 4.0.2
  */
-export interface BaseAttributes {
+export interface ProviderAttributes {
   /**
-   * The Generative AI product as identified by the client or server
-   * instrumentation.
+   * The Generative AI provider as identified by the client or server
+   * instrumentation, written as `gen_ai.provider.name`.
    */
-  readonly system?: (string & {}) | WellKnownSystem | null | undefined
+  readonly name?: (string & {}) | WellKnownProviderName | null | undefined
 }
 
 /**
@@ -87,14 +72,17 @@ export interface OperationAttributes {
 
 /**
  * Telemetry attributes which are part of the GenAI specification and are
- * namespaced by `gen_ai.token`.
+ * namespaced by `gen_ai.output`.
  *
  * @stability unstable
  * @category models
- * @since 4.0.0
+ * @since 4.0.2
  */
-export interface TokenAttributes {
-  readonly type?: string | null | undefined
+export interface OutputAttributes {
+  /**
+   * The output modality requested by the client.
+   */
+  readonly type?: (string & {}) | WellKnownOutputType | null | undefined
 }
 
 /**
@@ -128,15 +116,15 @@ export interface RequestAttributes {
    */
   readonly temperature?: number | null | undefined
   /**
-   * The temperature setting for the GenAI request.
+   * The top_k sampling setting for the GenAI request.
    */
   readonly topK?: number | null | undefined
   /**
-   * The top_k sampling setting for the GenAI request.
+   * The top_p sampling setting for the GenAI request.
    */
   readonly topP?: number | null | undefined
   /**
-   * The top_p sampling setting for the GenAI request.
+   * The maximum number of tokens the model may generate.
    */
   readonly maxTokens?: number | null | undefined
   /**
@@ -203,7 +191,18 @@ export interface ResponseAttributes {
 export type WellKnownOperationName = "chat" | "embeddings" | "text_completion"
 
 /**
- * The `gen_ai.system` attribute has the following list of well-known values.
+ * The `gen_ai.output.type` attribute has the following list of well-known
+ * values.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.2
+ */
+export type WellKnownOutputType = "text" | "json" | "image" | "speech"
+
+/**
+ * The `gen_ai.provider.name` attribute has the following list of well-known
+ * values.
  *
  * **Details**
  *
@@ -212,23 +211,25 @@ export type WellKnownOperationName = "chat" | "embeddings" | "text_completion"
  *
  * @stability unstable
  * @category models
- * @since 4.0.0
+ * @since 4.0.2
  */
-export type WellKnownSystem =
+export type WellKnownProviderName =
   | "anthropic"
   | "aws.bedrock"
-  | "az.ai.inference"
-  | "az.ai.openai"
+  | "azure.ai.inference"
+  | "azure.ai.openai"
   | "cohere"
   | "deepseek"
-  | "gemini"
+  | "gcp.gemini"
+  | "gcp.gen_ai"
+  | "gcp.vertex_ai"
   | "groq"
   | "ibm.watsonx.ai"
   | "mistral_ai"
+  | "moonshot_ai"
   | "openai"
   | "perplexity"
-  | "vertex_ai"
-  | "xai"
+  | "x_ai"
 
 /**
  * Utility type for prefixing attribute names with a namespace.
@@ -375,11 +376,11 @@ export const addSpanAttributes = (
   }
 }
 
-const addSpanBaseAttributes = addSpanAttributes("gen_ai", String.camelToSnake)<BaseAttributes>
+const addSpanProviderAttributes = addSpanAttributes("gen_ai.provider", String.camelToSnake)<ProviderAttributes>
 const addSpanOperationAttributes = addSpanAttributes("gen_ai.operation", String.camelToSnake)<OperationAttributes>
+const addSpanOutputAttributes = addSpanAttributes("gen_ai.output", String.camelToSnake)<OutputAttributes>
 const addSpanRequestAttributes = addSpanAttributes("gen_ai.request", String.camelToSnake)<RequestAttributes>
 const addSpanResponseAttributes = addSpanAttributes("gen_ai.response", String.camelToSnake)<ResponseAttributes>
-const addSpanTokenAttributes = addSpanAttributes("gen_ai.token", String.camelToSnake)<TokenAttributes>
 const addSpanUsageAttributes = addSpanAttributes("gen_ai.usage", String.camelToSnake)<UsageAttributes>
 
 /**
@@ -387,8 +388,7 @@ const addSpanUsageAttributes = addSpanAttributes("gen_ai.usage", String.camelToS
  *
  * **Details**
  *
- * Combines base attributes with optional grouped attributes for comprehensive
- * telemetry coverage of AI operations.
+ * Groups attributes by their `gen_ai.*` namespace.
  *
  * **Example** (Configuring GenAI telemetry attributes)
  *
@@ -396,7 +396,7 @@ const addSpanUsageAttributes = addSpanAttributes("gen_ai.usage", String.camelToS
  * import type { Telemetry } from "effect/ai"
  *
  * const telemetryOptions: Telemetry.GenAITelemetryAttributeOptions = {
- *   system: "openai",
+ *   provider: { name: "openai" },
  *   operation: {
  *     name: "chat"
  *   },
@@ -416,18 +416,26 @@ const addSpanUsageAttributes = addSpanAttributes("gen_ai.usage", String.camelToS
  *   }
  * }
  *
- * const result = [telemetryOptions.system, telemetryOptions.usage?.inputTokens] // => ["openai", 50]
+ * const result = [telemetryOptions.provider?.name, telemetryOptions.usage?.inputTokens] // => ["openai", 50]
  * ```
  *
  * @stability unstable
  * @category options
  * @since 4.0.0
  */
-export type GenAITelemetryAttributeOptions = BaseAttributes & {
+export type GenAITelemetryAttributeOptions = {
+  /**
+   * Provider attributes (e.g., provider name).
+   */
+  readonly provider?: ProviderAttributes | undefined
   /**
    * Operation-specific attributes (e.g., operation name).
    */
   readonly operation?: OperationAttributes | undefined
+  /**
+   * Output attributes (e.g., requested output type).
+   */
+  readonly output?: OutputAttributes | undefined
   /**
    * Request-specific attributes (e.g., model parameters).
    */
@@ -436,10 +444,6 @@ export type GenAITelemetryAttributeOptions = BaseAttributes & {
    * Response-specific attributes (e.g., response metadata).
    */
   readonly response?: ResponseAttributes | undefined
-  /**
-   * Token-specific attributes.
-   */
-  readonly token?: TokenAttributes | undefined
   /**
    * Usage statistics attributes (e.g., token counts).
    */
@@ -451,7 +455,7 @@ export type GenAITelemetryAttributeOptions = BaseAttributes & {
  *
  * **When to use**
  *
- * Use when you need to write GenAI request, response, token, or usage
+ * Use when you need to write GenAI request, response, or usage
  * attributes onto an existing OpenTelemetry span.
  *
  * **Details**
@@ -473,7 +477,7 @@ export type GenAITelemetryAttributeOptions = BaseAttributes & {
  *   const span = yield* Effect.currentSpan
  *
  *   Telemetry.addGenAIAnnotations(span, {
- *     system: "openai",
+ *     provider: { name: "openai" },
  *     request: { model: "gpt-4", temperature: 0.7 },
  *     usage: { inputTokens: 100, outputTokens: 50 }
  *   })
@@ -493,7 +497,7 @@ export const addGenAIAnnotations: {
    *
    * **When to use**
    *
-   * Use when you need to write GenAI request, response, token, or usage
+   * Use when you need to write GenAI request, response, or usage
    * attributes onto an existing OpenTelemetry span.
    *
    * **Details**
@@ -515,7 +519,7 @@ export const addGenAIAnnotations: {
    *   const span = yield* Effect.currentSpan
    *
    *   Telemetry.addGenAIAnnotations(span, {
-   *     system: "openai",
+   *     provider: { name: "openai" },
    *     request: { model: "gpt-4", temperature: 0.7 },
    *     usage: { inputTokens: 100, outputTokens: 50 }
    *   })
@@ -535,7 +539,7 @@ export const addGenAIAnnotations: {
    *
    * **When to use**
    *
-   * Use when you need to write GenAI request, response, token, or usage
+   * Use when you need to write GenAI request, response, or usage
    * attributes onto an existing OpenTelemetry span.
    *
    * **Details**
@@ -557,7 +561,7 @@ export const addGenAIAnnotations: {
    *   const span = yield* Effect.currentSpan
    *
    *   Telemetry.addGenAIAnnotations(span, {
-   *     system: "openai",
+   *     provider: { name: "openai" },
    *     request: { model: "gpt-4", temperature: 0.7 },
    *     usage: { inputTokens: 100, outputTokens: 50 }
    *   })
@@ -573,11 +577,11 @@ export const addGenAIAnnotations: {
    */
   (span: Span, options: GenAITelemetryAttributeOptions): void
 } = dual(2, (span: Span, options: GenAITelemetryAttributeOptions) => {
-  addSpanBaseAttributes(span, { system: options.system })
+  if (Predicate.isNotNullish(options.provider)) addSpanProviderAttributes(span, options.provider)
   if (Predicate.isNotNullish(options.operation)) addSpanOperationAttributes(span, options.operation)
+  if (Predicate.isNotNullish(options.output)) addSpanOutputAttributes(span, options.output)
   if (Predicate.isNotNullish(options.request)) addSpanRequestAttributes(span, options.request)
   if (Predicate.isNotNullish(options.response)) addSpanResponseAttributes(span, options.response)
-  if (Predicate.isNotNullish(options.token)) addSpanTokenAttributes(span, options.token)
   if (Predicate.isNotNullish(options.usage)) addSpanUsageAttributes(span, options.usage)
 })
 

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/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/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({

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/ClusterWorkflowEngine.ts

@@ -411,7 +411,7 @@ export const make = Effect.gen(function*() {
             // Replays reuse the request id but track a fresh set of awaits.
             let currentRun: {
               readonly request: Entity.Request<any>
-              readonly awaitedDeferreds: ReadonlySet<string>
+              readonly instance: WorkflowEngine.WorkflowInstance["Service"]
             } | undefined
             // Concurrent wakes share one wait for the current run to publish its reply.
             const resumeGate = Semaphore.makeUnsafe(1)
@@ -428,7 +428,7 @@ export const make = Effect.gen(function*() {
             return {
               run: (request: Entity.Request<any>) => {
                 const instance = WorkflowEngine.WorkflowInstance.initial(workflow, executionId)
-                currentRun = { request, awaitedDeferreds: instance.awaitedDeferreds }
+                currentRun = { request, instance }
                 const parent = (request.payload as any)[payloadParentKey] as
                   | { workflowName: string; executionId: string }
                   | undefined
@@ -522,9 +522,13 @@ export const make = Effect.gen(function*() {
                 // registered yet, a later await will see the result just stored.
                 // Check when the wake runs and skip preemption too: interrupting
                 // a later await would require waiting for its reply before reset.
+                // A run completing its own deferred also reads it from the cache
+                // when it awaits later, so that completion never wakes the run.
                 const wake = Effect.suspend(() =>
-                  currentRun && !currentRun.awaitedDeferreds.has(payload.name)
-                    ? ensureSuccess(resume(workflow, executionId))
+                  currentRun && !currentRun.instance.awaitedDeferreds.has(payload.name)
+                    ? currentRun.instance.completedDeferreds.has(payload.name)
+                      ? Effect.void
+                      : ensureSuccess(resume(workflow, executionId))
                     : deferredState.deferredDone(executionId, payload.name).pipe(Effect.andThen(resumeCurrentRun))
                 )
                 // An asynchronous reply releases the RPC concurrency permit while
@@ -703,6 +707,16 @@ export const make = Effect.gen(function*() {
 
     deferredDone: Effect.fnUntraced(
       function*({ deferredName, executionId, exit, workflowName }) {
+        const instance = yield* Effect.serviceOption(WorkflowEngine.WorkflowInstance)
+        // Activities run with their own instance, so their completions still
+        // wake a run that suspended before reaching the await. An interrupt
+        // must wake the run even when it signals itself.
+        if (
+          Option.isSome(instance) && instance.value.executionId === executionId &&
+          deferredName !== InterruptSignal.name
+        ) {
+          instance.value.completedDeferreds.add(deferredName)
+        }
         const workflow = workflows.get(workflowName)
         if (workflow) {
           return yield* Effect.orDie(sendDiscard({

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)