agents 0.20.0 → 0.20.1

package/dist/mcp/server.js

@@ -1,2 +1,2 @@
-import { n as getMcpAuthContext, t as createStatelessMcpHandler } from "../handler-stateless-8hQN_kC3.js";
+import { n as getMcpAuthContext, t as createStatelessMcpHandler } from "../handler-stateless-CIkKPETH.js";
 export { createStatelessMcpHandler as createMcpHandler, getMcpAuthContext };

package/dist/observability/ai/index.d.ts

@@ -6,7 +6,15 @@ type AISDKStorageOptions = {
 };
 /** Instrumentation options for the AI SDK v6 adapter. */
 type AISDKInstrumentationOptions = AISDKStorageOptions & {
-  /** AI SDK v6 `experimental_context` keys to emit as scalar attributes. */ readonly includeRuntimeContext?: readonly string[];
+  /**
+   * Context keys to emit as `cloudflare.agents.runtime_context.{key}`, set
+   * once for the wrapper rather than per call.
+   *
+   * Distinct from the AI SDK's own per-call `telemetry.includeRuntimeContext`,
+   * which shares the name but selects keys that map onto the canonical
+   * `cloudflare.agents.turn.*` / `cloudflare.agents.metadata.*` attributes.
+   */
+  readonly includeRuntimeContext?: readonly string[];
 };
 //#endregion
 //#region src/observability/ai/v7/types.d.ts

package/dist/observability/ai/index.js

@@ -1,4 +1,5 @@
-import { n as writeSpanAttributes, t as tracer } from "../../cloudflare-BldFV0Pa.js";
+import { __DO_NOT_USE_WILL_BREAK__agentContext } from "../../internal_context.js";
+import { r as writeSpanAttributes, t as tracer } from "../../cloudflare-BduZwmYK.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/observability/ai/read.ts
 /** Narrows an unknown value to a string. */
