agents 0.20.0 → 0.20.1

package/dist/{agent-tool-types-Btk9ETS-.d.ts → agent-tool-types-BC-WFlsz.d.ts}

@@ -100,6 +100,33 @@ import {
 } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
 
+//#region src/observability/tracing/tracer.d.ts
+type InvocationScopeOptions = {
+  /**
+   * Open a scope even inside a live one, for work deliberately detached from
+   * the handler that started it — `ctx.waitUntil` bodies, queue drains — which
+   * runs on past that handler and must not be cut off with it.
+   */
+  readonly detached?: boolean;
+};
+/**
+ * Runs `body` as one traced invocation.
+ *
+ * Work that escapes its native invocation cannot be traced from the context it
+ * started in: the still-open span is force-closed against the invocation that
+ * owned that context, which reports a negative duration or `span_not_ended`.
+ * Spans opened with {@link SpanLifetime.boundToInvocation} inside this scope
+ * are therefore closed before `body` settles — but not one moment earlier, so
+ * everything that completes during the invocation (the normal case: a chat
+ * turn is awaited by the handler that received it) still records its finish
+ * attributes. A span truncated this way is marked
+ * `cloudflare.agents.span.truncated` rather than passing as complete.
+ */
+declare function withInvocationScope<T>(
+  body: () => T,
+  options?: InvocationScopeOptions
+): T;
+//#endregion
 //#region src/sub-routing.d.ts
 /**
  * URL segment marking a parent↔child boundary.
@@ -281,19 +308,6 @@ declare class WorkerTransport extends WebStandardStreamableHTTPServerTransport$1
   private _capturedInitializeParams?;
   private _userOnSessionInitialized?;
   private _bridgeInstalled;
-  /**
-   * Tracks keepalive interval cleanups so we can fire them eagerly when the
-   * SDK closes the underlying SSE stream via `closeSSEStream(requestId)` or
-   * `closeStandaloneSSEStream()`. Keyed by the JSON-RPC request id that
-   * triggered the stream, or the sentinel for the standalone GET stream.
-   */
-  private readonly _keepaliveCleanups;
-  /**
-   * Most recent JSON-RPC request id seen on an incoming POST. Used to key
-   * keepalive cleanups when the response is an SSE stream tied to that
-   * request (so `closeSSEStream(id)` can find and clear the interval).
-   */
-  private _pendingRequestId?;
   /**
    * Request ids whose SSE stream was deliberately torn down via
    * `closeSSEStream`. The SDK's `send()` throws "No connection established"
@@ -314,8 +328,7 @@ declare class WorkerTransport extends WebStandardStreamableHTTPServerTransport$1
   /**
    * Top-level request entry point. Handles CORS preflight, restores any
    * persisted state on first invocation, then delegates to the SDK transport
-   * and finally appends CORS headers + keepalive to whatever response comes
-   * back.
+   * and finally appends CORS headers to whatever response comes back.
    */
   handleRequest(
     request: Request,
@@ -331,7 +344,6 @@ declare class WorkerTransport extends WebStandardStreamableHTTPServerTransport$1
    */
   private normalizeAllowHeader;
   closeSSEStream(requestId: RequestId): void;
-  closeStandaloneSSEStream(): void;
   close(): Promise<void>;
   /**
    * Swallow two classes of message that would otherwise surface as
@@ -356,34 +368,6 @@ declare class WorkerTransport extends WebStandardStreamableHTTPServerTransport$1
     message: JSONRPCMessage$1,
     options?: TransportSendOptions$1
   ): Promise<void>;
-  /**
-   * If the response is an SSE stream, tee the body through a TransformStream
-   * that injects a `: keepalive\n\n` comment frame every 25s. The interval
-   * is cleared when the wrapped stream closes — which happens both when the
-   * SDK ends the underlying stream naturally and when `closeSSEStream` is
-   * called.
-   *
-   * Keepalive policy:
-   *   - POST response streams (`key` is a request id): always keepalive.
-   *     In-progress tool calls have no recovery path — if the stream drops
-   *     mid-execution the result is lost — so we keep it under the
-   *     Cloudflare edge ~5min idle watchdog.
-   *   - Standalone GET stream (`key === "_standalone"`): keepalive only
-   *     when no `eventStore` is configured. When resumability is enabled,
-   *     clients reconnect with `Last-Event-ID` after an idle drop, so we
-   *     skip the keepalive and let the DO hibernate.
-   *
-   * Uses the shared `sse-keepalive` constants so both this wrapper and
-   * `McpAgent.serve()` write identical frames at the same cadence.
-   * See cloudflare/agents#1583.
-   */
-  private withKeepalive;
-  /**
-   * Does the SDK transport have an `eventStore`? Reaches into the SDK's
-   * private field because the option isn't surfaced on the public API —
-   * we only need a yes/no for keepalive policy.
-   */
-  private eventStoreConfigured;
   private getCorsHeaders;
   private withCorsHeaders;
   private installOnSessionInitializedBridge;
@@ -6109,6 +6093,7 @@ export {
   createLegacyMcpHandler as en,
   Schedule as et,
   AgentToolProgress as f,
+  withInvocationScope as fn,
   getAgentByName as ft,
   AgentToolRunPart as g,
   unstable_callable as gt,
@@ -6159,4 +6144,4 @@ export {
   EmailRoutingOptions as z,
   RPCClientTransportOptions as zt
 };
-//# sourceMappingURL=agent-tool-types-Btk9ETS-.d.ts.map
+//# sourceMappingURL=agent-tool-types-BC-WFlsz.d.ts.map

package/dist/agent-tool-types.d.ts

@@ -24,7 +24,7 @@ import {
   w as RunAgentToolOptions,
   x as ChatCapableAgentClass,
   y as AgentToolStoredChunk
-} from "./agent-tool-types-Btk9ETS-.js";
+} from "./agent-tool-types-BC-WFlsz.js";
 export {
   AGENT_TOOL_MILESTONE_PART,
   AGENT_TOOL_PROGRESS_PART,

package/dist/{agent-tools-UuScsJg3.d.ts → agent-tools-DeHe9Xov.d.ts}

@@ -4,7 +4,7 @@ import {
   o as AgentToolEventMessage,
   s as AgentToolEventState,
   y as AgentToolStoredChunk
-} from "./agent-tool-types-Btk9ETS-.js";
+} from "./agent-tool-types-BC-WFlsz.js";
 
 //#region src/chat/agent-tools.d.ts
 type AgentToolProgressEmitResult = "emitted" | "coalesced" | "inactive";
@@ -130,4 +130,4 @@ export {
   interceptAgentToolBroadcast as s,
   AgentToolBroadcastHooks as t
 };
-//# sourceMappingURL=agent-tools-UuScsJg3.d.ts.map
+//# sourceMappingURL=agent-tools-DeHe9Xov.d.ts.map

package/dist/agent-tools.d.ts

@@ -19,7 +19,7 @@ import {
   w as RunAgentToolOptions,
   x as ChatCapableAgentClass,
   y as AgentToolStoredChunk
-} from "./agent-tool-types-Btk9ETS-.js";
+} from "./agent-tool-types-BC-WFlsz.js";
 import { Tool } from "ai";
 
 //#region src/agent-tools.d.ts