@@ -42,6 +43,7 @@ const TraceAttribute = {
 		MetadataPrefix: "cloudflare.agents.metadata.",
 		OperationName: "cloudflare.agents.operation.name",
 		ResponseFinishReason: "cloudflare.agents.response.finish_reason",
+		RuntimeContextPrefix: "cloudflare.agents.runtime_context.",
 		ToolApprovalState: "cloudflare.agents.tool.approval.state",
 		ToolCount: "cloudflare.agents.tool.count",
 		TurnAdmission: "cloudflare.agents.turn.admission",
@@ -159,19 +161,24 @@ const CONSUMED_METADATA_KEYS = /* @__PURE__ */ new Set([
 	"gen_ai.conversation.id"
 ]);
 /**
-* Projects the AI SDK's per-call `experimental_telemetry.metadata` onto root
-* span attributes: reserved keys map to their dedicated attributes, any other
-* SCALAR entry passes through as `cloudflare.agents.metadata.{key}`, and
-* object/array values are dropped (scalar-only attribute rule).
+* Projects a per-call telemetry record onto root span attributes: reserved
+* keys map to their dedicated attributes, any other SCALAR entry passes
+* through under `passthroughPrefix`, and object/array values are dropped
+* (scalar-only attribute rule).
+*
+* v6 passes `experimental_telemetry.metadata` and keeps the default prefix;
+* v7 has no metadata option and passes the included subset of `runtimeContext`
+* under its own prefix. Reserved keys land on the same attribute either way,
+* so turn identity does not move namespace between SDK majors.
 */
-function metadataAttributes(metadata) {
+function metadataAttributes(metadata, passthroughPrefix = TraceAttribute.Cloudflare.MetadataPrefix) {
 	if (metadata === void 0) return {};
 	const attributes = {};
 	for (const [key, value] of Object.entries(metadata)) {
 		if (CONSUMED_METADATA_KEYS.has(key)) continue;
 		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") continue;
 		const reserved = Object.hasOwn(RESERVED_METADATA_ATTRIBUTES, key) ? RESERVED_METADATA_ATTRIBUTES[key] : void 0;
-		attributes[reserved ?? `${TraceAttribute.Cloudflare.MetadataPrefix}${key}`] = value;
+		attributes[reserved ?? `${passthroughPrefix}${key}`] = value;
 	}
 	return attributes;
 }
@@ -804,8 +811,9 @@ function finishWhenStreamCompletes(result, span, options = {}) {
 		onComplete: (summary) => {
 			span.finish(finishAttributesFromStreamSummary(summary, options.includeResponse === true, options.includeAIGatewayLog === true, options.aiGatewayLogId, options.storeMessages === true));
 		},
-		onError: (cause, observedAIGatewayLogId) => {
+		onError: (cause, observedAIGatewayLogId, observed) => {
 			if (options.includeAIGatewayLog) writeSpanAttributes(span, aiGatewayLogAttributes(observedAIGatewayLogId ?? extractAIGatewayLogId(cause) ?? options.aiGatewayLogId));
+			if (observed !== void 0) writeSpanAttributes(span, finishAttributesFromStreamSummary(observed, options.includeResponse === true, options.includeAIGatewayLog === true, options.aiGatewayLogId, options.storeMessages === true));
 			span.fail(cause);
 		}
 	}, options.startedAtMs, options.includeAIGatewayLog ? options.aiGatewayLogId : void 0, options.storeMessages === true);
@@ -836,10 +844,10 @@ function patchStreamFields(result, hooks, startedAtMs, aiGatewayLogId, storeMess
 		closed = true;
 		hooks.onComplete(summary);
 	};
-	const errorOnce = (cause, observedAIGatewayLogId) => {
+	const errorOnce = (cause, observedAIGatewayLogId, observed) => {
 		if (closed) return;
 		closed = true;
-		hooks.onError(cause, observedAIGatewayLogId);
+		hooks.onError(cause, observedAIGatewayLogId, observed);
 	};
 	try {
 		if (isReadableStream(record.baseStream)) {
@@ -977,13 +985,23 @@ function createStreamState(hooks, startedAtMs, initialAIGatewayLogId, storeMessa
 	let observedAbort = false;
 	let firstChunkAtMs;
 	const output = createStreamMessages();
+	/** What the stream reported before it stopped, complete or not. */
+	const observedSummary = () => streamSummaryFromParts({
+		aiGatewayLogId,
+		finishReason,
+		outputMessages: storeMessages ? output.messages(finishReason) : void 0,
+		response,
+		timeToFirstChunkSeconds: firstChunkAtMs === void 0 || startedAtMs === void 0 ? void 0 : (firstChunkAtMs - startedAtMs) / 1e3,
+		toolCallCount,
+		usage
+	});
 	const settleObserved = () => {
 		if (observedError) {
-			hooks.onError(observedError.cause, aiGatewayLogId);
+			hooks.onError(observedError.cause, aiGatewayLogId, observedSummary());
 			return true;
 		}
 		if (observedAbort) {
-			hooks.onError({ name: "AbortError" }, aiGatewayLogId);
+			hooks.onError({ name: "AbortError" }, aiGatewayLogId, observedSummary());
 			return true;
 		}
 		return false;
@@ -1070,7 +1088,7 @@ function isAsyncIterable$1(value) {
 }
 //#endregion
 //#region src/observability/ai/v6/model.ts
-function wrapModel(tracer, wrapLanguageModel, model, parentOperation, storeMessages) {
+function wrapModel(tracer, wrapLanguageModel, model, parentOperation, storeMessages, boundToInvocation = false) {
 	if (!wrapLanguageModel) return model;
 	if (typeof model !== "object" || model === null) return model;
 	const modelInfo = extractModelInfo(model);
@@ -1096,7 +1114,7 @@ function wrapModel(tracer, wrapLanguageModel, model, parentOperation, storeMessa
 						recordAIGatewayLogOnError(modelCall, cause, aiGatewayLog.get());
 						throw cause;
 					}
-				});
+				}, boundToInvocation ? { boundToInvocation: true } : void 0);
 			},
 			wrapStream: async ({ doStream, params }) => {
 				const span = modelCallSpanForModel("doStream", modelInfo, params, parentOperation, storeMessages);
@@ -1117,7 +1135,7 @@ function wrapModel(tracer, wrapLanguageModel, model, parentOperation, storeMessa
 						modelCall.fail(cause);
 						throw cause;
 					}
-				});
+				}, boundToInvocation ? { boundToInvocation: true } : void 0);
 			}
 		}
 	});