package/dist/chat/index.d.ts

@@ -4,7 +4,7 @@ import {
   a as AgentToolEvent,
   o as AgentToolEventMessage,
   s as AgentToolEventState
-} from "../agent-tool-types-Btk9ETS-.js";
+} from "../agent-tool-types-BC-WFlsz.js";
 import {
   n as ClientToolSchema,
   r as createToolsFromClientSchemas,
@@ -18,7 +18,7 @@ import {
   r as AgentToolProgressEmitResult,
   s as interceptAgentToolBroadcast,
   t as AgentToolBroadcastHooks
-} from "../agent-tools-UuScsJg3.js";
+} from "../agent-tools-DeHe9Xov.js";
 import { JSONSchema7, UIMessage } from "ai";
 import { Connection } from "agents";
 

package/dist/chat-sdk/index.d.ts

@@ -2,7 +2,7 @@ import {
   O as Agent,
   ct as SubAgentClass,
   lt as SubAgentStub
-} from "../agent-tool-types-Btk9ETS-.js";
+} from "../agent-tool-types-BC-WFlsz.js";
 import { Lock, QueueEntry, StateAdapter } from "chat";
 
 //#region src/chat-sdk/agent.d.ts

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { O as Agent } from "./agent-tool-types-Btk9ETS-.js";
+import { O as Agent } from "./agent-tool-types-BC-WFlsz.js";
 import {
   ClientParameters,
   Method,

package/dist/cloudflare-BduZwmYK.js

@@ -0,0 +1,204 @@
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as cloudflareWorkers from "cloudflare:workers";
+//#region src/observability/tracing/tracer.ts
+/**
+* Spans that asked to be invocation-bounded while a scope was active. Closed
+* when that scope ends; see {@link withInvocationScope}.
+*/
+const invocationScope = new AsyncLocalStorage();
+/**
+* Runs `body` as one traced invocation.
+*
+* Work that escapes its native invocation cannot be traced from the context it
+* started in: the still-open span is force-closed against the invocation that
+* owned that context, which reports a negative duration or `span_not_ended`.
+* Spans opened with {@link SpanLifetime.boundToInvocation} inside this scope
+* are therefore closed before `body` settles — but not one moment earlier, so
+* everything that completes during the invocation (the normal case: a chat
+* turn is awaited by the handler that received it) still records its finish
+* attributes. A span truncated this way is marked
+* `cloudflare.agents.span.truncated` rather than passing as complete.
+*/
+function withInvocationScope(body, options) {
+	const current = invocationScope.getStore();
+	if (options?.detached !== true && current !== void 0 && !current.ended) return body();
+	const scope = {
+		ended: false,
+		open: /* @__PURE__ */ new Set()
+	};
+	const endInvocation = () => {
+		scope.ended = true;
+		for (const span of scope.open) try {
+			span.truncate();
+		} catch {}
+		scope.open.clear();
+	};
+	return invocationScope.run(scope, () => {
+		let result;
+		try {
+			result = body();
+		} catch (cause) {
+			endInvocation();
+			throw cause;
+		}
+		if (isPromiseLike(result)) return Promise.resolve(result).finally(endInvocation);
+		endInvocation();
+		return result;
+	});
+}
+/** Creates a tracer from a runtime span capability. */
+function createTracer(runtime) {
+	return new RuntimeTracer(runtime);
+}
+var RuntimeTracer = class {
+	constructor(runtime) {
+		this.runtime = runtime;
+	}
+	withSpan(name, attributes, run, lifetime) {
+		return this.activate(name, attributes, (span) => {
+			const outOfBand = lifetime?.boundToInvocation === true && bindToInvocation(span);
+			const result = run(span);
+			if (isPromiseLike(result)) {
+				if (outOfBand) span.truncate();
+				return Promise.resolve(result).catch((cause) => {
+					span.fail(cause);
+					throw cause;
+				}).finally(() => {
+					span.close();
+				});
+			}
+			if (outOfBand) span.truncate();
+			span.close();
+			return result;
+		});
+	}
+	openSpan(name, attributes, activate, lifetime) {
+		if (!lifetime?.boundToInvocation) return this.activate(name, attributes, activate);
+		return this.activate(name, attributes, (span) => {
+			const invocationEnded = bindToInvocation(span);
+			try {
+				return activate(span);
+			} finally {
+				if (invocationEnded) span.truncate();
+			}
+		});
+	}
+	/**
+	* Shared scaffold: opens an active span, seeds its attributes, and fails the
+	* span on a thrown defect before rethrowing. The `body` decides the span's
+	* finishing policy (managed vs. caller-owned).
+	*/
+	activate(name, attributes, body) {
+		return this.runtime.startActiveSpan(name, (writer) => {
+			setAttributes(writer, attributes);
+			const span = new ManagedSpan(writer);
+			try {
+				return body(span);
+			} catch (cause) {
+				span.fail(cause);
+				throw cause;
+			}
+		});
+	}
+};
+var _closed = /* @__PURE__ */ new WeakMap();
+var ManagedSpan = class {
+	constructor(span) {
+		this.span = span;
+		_classPrivateFieldInitSpec(this, _closed, false);
+	}
+	get isTraced() {
+		return this.span.isTraced;
+	}
+	/** INTERNAL: see {@link writeSpanAttributes}. */
+	writeAttributes(attributes) {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		setAttributes(this.span, attributes);
+	}
+	finish(attributes = {}) {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		setAttributes(this.span, attributes);
+		this.close();
+	}
+	fail(cause) {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		if (isCancellation(cause)) setAttributes(this.span, { "cloudflare.agents.canceled": true });
+		else setAttributes(this.span, { "error.type": cause instanceof Error ? cause.name || "Error" : typeof cause });
+		this.close();
+	}
+	close() {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		_classPrivateFieldSet2(_closed, this, true);
+		this.span.end();
+	}
+	/**
+	* Closes a span whose work has not finished because its invocation is ending.
+	* The marker distinguishes "this span has no tokens because the turn escaped
+	* its invocation" from "this span completed and reported none".
+	*/
+	truncate() {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		setAttributes(this.span, { "cloudflare.agents.span.truncated": true });
+		this.close();
+	}
+};
+/**
+* Registers a span for closure at the end of the current invocation, and
+* reports whether that invocation has already ended.
+*
+* Outside any scope the span keeps its natural lifetime: with no known
+* invocation boundary there is nothing to bound it to, and closing early would
+* discard finish attributes for no gain. Inside a scope that has already
+* ended — work resumed later while still carrying this context — the span
+* cannot outlive an invocation that is already gone, so the caller truncates
+* it as soon as it has written what it knows.
+*/
+function bindToInvocation(span) {
+	const scope = invocationScope.getStore();
+	if (scope === void 0) return false;
+	if (scope.ended) return true;
+	scope.open.add(span);
+	return false;
+}
+/**
+* INTERNAL: writes attributes onto an open managed span. Lets instrumentation
+* defer expensive attribute computation until after the isTraced check (span
+* names must exist at open time; attributes need not). Not part of the public
+* barrel surface.
+*/
+function writeSpanAttributes(span, attributes) {
+	if (span instanceof ManagedSpan) span.writeAttributes(attributes);
+}
+function setAttributes(span, attributes) {
+	if (!span.isTraced) return;
+	try {
+		for (const [key, value] of Object.entries(attributes)) if (value !== void 0) span.setAttribute(key, value);
+	} catch {}
+}
+function isPromiseLike(value) {
+	return value !== null && value !== void 0 && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+/**
+* Recognizes caller/runtime cancellation (an `AbortError`, e.g. from an aborted
+* `AbortSignal`) so it can be classified separately from genuine failures. A
+* `DOMException` named `AbortError` is not always an `Error` instance, so this
+* probes the `name` field structurally rather than via `instanceof`.
+*/
+function isCancellation(cause) {
+	return typeof cause === "object" && cause !== null && "name" in cause && cause.name === "AbortError";
+}
+//#endregion
+//#region src/observability/tracing/cloudflare.ts
+const noopSpan = {
+	isTraced: false,
+	setAttribute() {},
+	end() {}
+};
+const tracer = createTracer(cloudflareWorkers.tracing ?? { startActiveSpan(_name, run) {
+	return run(noopSpan);
+} });
+//#endregion
+export { withInvocationScope as n, writeSpanAttributes as r, tracer as t };
+
+//# sourceMappingURL=cloudflare-BduZwmYK.js.map

package/dist/cloudflare-BduZwmYK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-BduZwmYK.js","names":[],"sources":["../src/observability/tracing/tracer.ts","../src/observability/tracing/cloudflare.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"node:async_hooks\";\n\n/** Attribute values accepted by custom spans. */\nexport type TraceAttributeValue = string | number | boolean | undefined;\n\n/** Initial or finish attributes attached to a span. */\nexport type TraceAttributes = Readonly<Record<string, TraceAttributeValue>>;\n\n/** A value that may complete synchronously or through a promise-like result. */\nexport type MaybePromise<T> = T | PromiseLike<T>;\n\n/** Minimal runtime span surface used by tracers. */\nexport type SpanWriter = {\n  readonly isTraced: boolean;\n  setAttribute(key: string, value: TraceAttributeValue): void;\n  end(): void;\n};\n\n/** Runtime capability for starting an active span in the current async context. */\nexport type SpanRuntime = {\n  startActiveSpan<T>(name: string, run: (span: SpanWriter) => T): T;\n};\n\n/** Optional automatic lifetime policy for invocation-bounded spans. */\nexport type SpanLifetime = {\n  /**\n   * Close the span no later than the end of the surrounding\n   * {@link withInvocationScope}, so it cannot outlive the native invocation\n   * that owns its tracing context. Ignored outside such a scope.\n   */\n  readonly boundToInvocation?: boolean;\n};\n\n/** AgentTracer seam used by integrations. */\nexport type AgentTracer = {\n  /**\n   * Runs `run` inside an active span whose lifetime the tracer owns: the span\n   * finishes when `run` returns (or its promise resolves) and fails when `run`\n   * throws or rejects. Callers do not call {@link AgentSpan.finish}/{@link AgentSpan.fail};\n   * doing so early is safe but the tracer guarantees closure.\n   *\n   * @template T The value produced by the instrumented work.\n   */\n  withSpan<T>(\n    name: string,\n    attributes: TraceAttributes,\n    run: (span: AgentSpan) => MaybePromise<T>,\n    lifetime?: SpanLifetime\n  ): T | Promise<T>;\n  /**\n   * Activates a span and returns whatever `activate` returns (typically the\n   * {@link AgentSpan} handle itself). The caller owns the span lifetime and MUST call\n   * {@link AgentSpan.finish} or {@link AgentSpan.fail}; an unfinished span leaks. Use this\n   * for work that outlives the callback, such as streams and event-driven\n   * telemetry. A throw from `activate` still fails the span before rethrowing.\n   *\n   * @template T The value returned to the caller, usually the span handle.\n   */\n  openSpan<T>(\n    name: string,\n    attributes: TraceAttributes,\n    activate: (span: AgentSpan) => T,\n    lifetime?: SpanLifetime\n  ): T;\n};\n\n/** Active span handle passed to instrumented work. */\nexport type AgentSpan = {\n  /**\n   * Whether this invocation is actually being traced. Instrumentation can use\n   * this to skip expensive capture work when nobody is listening.\n   */\n  readonly isTraced: boolean;\n  /** Records the optional finish attributes and ends the span. Idempotent. */\n  finish(attributes?: TraceAttributes): void;\n  /**\n   * Ends the span as not-successful. Genuine failures record `error.type`;\n   * recognized cancellations (an `AbortError`) record `canceled` instead so aborts\n   * are not counted as errors. The cause message is never recorded. Idempotent.\n   */\n  fail(cause: unknown): void;\n};\n\ntype InvocationScope = {\n  /** Bounded spans still open. Emptied when the invocation ends. */\n  readonly open: Set<ManagedSpan>;\n  /** Whether the invocation this scope represents has already ended. */\n  ended: boolean;\n};\n\nexport type InvocationScopeOptions = {\n  /**\n   * Open a scope even inside a live one, for work deliberately detached from\n   * the handler that started it — `ctx.waitUntil` bodies, queue drains — which\n   * runs on past that handler and must not be cut off with it.\n   */\n  readonly detached?: boolean;\n};\n\n/**\n * Spans that asked to be invocation-bounded while a scope was active. Closed\n * when that scope ends; see {@link withInvocationScope}.\n */\nconst invocationScope = new AsyncLocalStorage<InvocationScope>();\n\n/**\n * Runs `body` as one traced invocation.\n *\n * Work that escapes its native invocation cannot be traced from the context it\n * started in: the still-open span is force-closed against the invocation that\n * owned that context, which reports a negative duration or `span_not_ended`.\n * Spans opened with {@link SpanLifetime.boundToInvocation} inside this scope\n * are therefore closed before `body` settles — but not one moment earlier, so\n * everything that completes during the invocation (the normal case: a chat\n * turn is awaited by the handler that received it) still records its finish\n * attributes. A span truncated this way is marked\n * `cloudflare.agents.span.truncated` rather than passing as complete.\n */\nexport function withInvocationScope<T>(\n  body: () => T,\n  options?: InvocationScopeOptions\n): T {\n  // Nested scopes would truncate spans at an inner boundary that is not an\n  // invocation edge, so the outermost live scope owns the lifetime. A scope\n  // that has already ended is not an enclosing invocation at all — it is a\n  // leftover context on work that resumed later — so `body` starts a new one.\n  const current = invocationScope.getStore();\n  if (options?.detached !== true && current !== undefined && !current.ended) {\n    return body();\n  }\n\n  const scope: InvocationScope = { ended: false, open: new Set() };\n  const endInvocation = () => {\n    scope.ended = true;\n    for (const span of scope.open) {\n      // Fail open: this runs on the return path of every agent handler, so a\n      // span writer that throws must not take the handler's result with it,\n      // nor stop the remaining spans from closing.\n      try {\n        span.truncate();\n      } catch {\n        // Nothing useful to do with a broken span writer.\n      }\n    }\n    scope.open.clear();\n  };\n\n  return invocationScope.run(scope, () => {\n    let result: T;\n    try {\n      result = body();\n    } catch (cause: unknown) {\n      endInvocation();\n      throw cause;\n    }\n\n    if (isPromiseLike(result)) {\n      // SAFETY: T is promise-like here, so the settled promise is still a T.\n      return Promise.resolve(result).finally(endInvocation) as T;\n    }\n\n    endInvocation();\n    return result;\n  });\n}\n\n/** Creates a tracer from a runtime span capability. */\nexport function createTracer(runtime: SpanRuntime): AgentTracer {\n  return new RuntimeTracer(runtime);\n}\n\nclass RuntimeTracer implements AgentTracer {\n  constructor(private readonly runtime: SpanRuntime) {}\n\n  withSpan<T>(\n    name: string,\n    attributes: TraceAttributes,\n    run: (span: AgentSpan) => MaybePromise<T>,\n    lifetime?: SpanLifetime\n  ): T | Promise<T> {\n    return this.activate(name, attributes, (span) => {\n      // Ask before running: a span that opens and closes in one tick still\n      // needs to know whether that tick happened after its invocation ended.\n      const outOfBand =\n        lifetime?.boundToInvocation === true && bindToInvocation(span);\n      const result = run(span);\n      if (isPromiseLike(result)) {\n        if (outOfBand) {\n          span.truncate();\n        }\n        return Promise.resolve(result)\n          .catch((cause: unknown) => {\n            span.fail(cause);\n            throw cause;\n          })\n          .finally(() => {\n            span.close();\n          });\n      }\n\n      if (outOfBand) {\n        span.truncate();\n      }\n      span.close();\n      return result;\n    });\n  }\n\n  openSpan<T>(\n    name: string,\n    attributes: TraceAttributes,\n    activate: (span: AgentSpan) => T,\n    lifetime?: SpanLifetime\n  ): T {\n    if (!lifetime?.boundToInvocation) {\n      return this.activate(name, attributes, activate);\n    }\n\n    return this.activate(name, attributes, (span) => {\n      const invocationEnded = bindToInvocation(span);\n      try {\n        return activate(span);\n      } finally {\n        // Truncate only once `activate` has had its turn: callers that open\n        // with an empty attribute set and write the real one lazily (the AI\n        // operation span does, to stay cheap for untraced calls) would\n        // otherwise be closed before writing anything at all.\n        if (invocationEnded) {\n          span.truncate();\n        }\n      }\n    });\n  }\n\n  /**\n   * Shared scaffold: opens an active span, seeds its attributes, and fails the\n   * span on a thrown defect before rethrowing. The `body` decides the span's\n   * finishing policy (managed vs. caller-owned).\n   */\n  private activate<T>(\n    name: string,\n    attributes: TraceAttributes,\n    body: (span: ManagedSpan) => T\n  ): T {\n    return this.runtime.startActiveSpan(name, (writer) => {\n      setAttributes(writer, attributes);\n      const span = new ManagedSpan(writer);\n\n      try {\n        return body(span);\n      } catch (cause: unknown) {\n        span.fail(cause);\n        throw cause;\n      }\n    });\n  }\n}\n\nclass ManagedSpan implements AgentSpan {\n  #closed = false;\n\n  constructor(private readonly span: SpanWriter) {}\n\n  get isTraced(): boolean {\n    return this.span.isTraced;\n  }\n\n  /** INTERNAL: see {@link writeSpanAttributes}. */\n  writeAttributes(attributes: TraceAttributes): void {\n    if (this.#closed) {\n      return;\n    }\n\n    setAttributes(this.span, attributes);\n  }\n\n  finish(attributes: TraceAttributes = {}): void {\n    if (this.#closed) {\n      return;\n    }\n\n    setAttributes(this.span, attributes);\n    this.close();\n  }\n\n  fail(cause: unknown): void {\n    if (this.#closed) {\n      return;\n    }\n\n    if (isCancellation(cause)) {\n      // Cancellation is a control path, not a failure: OTel semconv leaves\n      // status Unset and records no error.type for cancellations, so aborted\n      // operations do not inflate error rates. The vendor marker is additive.\n      setAttributes(this.span, { \"cloudflare.agents.canceled\": true });\n    } else {\n      // Workers' custom Span API does not currently expose setStatus(). Do not\n      // invent an `otel.status_code` attribute: status is span state in OTel,\n      // not an attribute. error.type remains the standard queryable marker.\n      setAttributes(this.span, {\n        \"error.type\":\n          cause instanceof Error ? cause.name || \"Error\" : typeof cause\n      });\n    }\n\n    this.close();\n  }\n\n  close(): void {\n    if (this.#closed) {\n      return;\n    }\n\n    this.#closed = true;\n    this.span.end();\n  }\n\n  /**\n   * Closes a span whose work has not finished because its invocation is ending.\n   * The marker distinguishes \"this span has no tokens because the turn escaped\n   * its invocation\" from \"this span completed and reported none\".\n   */\n  truncate(): void {\n    if (this.#closed) {\n      return;\n    }\n\n    setAttributes(this.span, { \"cloudflare.agents.span.truncated\": true });\n    this.close();\n  }\n}\n\n/**\n * Registers a span for closure at the end of the current invocation, and\n * reports whether that invocation has already ended.\n *\n * Outside any scope the span keeps its natural lifetime: with no known\n * invocation boundary there is nothing to bound it to, and closing early would\n * discard finish attributes for no gain. Inside a scope that has already\n * ended — work resumed later while still carrying this context — the span\n * cannot outlive an invocation that is already gone, so the caller truncates\n * it as soon as it has written what it knows.\n */\nfunction bindToInvocation(span: ManagedSpan): boolean {\n  const scope = invocationScope.getStore();\n  if (scope === undefined) {\n    return false;\n  }\n\n  if (scope.ended) {\n    return true;\n  }\n\n  scope.open.add(span);\n  return false;\n}\n\n/**\n * INTERNAL: writes attributes onto an open managed span. Lets instrumentation\n * defer expensive attribute computation until after the isTraced check (span\n * names must exist at open time; attributes need not). Not part of the public\n * barrel surface.\n */\nexport function writeSpanAttributes(\n  span: AgentSpan,\n  attributes: TraceAttributes\n): void {\n  if (span instanceof ManagedSpan) {\n    span.writeAttributes(attributes);\n  }\n}\n\nfunction setAttributes(span: SpanWriter, attributes: TraceAttributes): void {\n  if (!span.isTraced) {\n    return;\n  }\n\n  // Fail-safe: a throwing writer must not leak the span or replace the\n  // application's original error with a telemetry one.\n  try {\n    for (const [key, value] of Object.entries(attributes)) {\n      if (value !== undefined) {\n        span.setAttribute(key, value);\n      }\n    }\n  } catch {\n    // Drop the attributes; the span still closes.\n  }\n}\n\nfunction isPromiseLike<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return (\n    value !== null &&\n    value !== undefined &&\n    (typeof value === \"object\" || typeof value === \"function\") &&\n    \"then\" in value &&\n    typeof value.then === \"function\"\n  );\n}\n\n/**\n * Recognizes caller/runtime cancellation (an `AbortError`, e.g. from an aborted\n * `AbortSignal`) so it can be classified separately from genuine failures. A\n * `DOMException` named `AbortError` is not always an `Error` instance, so this\n * probes the `name` field structurally rather than via `instanceof`.\n */\nfunction isCancellation(cause: unknown): boolean {\n  return (\n    typeof cause === \"object\" &&\n    cause !== null &&\n    \"name\" in cause &&\n    cause.name === \"AbortError\"\n  );\n}\n","import * as cloudflareWorkers from \"cloudflare:workers\";\nimport { createTracer } from \"./tracer\";\nimport type { SpanRuntime, SpanWriter, AgentTracer } from \"./tracer\";\n\nconst noopSpan: SpanWriter = {\n  isTraced: false,\n  setAttribute() {},\n  end() {}\n};\n\nconst noopRuntime: SpanRuntime = {\n  startActiveSpan(_name, run) {\n    return run(noopSpan);\n  }\n};\n\n// Accessed via the namespace so runtimes that predate the `tracing` export\n// degrade to a no-op tracer instead of failing at module-link time — this\n// module loads with the main `agents` entry, not just for tracing users.\nconst runtime: SpanRuntime =\n  (cloudflareWorkers as { tracing?: SpanRuntime }).tracing ?? noopRuntime;\n\nexport const tracer: AgentTracer = createTracer(runtime);\n"],"mappings":"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"}