@@ -1144,21 +1162,21 @@ function modelCallSpanForModel(operation, model, params, parentOperation, storeM
 }
 //#endregion
 //#region src/observability/ai/v6/tools.ts
-function wrapTools(tracer, tools, storeTools) {
+function wrapTools(tracer, tools, storeTools, boundToInvocation = false, approvedToolCalls) {
 	if (typeof tools !== "object" || tools === null) return tools;
 	const toolRecord = tools;
 	const wrappedTools = {};
-	for (const [toolName, tool] of Object.entries(toolRecord)) wrappedTools[toolName] = wrapTool(tracer, toolName, tool, storeTools);
+	for (const [toolName, tool] of Object.entries(toolRecord)) wrappedTools[toolName] = wrapTool(tracer, toolName, tool, storeTools, boundToInvocation, approvedToolCalls);
 	return wrappedTools;
 }
-function wrapTool(tracer, toolName, tool, storeTools) {
+function wrapTool(tracer, toolName, tool, storeTools, boundToInvocation, approvedToolCalls) {
 	if (typeof tool !== "object" || tool === null) return tool;
 	const toolRecord = tool;
 	const hasExecute = typeof toolRecord.execute === "function";
 	const hasApproval = typeof toolRecord.needsApproval === "boolean" || typeof toolRecord.needsApproval === "function";
 	if (!hasExecute && !hasApproval) return tool;
 	const wrappedTool = Object.assign(Object.create(Object.getPrototypeOf(tool)), tool);
-	if (hasApproval) wrapApprovalCheck(tracer, wrappedTool, toolRecord, tool, toolName);
+	if (hasApproval) wrapApprovalCheck(tracer, wrappedTool, toolRecord, tool, toolName, boundToInvocation);
 	if (!hasExecute) return wrappedTool;
 	const execute = toolRecord.execute;
 	if (typeof execute !== "function") return wrappedTool;
@@ -1176,36 +1194,58 @@ function wrapTool(tracer, toolName, tool, storeTools) {
 		};
 		return tracer.openSpan(span.name, attributes, (toolSpan) => {
 			const inSpanContext = AsyncLocalStorage.snapshot();
-			const approval = approvalResponseForOptions(args[1], extractToolCallId(args[1]));
-			if (approval?.approved === true) recordApprovalChild(tracer, toolName, approval.toolCallId, "approved");
+			const toolCallId = extractToolCallId(args[1]);
+			if (approvalResponseForOptions(args[1], toolCallId)?.approved === true || toolCallId !== void 0 && approvedToolCalls?.get(toolCallId) === toolName) {
+				recordApprovalChild(tracer, toolName, toolCallId, "approved", boundToInvocation);
+				if (toolCallId !== void 0) approvedToolCalls?.delete(toolCallId);
+			}
 			const result = originalExecute(...args);
 			if (isPromiseLike(result)) return Promise.resolve(result).then((resolved) => settleToolResult(resolved, toolSpan, inSpanContext, storeTools), (cause) => {
 				toolSpan.fail(cause);
 				throw cause;
 			});
 			return settleToolResult(result, toolSpan, inSpanContext, storeTools);
-		});
+		}, boundToInvocation ? { boundToInvocation: true } : void 0);
 	};
 	return wrappedTool;
 }