package/dist/{handler-stateless-8hQN_kC3.js → handler-stateless-CIkKPETH.js}

@@ -1,37 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { WebStandardStreamableHTTPServerTransport, createMcpHandler, hostHeaderValidationResponse, isJSONRPCRequest, isLegacyRequest, localhostAllowedHostnames, localhostAllowedOrigins, originValidationResponse } from "@modelcontextprotocol/server";
-//#region src/mcp/sse-keepalive.ts
-/**
-* Shared SSE keepalive utility for MCP transports.
-*
-* Cloudflare's edge closes idle SSE responses after ~5 minutes. Writers
-* that may sit silent for that long (long-running tool calls, idle
-* standalone GET streams) arm a keepalive to keep the response under the
-* watchdog.
-*
-* See cloudflare/agents#1583.
-*/
-/** Interval between SSE keepalive comment frames, in ms.
-*
-* The WHATWG SSE spec recommends a comment line every "15 seconds or so"
-* (html.spec.whatwg.org §9.2.7). 25s gives comfortable headroom below
-* both the ~30s post-handler background-work cancellation window on
-* Workers and the ~5min Cloudflare edge idle-stream watchdog.
-*/
-const KEEPALIVE_INTERVAL_MS = 25e3;
-/** SSE comment frame the parser drops before any event dispatch. */
-const KEEPALIVE_FRAME = ": keepalive\n\n";
-/**
-* Start an SSE keepalive on `writer`. Returns a `clearInterval` handle
-* that the stream cleanup must invoke when the stream closes.
-*/
-function startKeepalive(writer, encoder) {
-	const handle = setInterval(() => {
-		writer.write(encoder.encode(KEEPALIVE_FRAME)).catch(() => clearInterval(handle));
-	}, KEEPALIVE_INTERVAL_MS);
-	return handle;
-}
-//#endregion
 //#region src/mcp/auth-context.ts
 const VERIFIED_OAUTH_CONTEXT = Symbol.for("cloudflare.workers-oauth-provider.verified-context.v1");
 const authContextStorage = new AsyncLocalStorage();
@@ -109,13 +77,14 @@ function reportHandlerError(onerror, error) {
 * Local deltas from the upstream stateless fallback:
 *
 * - impossible stateless server-to-client requests fail immediately rather
-*   than leaving the tool handler waiting for a session response;
-* - streamed POST responses receive Cloudflare's 25-second SSE keepalive.
+*   than leaving the tool handler waiting for a session response.
 *
-* Remove this adapter once the SDK exposes both policies directly.
+* Streaming and keepalive behavior remain delegated to the SDK transport.
+* Remove this adapter once the SDK exposes the reverse-request policy directly.
 */
-function createLegacyCompatibilityRequestHandler(factory, onerror) {
-	const fetch = async (request, options) => {
+function createLegacyCompatibilityRequestHandler(factory, handlerOptions = {}) {
+	const { keepAliveMs, onerror } = handlerOptions;
+	const fetch = async (request, requestOptions) => {
 		if (request.method.toUpperCase() !== "POST") return Response.json({
 			jsonrpc: "2.0",
 			error: {
@@ -127,20 +96,21 @@ function createLegacyCompatibilityRequestHandler(factory, onerror) {
 		if (request.signal.aborted) return new Response(null, { status: 499 });
 		let product;
 		let transport;
-		let clearResponseKeepalive = () => {};
 		let teardownPromise;
 		const teardown = () => teardownPromise ??= (async () => {
-			clearResponseKeepalive();
 			await Promise.all([transport?.close().catch(() => {}), product?.close().catch(() => {})]);
 		})();
 		const onAbort = () => void teardown();
 		try {
 			product = await factory({
 				era: "legacy",
-				...options?.authInfo !== void 0 && { authInfo: options.authInfo },
+				...requestOptions?.authInfo !== void 0 && { authInfo: requestOptions.authInfo },
 				requestInfo: request
 			});
-			transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+			transport = new WebStandardStreamableHTTPServerTransport({
+				keepAliveMs,
+				sessionIdGenerator: void 0
+			});
 			const send = transport.send.bind(transport);
 			transport.send = async (message, sendOptions) => {
 				if (isJSONRPCRequest(message)) {
@@ -163,8 +133,8 @@ function createLegacyCompatibilityRequestHandler(factory, onerror) {
 			}
 			request.signal.addEventListener("abort", onAbort, { once: true });
 			const response = await transport.handleRequest(request, {
-				...options?.authInfo !== void 0 && { authInfo: options.authInfo },
-				...options?.parsedBody !== void 0 && { parsedBody: options.parsedBody }
+				...requestOptions?.authInfo !== void 0 && { authInfo: requestOptions.authInfo },
+				...requestOptions?.parsedBody !== void 0 && { parsedBody: requestOptions.parsedBody }
 			});
 			if (response.body === null || !response.headers.get("content-type")?.includes("text/event-stream")) {
 				request.signal.removeEventListener("abort", onAbort);
@@ -172,44 +142,22 @@ function createLegacyCompatibilityRequestHandler(factory, onerror) {
 				return response;
 			}
 			const reader = response.body.getReader();
-			const encoder = new TextEncoder();
-			let keepalive;
-			const clearKeepalive = () => {
-				if (keepalive !== void 0) {
-					clearInterval(keepalive);
-					keepalive = void 0;
-				}
-			};
-			clearResponseKeepalive = clearKeepalive;
 			const body = new ReadableStream({
-				start(controller) {
-					if (teardownPromise) return;
-					keepalive = setInterval(() => {
-						try {
-							controller.enqueue(encoder.encode(KEEPALIVE_FRAME));
-						} catch {
-							clearKeepalive();
-						}
-					}, KEEPALIVE_INTERVAL_MS);
-				},
 				async pull(controller) {
 					try {
 						const { done, value } = await reader.read();
 						if (done) {
-							clearKeepalive();
 							request.signal.removeEventListener("abort", onAbort);
 							await teardown();
 							controller.close();
 						} else if (value !== void 0) controller.enqueue(value);
 					} catch (error) {
-						clearKeepalive();
 						request.signal.removeEventListener("abort", onAbort);
 						await teardown();
 						controller.error(error);
 					}
 				},
 				async cancel(reason) {
-					clearKeepalive();
 					request.signal.removeEventListener("abort", onAbort);
 					await reader.cancel(reason).catch(() => {});
 					await teardown();
@@ -224,7 +172,7 @@ function createLegacyCompatibilityRequestHandler(factory, onerror) {
 			request.signal.removeEventListener("abort", onAbort);
 			await teardown();
 			reportHandlerError(onerror, error);
-			return internalErrorResponse(requestIdFromParsedBody(options?.parsedBody));
+			return internalErrorResponse(requestIdFromParsedBody(requestOptions?.parsedBody));
 		}
 	};
 	return { fetch };
@@ -309,7 +257,10 @@ function createStatelessMcpHandler(factory, options = {}) {
 		...sdkOptions,
 		legacy: "reject"
 	});
-	const legacyCompatibilityHandler = legacy === "stateless" ? createLegacyCompatibilityRequestHandler(factory, sdkOptions.onerror) : void 0;
+	const legacyCompatibilityHandler = legacy === "stateless" ? createLegacyCompatibilityRequestHandler(factory, {
+		keepAliveMs: sdkOptions.keepAliveMs,
+		onerror: sdkOptions.onerror
+	}) : void 0;
 	const serve = async (request, requestOptions, workerCtx) => {
 		const requestUrl = new URL(request.url);
 		if (requestUrl.pathname !== route) return withCors(new Response("Not Found", { status: 404 }), corsOptions);
@@ -362,6 +313,6 @@ function createStatelessMcpHandler(factory, options = {}) {
 	});
 }
 //#endregion
-export { KEEPALIVE_INTERVAL_MS as a, KEEPALIVE_FRAME as i, getMcpAuthContext as n, startKeepalive as o, runWithAuthContext as r, createStatelessMcpHandler as t };
+export { getMcpAuthContext as n, runWithAuthContext as r, createStatelessMcpHandler as t };
 
-//# sourceMappingURL=handler-stateless-8hQN_kC3.js.map
+//# sourceMappingURL=handler-stateless-CIkKPETH.js.map