-function wrapApprovalCheck(tracer, wrappedTool, toolRecord, tool, toolName) {
+function wrapApprovalCheck(tracer, wrappedTool, toolRecord, tool, toolName, boundToInvocation) {
 	const approval = toolRecord.needsApproval;
 	const original = typeof approval === "function" ? approval.bind(tool) : void 0;
 	wrappedTool.needsApproval = (...args) => {
 		const result = original ? original(...args) : approval;
 		const recordRequested = (needed) => {
 			const toolCallId = extractToolCallId(args[1]);
-			if (needed === true && !hasApprovalResponse(args[1], toolCallId)) recordApprovalSegment(tracer, toolName, toolCallId, "requested");
+			if (needed === true && !hasApprovalResponse(args[1], toolCallId)) recordApprovalSegment(tracer, toolName, toolCallId, "requested", boundToInvocation);
 			return needed;
 		};
 		return isPromiseLike(result) ? Promise.resolve(result).then(recordRequested) : recordRequested(result);
 	};
 }
+/** Instruments AI SDK v7's top-level tool approval policy. */
+function wrapToolApprovalPolicy(tracer, policy, approvedToolCalls, boundToInvocation = false) {
+	if (typeof policy === "function") return (...args) => {
+		const toolCall = recordValue$1(recordValue$1(args[0])?.toolCall);
+		return observePolicyResult(policy(...args), readString(toolCall?.toolName) ?? "tool", readString(toolCall?.toolCallId), tracer, approvedToolCalls, boundToInvocation);
+	};
+	if (typeof policy !== "object" || policy === null) return policy;
+	return Object.fromEntries(Object.entries(policy).map(([toolName, setting]) => [toolName, (...args) => observePolicyResult(typeof setting === "function" ? setting(...args) : setting, toolName, extractToolCallId(args[1]), tracer, approvedToolCalls, boundToInvocation)]));
+}
+function observePolicyResult(result, toolName, toolCallId, tracer, approvedToolCalls, boundToInvocation = false) {
+	const observe = (status) => {
+		if (toolCallId === void 0) return status;
+		const type = typeof status === "string" ? status : readString(recordValue$1(status)?.type);
+		if (type === "approved") approvedToolCalls.set(toolCallId, toolName);
+		else if (type === "user-approval" || type === "denied") recordApprovalSegment(tracer, toolName, toolCallId, type === "denied" ? "denied" : "requested", boundToInvocation);
+		return status;
+	};
+	return isPromiseLike(result) ? Promise.resolve(result).then(observe) : observe(result);
+}
 /** Records denied responses, whose tool never reaches execute(). */
 function recordDeniedApprovalResponses(tracer, messages) {
 	for (const response of approvalResponses(messages)) if (!response.approved) recordApprovalSegment(tracer, response.toolName, response.toolCallId, "denied");
 }
-function recordApprovalSegment(tracer, toolName, toolCallId, state) {
+function recordApprovalSegment(tracer, toolName, toolCallId, state, boundToInvocation = false) {
 	const tool = toolCallSpan({
 		integration: "ai-sdk",
 		operation: "tool.approval",
@@ -1213,16 +1253,16 @@ function recordApprovalSegment(tracer, toolName, toolCallId, state) {
 		toolName
 	});
 	tracer.withSpan(tool.name, tool.attributes, () => {
-		recordApprovalChild(tracer, toolName, toolCallId, state);
-	});
+		recordApprovalChild(tracer, toolName, toolCallId, state, boundToInvocation);
+	}, boundToInvocation ? { boundToInvocation: true } : void 0);
 }
-function recordApprovalChild(tracer, toolName, toolCallId, state) {
+function recordApprovalChild(tracer, toolName, toolCallId, state, boundToInvocation = false) {
 	const approval = toolApprovalSpan({
 		state,
 		toolCallId,
 		toolName
 	});
-	tracer.withSpan(approval.name, approval.attributes, () => void 0);
+	tracer.withSpan(approval.name, approval.attributes, () => void 0, boundToInvocation ? { boundToInvocation: true } : void 0);
 }
 function hasApprovalResponse(options, toolCallId) {
 	return approvalResponseForOptions(options, toolCallId) !== void 0;
@@ -1321,6 +1361,9 @@ function extractToolCallId(options) {
 function isAsyncIterable(value) {
 	return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
+function recordValue$1(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
 function isPromiseLike(value) {
 	return value !== null && value !== void 0 && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
 }
@@ -1372,6 +1415,7 @@ function createOperationWrapper(operationName, operation, wrapLanguageModel, ins
 		storeTools: instrumentation.options?.storeTools === true
 	};
 	if (isStreamOperation$1(operationName)) return (params, ...args) => {
+		const boundToInvocation = isAISDKInvocationBounded(params);
 		return instrumentation.tracer.openSpan(operationSpanName(agentNameForCall(params)), {}, (operationSpan) => {
 			if (!operationSpan.isTraced) {
 				operationSpan.finish();
@@ -1380,40 +1424,45 @@ function createOperationWrapper(operationName, operation, wrapLanguageModel, ins
 			writeSpanAttributes(operationSpan, operationSpanForCall(operationName, extractModelInfo(params.model), params, instrumentation.options).attributes);
 			recordDeniedApprovalResponses(instrumentation.tracer, params.messages);
 			const startedAtMs = Date.now();
-			const result = operation(operationParamsForCall(params, operationName, wrapLanguageModel, instrumentation.tracer, storage), ...args);
+			const result = operation(operationParamsForCall(params, operationName, wrapLanguageModel, instrumentation.tracer, storage, boundToInvocation), ...args);
 			const hasModelSpan = canWrapModel(wrapLanguageModel, params.model);
 			return finishWhenStreamCompletes(result, operationSpan, {
 				includeResponse: !hasModelSpan,
 				startedAtMs: hasModelSpan ? void 0 : startedAtMs
 			});
-		});
+		}, boundToInvocation ? { boundToInvocation: true } : void 0);
 	};
 	return async (params, ...args) => {
+		const boundToInvocation = isAISDKInvocationBounded(params);
 		return instrumentation.tracer.withSpan(operationSpanName(agentNameForCall(params)), {}, async (operationSpan) => {
 			if (!operationSpan.isTraced) return operation(params, ...args);
 			writeSpanAttributes(operationSpan, operationSpanForCall(operationName, extractModelInfo(params.model), params, instrumentation.options).attributes);
 			recordDeniedApprovalResponses(instrumentation.tracer, params.messages);
-			const result = await operation(operationParamsForCall(params, operationName, wrapLanguageModel, instrumentation.tracer, storage), ...args);
+			const result = await operation(operationParamsForCall(params, operationName, wrapLanguageModel, instrumentation.tracer, storage, boundToInvocation), ...args);
 			operationSpan.finish(finishAttributesFromResult(result, { includeResponse: !canWrapModel(wrapLanguageModel, params.model) }));
 			return result;
-		});
+		}, boundToInvocation ? { boundToInvocation: true } : void 0);
 	};
 }
 /**
-* Reads only the agent name (metadata.agentName / gen_ai.agent.name /
-* functionId) for the span name. `functionId` is the AI SDK's canonical
-* projection to `gen_ai.agent.name`; an explicit metadata name takes priority.
+* Reads only the agent name for the span name, from the same sources and in
+* the same order as {@link semanticContext}, so the span name and
+* `gen_ai.agent.name` never disagree. `functionId` is the AI SDK's canonical
+* projection; an explicit name from v6 metadata or v7 runtime context wins.
 */
 function agentNameForCall(params) {
-	const telemetry = typeof params.experimental_telemetry === "object" && params.experimental_telemetry !== null ? params.experimental_telemetry : void 0;
-	const metadata = typeof telemetry?.metadata === "object" && telemetry.metadata !== null ? telemetry.metadata : void 0;
-	return readString(metadata?.agentName ?? metadata?.["gen_ai.agent.name"]) ?? readString(telemetry?.functionId);
+	const telemetry = telemetryOptions(params);
+	const metadata = telemetryMetadata(params);
+	const runtimeContext = runtimeContextRecord(params);
+	return metadataValue$1(metadata, "agentName", "gen_ai.agent.name") ?? metadataValue$1(runtimeContext, "agentName", "gen_ai.agent.name") ?? readString(telemetry?.functionId);
 }
-function operationParamsForCall(params, operationName, wrapLanguageModel, tracer, storage) {
+function operationParamsForCall(params, operationName, wrapLanguageModel, tracer, storage, boundToInvocation = false) {
+	const approvedToolCalls = /* @__PURE__ */ new Map();
 	return {
 		...params,
-		...shouldWrapTools(operationName) && params.tools !== void 0 ? { tools: wrapTools(tracer, params.tools, storage.storeTools) } : {},
-		...params.model !== void 0 ? { model: wrapModel(tracer, wrapLanguageModel, params.model, operationName, storage.storeMessages) } : {}
+		...shouldWrapTools(operationName) && params.tools !== void 0 ? { tools: wrapTools(tracer, params.tools, storage.storeTools, boundToInvocation, approvedToolCalls) } : {},
+		...params.toolApproval !== void 0 ? { toolApproval: wrapToolApprovalPolicy(tracer, params.toolApproval, approvedToolCalls) } : {},
+		...params.model !== void 0 ? { model: wrapModel(tracer, wrapLanguageModel, params.model, operationName, storage.storeMessages, boundToInvocation) } : {}
 	};
 }
 function canWrapModel(wrapLanguageModel, model) {
@@ -1431,6 +1480,7 @@ function isWrappedOperationName(value) {
 function operationSpanForCall(operation, model, params, options) {
 	return operationSpan({
 		attributes: {
+			...metadataAttributes(includedRuntimeContext(params), TraceAttribute.Cloudflare.RuntimeContextPrefix),
 			...metadataAttributes(telemetryMetadata(params)),
 			...contextAttributes(params, options)
 		},
@@ -1444,39 +1494,114 @@ function operationSpanForCall(operation, model, params, options) {
 }
 /** Reads the per-call `experimental_telemetry.metadata` record, if present. */
 function telemetryMetadata(params) {
-	const telemetry = typeof params.experimental_telemetry === "object" && params.experimental_telemetry !== null ? params.experimental_telemetry : void 0;
+	const telemetry = telemetryOptions(params);
 	return typeof telemetry?.metadata === "object" && telemetry.metadata !== null ? telemetry.metadata : void 0;
 }
 /**
-* Reads agent/conversation semantic context from the AI SDK's own
-* `experimental_telemetry` fields. The AI SDK maps `functionId` to
-* `gen_ai.agent.name`; explicit `metadata.agentName` / `gen_ai.agent.name`
-* takes priority. Other semantic fields come only from metadata.
+* The caller's application-data channel: `runtimeContext` on v7, the
+* `experimental_context` it replaced on v6. Read through one accessor so the
+* two majors cannot drift on which one identity and metadata come from.
+*/
+function runtimeContextRecord(params) {
+	const value = params.runtimeContext ?? params.experimental_context;
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function telemetryOptions(params) {
+	const telemetryValue = params.telemetry ?? params.experimental_telemetry;
+	return typeof telemetryValue === "object" && telemetryValue !== null ? telemetryValue : void 0;
+}
+/**
+* The v7 stand-in for `experimental_telemetry.metadata`.
+*
+* v7 dropped `metadata` from its telemetry options; callers put the same
+* values in `runtimeContext` and mark the telemetry-visible ones through the
+* SDK's own `telemetry.includeRuntimeContext`. Running the included subset
+* through {@link metadataAttributes} is what keeps reserved keys — Think's
+* `cloudflare.agents.turn.*` above all — on the attribute names v6 emits, so
+* a query written against v6 traces still matches v7 ones. Everything else
+* passes through as documented, under `cloudflare.agents.runtime_context.*`.
+*
+* Runtime context the caller did not mark as included stays off the span as a
+* passthrough attribute: on v7 this is a general application-data channel, not
+* a telemetry bag. Identity (`agentId`, `agentName`, `agentVersion`,
+* `conversationId`) is separate — {@link semanticContext} reads it regardless,
+* because it names the operation rather than describing it, and v7 left
+* callers nowhere else to put it.
+*/
+function includedRuntimeContext(params) {
+	const runtimeContext = runtimeContextRecord(params);
+	if (runtimeContext === void 0) return;
+	const included = includedContextKeys(telemetryOptions(params));
+	if (included === void 0) return;
+	const projected = {};
+	for (const key of included) if (Object.hasOwn(runtimeContext, key)) projected[key] = runtimeContext[key];
+	return projected;
+}
+/**
+* The keys a caller marked as telemetry-visible.
+*
+* The SDK's own shape is `{ [key]: boolean }`, included only when explicitly
+* true; a plain array of key names is accepted too, since that is the shape of
+* the wrapper's option of the same name and silently ignoring it would be
+* worse than honouring it. There is deliberately no "include everything"
+* shorthand — runtime context routinely carries credentials and user data that
+* no one asked to put on a span.
+*/
+function includedContextKeys(telemetry) {
+	const included = telemetry?.includeRuntimeContext;
+	if (Array.isArray(included)) return included.filter((key) => typeof key === "string");
+	if (typeof included !== "object" || included === null) return;
+	return Object.entries(included).filter(([, enabled]) => enabled === true).map(([key]) => key);
+}
+/**
+* Whether the caller explicitly opted a key OUT. Identity is read from runtime
+* context without an opt-in — on v7 there is nowhere else to put it, and
+* requiring one would silently cost every caller `gen_ai.agent.id` — but an
+* explicit `false` is a stated intention and is honoured.
+*/
+function isExcludedFromContext(params, key) {
+	const included = telemetryOptions(params)?.includeRuntimeContext;
+	return typeof included === "object" && included !== null && !Array.isArray(included) && included[key] === false;
+}
+/**
+* Reads agent/conversation semantic context from the AI SDK's own telemetry
+* fields. The AI SDK maps `functionId` to `gen_ai.agent.name`; an explicit
+* name takes priority. Each field comes from v6 `telemetry.metadata` or, on
+* v7 where that option no longer exists, from `runtimeContext`.
 */
 function semanticContext(params) {
-	const telemetry = typeof params.experimental_telemetry === "object" && params.experimental_telemetry !== null ? params.experimental_telemetry : void 0;
-	const metadata = typeof telemetry?.metadata === "object" && telemetry.metadata !== null ? telemetry.metadata : void 0;
+	const telemetry = telemetryOptions(params);
+	const metadata = telemetryMetadata(params);
+	const runtimeContext = runtimeContextRecord(params);
+	const fromContext = (key, semanticKey) => isExcludedFromContext(params, key) ? void 0 : metadataValue$1(runtimeContext, key, semanticKey);
 	return {
-		agentId: metadataValue$1(metadata, "agentId", "gen_ai.agent.id"),
-		agentName: metadataValue$1(metadata, "agentName", "gen_ai.agent.name") ?? readString(telemetry?.functionId),
-		agentVersion: metadataValue$1(metadata, "agentVersion", "gen_ai.agent.version"),
-		conversationId: metadataValue$1(metadata, "conversationId", "gen_ai.conversation.id")
+		agentId: metadataValue$1(metadata, "agentId", "gen_ai.agent.id") ?? fromContext("agentId", "gen_ai.agent.id"),
+		agentName: metadataValue$1(metadata, "agentName", "gen_ai.agent.name") ?? fromContext("agentName", "gen_ai.agent.name") ?? readString(telemetry?.functionId),
+		agentVersion: metadataValue$1(metadata, "agentVersion", "gen_ai.agent.version") ?? fromContext("agentVersion", "gen_ai.agent.version"),
+		conversationId: metadataValue$1(metadata, "conversationId", "gen_ai.conversation.id") ?? fromContext("conversationId", "gen_ai.conversation.id")
 	};
 }
 function metadataValue$1(metadata, key, semanticKey) {
 	return readString(metadata?.[key] ?? metadata?.[semanticKey]);
 }
+/**
+* The wrapper-level allowlist, set once for the instrumentation rather than
+* per call. It selects from the same context and lands on the same attributes
+* as the SDK's per-call allowlist: selecting a key through both must produce
+* one attribute, not a canonical one and a `runtime_context.*` near-duplicate.
+*/
 function contextAttributes(params, options) {
-	const attributes = {};
-	const runtimeContext = typeof params.experimental_context === "object" && params.experimental_context !== null ? params.experimental_context : void 0;
-	for (const key of options?.includeRuntimeContext ?? []) {
-		const value = runtimeContext?.[key];
-		if (isScalarAttributeValue$1(value)) attributes[`cloudflare.agents.runtime_context.${key}`] = value;
-	}
-	return Object.keys(attributes).length > 0 ? attributes : void 0;
-}
-function isScalarAttributeValue$1(value) {
-	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+	const included = options?.includeRuntimeContext;
+	if (included === void 0 || included.length === 0) return;
+	const runtimeContext = runtimeContextRecord(params);
+	if (runtimeContext === void 0) return;
+	const projected = {};
+	for (const key of included) if (Object.hasOwn(runtimeContext, key)) projected[key] = runtimeContext[key];
+	return metadataAttributes(projected, TraceAttribute.Cloudflare.RuntimeContextPrefix);
+}
+const invocationBounded = Symbol.for("cloudflare.agents.ai-sdk.invocation-bounded");
+function isAISDKInvocationBounded(params) {
+	return params[invocationBounded] === true || __DO_NOT_USE_WILL_BREAK__agentContext.getStore()?.connection !== void 0;
 }
 //#endregion
 //#region src/observability/ai/v7/extract.ts