@apifuse/provider-sdk 2.2.0-beta.62 → 2.2.0-beta.63

package/src/runtime/ocr-telemetry.ts

@@ -0,0 +1,308 @@
+import type { OcrContext } from "../types.js";
+import {
+	add,
+	capabilityErrorText,
+	capabilityFacts,
+	capabilityMetadata,
+	capabilityText,
+	inputBytes,
+	integer,
+	observeCapability,
+	registerCapabilityInput,
+} from "./capability-telemetry.js";
+import {
+	type ClosedEnum,
+	closedEnum,
+	type SpanIndex,
+	type TelemetryContributor,
+} from "./request-telemetry.js";
+export type OcrTelemetryBackend =
+	| "cloudflare-workers-ai"
+	| "openai-compatible"
+	| "custom"
+	| "unavailable";
+export type OcrTelemetryEngine = "workers-ai" | "openai-compatible" | "custom";
+export type OcrTelemetryErrorCode =
+	| "OCR_UNAVAILABLE"
+	| "UNSUPPORTED_OCR_BACKEND"
+	| "OCR_UPSTREAM_FAILED"
+	| "OCR_INCOMPLETE_RESPONSE"
+	| "transport_network_error"
+	| "transport_timeout"
+	| "other";
+export type OcrTelemetryModel =
+	| "gemma-4-26b-a4b-it"
+	| "glm-ocr"
+	| "moondream3.1-9B-A2B"
+	| "kimi-k2.7-code";
+export type OcrTelemetryFinishReason =
+	| "stop"
+	| "length"
+	| "content_filter"
+	| "tool_calls"
+	| "function_call"
+	| "error"
+	| "unknown";
+const ERROR_CODES: ReadonlySet<string> = new Set([
+	"OCR_UNAVAILABLE",
+	"UNSUPPORTED_OCR_BACKEND",
+	"OCR_UPSTREAM_FAILED",
+	"OCR_INCOMPLETE_RESPONSE",
+	"transport_network_error",
+	"transport_timeout",
+	"other",
+]);
+const MODELS = new Map<string, OcrTelemetryModel>([
+	["@cf/google/gemma-4-26b-a4b-it", "gemma-4-26b-a4b-it"],
+	["zai-org/GLM-OCR", "glm-ocr"],
+	["@cf/moondream/moondream3.1-9B-A2B", "moondream3.1-9B-A2B"],
+	["@cf/moonshotai/kimi-k2.7-code", "kimi-k2.7-code"],
+]);
+function errorCode(error: unknown): OcrTelemetryErrorCode {
+	const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+	return typeof code === "string" && ERROR_CODES.has(code)
+		? (code as OcrTelemetryErrorCode)
+		: "other";
+}
+function finishReason(value: string | undefined, failed: boolean): OcrTelemetryFinishReason {
+	switch (value) {
+		case "stop":
+		case "length":
+		case "content_filter":
+		case "tool_calls":
+		case "function_call":
+			return value;
+		default:
+			return value === undefined ? (failed ? "error" : "stop") : "unknown";
+	}
+}
+export type OcrTelemetryEvent = {
+	backend: OcrTelemetryBackend;
+	engine: OcrTelemetryEngine;
+	model?: string;
+	ms: number;
+	status?: number;
+	bytesIn?: number;
+	bytesOut?: number;
+	candidates?: number;
+	warnings?: number;
+	errorCode?: OcrTelemetryErrorCode;
+	diagnostics?: string;
+	finishReason?: OcrTelemetryFinishReason;
+};
+export interface OcrTelemetrySink {
+	record(event: OcrTelemetryEvent): void;
+	markTelemetryFailed?(): void;
+}
+export type OcrTelemetryLogPayload = {
+	telemetryFailed?: true;
+	diagnostics?: string[];
+	backend: OcrTelemetryBackend;
+	engine: OcrTelemetryEngine;
+	model?: string;
+	ms: number;
+	status?: number;
+	bytesIn: number;
+	bytesOut: number;
+	candidates: number;
+	warnings: number;
+	lastErrorCode?: OcrTelemetryErrorCode;
+	finishReason?: OcrTelemetryFinishReason;
+	samples?: Array<Omit<OcrTelemetryEvent, "backend" | "engine" | "model" | "diagnostics">>;
+	samplesDropped?: number;
+};
+export type OcrTelemetryHeaderPayload = {
+	backend: ClosedEnum<OcrTelemetryBackend>;
+	engine: ClosedEnum<OcrTelemetryEngine>;
+	model?: ClosedEnum<OcrTelemetryModel>;
+	ms: number;
+	status?: number;
+	bytesIn: number;
+	bytesOut: number;
+	candidates: number;
+	warnings: number;
+	lastErrorCode?: ClosedEnum<OcrTelemetryErrorCode>;
+	finishReason?: ClosedEnum<OcrTelemetryFinishReason>;
+	samples?: Array<{
+		ms: number;
+		status?: number;
+		bytesIn?: number;
+		bytesOut?: number;
+		candidates?: number;
+		warnings?: number;
+		errorCode?: ClosedEnum<OcrTelemetryErrorCode>;
+		finishReason?: ClosedEnum<OcrTelemetryFinishReason>;
+	}>;
+	samplesDropped?: number;
+};
+export class OcrTelemetryCollector
+	implements
+		OcrTelemetrySink,
+		TelemetryContributor<OcrTelemetryLogPayload, OcrTelemetryHeaderPayload>
+{
+	readonly key = "ocr" as const;
+	readonly #redact?: (text: string) => string;
+	#samples: NonNullable<OcrTelemetryLogPayload["samples"]> = [];
+	#summary: Omit<OcrTelemetryLogPayload, "samples" | "samplesDropped"> | undefined;
+	#diagnostics: string[] = [];
+	#dropped = 0;
+	#failed = false;
+	constructor(options: { redact?: (text: string) => string } = {}) {
+		this.#redact = options.redact;
+	}
+	markTelemetryFailed(): void {
+		this.#failed = true;
+		this.#summary ??= {
+			backend: "custom",
+			engine: "custom",
+			ms: 0,
+			bytesIn: 0,
+			bytesOut: 0,
+			candidates: 0,
+			warnings: 0,
+		};
+	}
+	record(event: OcrTelemetryEvent): void {
+		const sample = {
+			ms: integer(event.ms),
+			...(event.status === undefined ? {} : { status: integer(event.status) }),
+			...(event.bytesIn === undefined ? {} : { bytesIn: integer(event.bytesIn) }),
+			...(event.bytesOut === undefined ? {} : { bytesOut: integer(event.bytesOut) }),
+			...(event.candidates === undefined ? {} : { candidates: integer(event.candidates) }),
+			...(event.warnings === undefined ? {} : { warnings: integer(event.warnings) }),
+			...(event.errorCode ? { errorCode: event.errorCode } : {}),
+			...(event.finishReason ? { finishReason: event.finishReason } : {}),
+			...(event.diagnostics === undefined
+				? {}
+				: { diagnostics: capabilityText(event.diagnostics, this.#redact, true) }),
+		};
+		const prior = this.#summary;
+		this.#summary = {
+			backend: event.backend,
+			engine: event.engine,
+			...(event.model === undefined ? {} : { model: capabilityText(event.model, this.#redact) }),
+			ms: add(prior?.ms ?? 0, sample.ms),
+			...(sample.status === undefined ? {} : { status: sample.status }),
+			bytesIn: add(prior?.bytesIn ?? 0, sample.bytesIn ?? 0),
+			bytesOut: add(prior?.bytesOut ?? 0, sample.bytesOut ?? 0),
+			candidates: add(prior?.candidates ?? 0, sample.candidates ?? 0),
+			warnings: add(prior?.warnings ?? 0, sample.warnings ?? 0),
+			...(event.errorCode ? { lastErrorCode: event.errorCode } : {}),
+			...(event.finishReason ? { finishReason: event.finishReason } : {}),
+		};
+		if (this.#samples.length < 24) {
+			const { diagnostics, ...closedSample } = sample;
+			this.#samples.push(closedSample);
+			if (diagnostics !== undefined) this.#diagnostics.push(diagnostics);
+		} else this.#dropped = add(this.#dropped, 1);
+	}
+	toLogPayload(_spans: SpanIndex): OcrTelemetryLogPayload | undefined {
+		if (!this.#summary) return undefined;
+		return {
+			...this.#summary,
+			...(this.#diagnostics.length ? { diagnostics: [...this.#diagnostics] } : {}),
+			...(this.#failed ? { telemetryFailed: true as const } : {}),
+			samples: this.#samples.map((s) => ({ ...s })),
+			...(this.#dropped ? { samplesDropped: this.#dropped } : {}),
+		};
+	}
+	toHeaderPayload(log: OcrTelemetryLogPayload): OcrTelemetryHeaderPayload {
+		return {
+			backend: closedEnum(log.backend),
+			engine: closedEnum(log.engine),
+			...(log.model && MODELS.has(log.model) ? { model: closedEnum(MODELS.get(log.model)!) } : {}),
+			ms: log.ms,
+			...(log.status === undefined ? {} : { status: log.status }),
+			bytesIn: log.bytesIn,
+			bytesOut: log.bytesOut,
+			candidates: log.candidates,
+			warnings: log.warnings,
+			...(log.lastErrorCode ? { lastErrorCode: closedEnum(log.lastErrorCode) } : {}),
+			...(log.finishReason ? { finishReason: closedEnum(log.finishReason) } : {}),
+			...(log.samples
+				? {
+						samples: log.samples.map((s) => ({
+							ms: s.ms,
+							...(s.status === undefined ? {} : { status: s.status }),
+							...(s.bytesIn === undefined ? {} : { bytesIn: s.bytesIn }),
+							...(s.bytesOut === undefined ? {} : { bytesOut: s.bytesOut }),
+							...(s.candidates === undefined ? {} : { candidates: s.candidates }),
+							...(s.warnings === undefined ? {} : { warnings: s.warnings }),
+							...(s.errorCode ? { errorCode: closedEnum(s.errorCode) } : {}),
+							...(s.finishReason ? { finishReason: closedEnum(s.finishReason) } : {}),
+						})),
+					}
+				: {}),
+			...(log.samplesDropped ? { samplesDropped: log.samplesDropped } : {}),
+		};
+	}
+}
+export function bindOcrTelemetry(
+	context: OcrContext,
+	sink: OcrTelemetrySink,
+	options: { backend?: OcrTelemetryBackend; engine?: OcrTelemetryEngine; model?: string } = {},
+): OcrContext {
+	const metadata = capabilityMetadata(context);
+	const backend =
+		options.backend ?? (metadata?.backend as OcrTelemetryBackend | undefined) ?? "custom";
+	const engine = options.engine ?? (metadata?.engine as OcrTelemetryEngine | undefined) ?? "custom";
+	const model = options.model ?? metadata?.model;
+	async function run<
+		T extends {
+			text: string;
+			model: string;
+			candidates?: readonly unknown[];
+			warnings?: readonly unknown[];
+		},
+	>(input: { kind: string; data?: string; url?: string }, operation: () => Promise<T>): Promise<T> {
+		const started = performance.now();
+		const facts: { status?: number; finishReason?: string; diagnostics?: string } = {};
+		observeCapability(sink, () => registerCapabilityInput(input));
+		let result: T;
+		try {
+			result = await capabilityFacts.run(facts, operation);
+		} catch (error) {
+			observeCapability(sink, () => {
+				const status =
+					error &&
+					typeof error === "object" &&
+					"status" in error &&
+					typeof error.status === "number"
+						? error.status
+						: undefined;
+				return sink.record({
+					backend,
+					engine,
+					model,
+					ms: performance.now() - started,
+					status: facts.status ?? status,
+					bytesIn: inputBytes(input),
+					errorCode: errorCode(error),
+					finishReason: finishReason(facts.finishReason, true),
+					diagnostics: `${capabilityErrorText(error)} ${facts.diagnostics ?? ""}`,
+				});
+			});
+			throw error;
+		}
+		observeCapability(sink, () =>
+			sink.record({
+				backend,
+				engine,
+				model: result.model,
+				ms: performance.now() - started,
+				status: facts.status,
+				bytesIn: inputBytes(input),
+				bytesOut: Buffer.byteLength(result.text),
+				candidates: result.candidates?.length ?? 0,
+				finishReason: finishReason(facts.finishReason, false),
+				warnings: result.warnings?.length ?? 0,
+			}),
+		);
+		return result;
+	}
+	return {
+		...context,
+		recognize: (request) => run(request.image, () => context.recognize(request)),
+		extractCaptchaText: (image, opts) => run(image, () => context.extractCaptchaText(image, opts)),
+	};
+}

package/src/runtime/ocr.ts

@@ -1,4 +1,3 @@
-import { readDiagnosticEnv } from "./diagnostic-env.js";
 import { ProviderError, TransportError } from "../errors.js";
 import type {
 	OcrCaptchaCandidate,
@@ -10,6 +9,13 @@ import type {
 	OcrResult,
 	ProviderOcrConfig,
 } from "../types.js";
+import { readCapabilityErrorBody } from "./capability-response.js";
+import {
+	captureCapability,
+	registerCapabilityInput,
+	tagCapability,
+} from "./capability-telemetry.js";
+import { readDiagnosticEnv, registerDiagnosticValue } from "./diagnostic-env.js";
 import { CLOUDFLARE_ACCOUNT_ID_ENV } from "./stt.js";
 import { createTimeoutController, isTimeoutLikeError } from "./timeout.js";
 
@@ -78,14 +84,17 @@ function createErrorOcrClient(options: ErrorOcrClientOptions): OcrContext {
 			fix: options.fix,
 		});
 	};
-	return {
-		async recognize() {
-			return unavailable();
-		},
-		async extractCaptchaText() {
-			return unavailable();
+	return tagCapability(
+		{
+			async recognize() {
+				return unavailable();
+			},
+			async extractCaptchaText() {
+				return unavailable();
+			},
 		},
-	};
+		{ backend: "unavailable", engine: "custom" },
+	);
 }
 
 export function createUnsupportedOcrClient(reason?: string): OcrContext {
@@ -249,6 +258,8 @@ function responseContent(payload: unknown, cloudflare: boolean, model: string):
 	const choices = root?.choices;
 	if (!Array.isArray(choices)) return undefined;
 	const choice = unknownRecord(choices[0]);
+	if (typeof choice?.finish_reason === "string")
+		captureCapability({ finishReason: choice.finish_reason });
 	if (typeof choice?.finish_reason === "string" && choice.finish_reason !== "stop") {
 		throw incompleteResponseError(model, choice.finish_reason);
 	}
@@ -305,7 +316,11 @@ function moondreamSseContent(body: string, model: string): string | undefined {
 			terminalFinishReason = chunk.finish_reason;
 		}
 	}
-	if (finalAnswer) return finalAnswer;
+	if (finalAnswer) {
+		captureCapability({ finishReason: "stop" });
+		return finalAnswer;
+	}
+	if (terminalFinishReason) captureCapability({ finishReason: terminalFinishReason });
 	if (terminalFinishReason) throw incompleteResponseError(model, terminalFinishReason);
 	if (firstDecodingFailure) throw malformedResponseError(model, firstDecodingFailure);
 	return finalAnswer;
@@ -361,48 +376,57 @@ export function createCloudflareWorkersAiOcrClient(
 ): OcrContext {
 	const model = options.model ?? DEFAULT_CLOUDFLARE_WORKERS_AI_OCR_MODEL;
 	const runFetch = options.fetch ?? fetch;
-	return createOcrClient(model, async (request) => {
-		const timeout = createTimeoutController(request.timeoutMs ?? DEFAULT_OCR_TIMEOUT_MS);
-		try {
-			let response: Response;
+	return tagCapability(
+		createOcrClient(model, async (request) => {
+			registerCapabilityInput(request.image);
+			registerDiagnosticValue(options.apiToken);
+			registerDiagnosticValue(`Bearer ${options.apiToken}`);
+			const timeout = createTimeoutController(request.timeoutMs ?? DEFAULT_OCR_TIMEOUT_MS);
 			try {
-				response = await runFetch(
-					`https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(options.accountId)}/ai/run/${model}`,
-					{
-						method: "POST",
-						headers: {
-							Authorization: `Bearer ${options.apiToken}`,
-							"Content-Type": "application/json",
+				let response: Response;
+				try {
+					response = await runFetch(
+						`https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(options.accountId)}/ai/run/${model}`,
+						{
+							method: "POST",
+							headers: {
+								Authorization: `Bearer ${options.apiToken}`,
+								"Content-Type": "application/json",
+							},
+							body: JSON.stringify(
+								isMoondreamModel(model)
+									? moondreamPayload(request)
+									: cloudflareMessagesPayload(request, model),
+							),
+							signal: timeout.controller.signal,
 						},
-						body: JSON.stringify(
-							isMoondreamModel(model)
-								? moondreamPayload(request)
-								: cloudflareMessagesPayload(request, model),
-						),
-						signal: timeout.controller.signal,
-					},
-				);
+					);
+				} catch (error) {
+					throw toOcrTransportError(error);
+				}
+				captureCapability({ status: response.status });
+				if (!response.ok) {
+					const echoed = await readCapabilityErrorBody(response, timeout.controller.signal);
+					captureCapability({ diagnostics: echoed });
+					throw new TransportError("OCR upstream request failed", {
+						code: "OCR_UPSTREAM_FAILED",
+						status: response.status,
+						upstreamStatus: response.status,
+					});
+				}
+				const text = isMoondreamModel(model)
+					? moondreamSseContent(await response.text(), model)
+					: responseContent(await responseJson(response, model), true, model);
+				if (!text) throw emptyResponseError(model);
+				return { text, model };
 			} catch (error) {
 				throw toOcrTransportError(error);
+			} finally {
+				timeout.clear();
 			}
-			if (!response.ok) {
-				throw new TransportError("OCR upstream request failed", {
-					code: "OCR_UPSTREAM_FAILED",
-					status: response.status,
-					upstreamStatus: response.status,
-				});
-			}
-			const text = isMoondreamModel(model)
-				? moondreamSseContent(await response.text(), model)
-				: responseContent(await responseJson(response, model), true, model);
-			if (!text) throw emptyResponseError(model);
-			return { text, model };
-		} catch (error) {
-			throw toOcrTransportError(error);
-		} finally {
-			timeout.clear();
-		}
-	});
+		}),
+		{ backend: "cloudflare-workers-ai", engine: "workers-ai", model },
+	);
 }
 
 export function createOpenAiCompatibleOcrClient(
@@ -410,38 +434,49 @@ export function createOpenAiCompatibleOcrClient(
 ): OcrContext {
 	const model = options.model;
 	const runFetch = options.fetch ?? fetch;
-	return createOcrClient(model, async (request) => {
-		const headers: Record<string, string> = { "Content-Type": "application/json" };
-		if (options.apiKey) headers.Authorization = `Bearer ${options.apiKey}`;
-		const timeout = createTimeoutController(request.timeoutMs ?? DEFAULT_OCR_TIMEOUT_MS);
-		try {
-			let response: Response;
+	return tagCapability(
+		createOcrClient(model, async (request) => {
+			registerCapabilityInput(request.image);
+			if (options.apiKey) {
+				registerDiagnosticValue(options.apiKey);
+				registerDiagnosticValue(`Bearer ${options.apiKey}`);
+			}
+			const headers: Record<string, string> = { "Content-Type": "application/json" };
+			if (options.apiKey) headers.Authorization = `Bearer ${options.apiKey}`;
+			const timeout = createTimeoutController(request.timeoutMs ?? DEFAULT_OCR_TIMEOUT_MS);
 			try {
-				response = await runFetch(`${options.baseUrl.replace(/\/+$/u, "")}/chat/completions`, {
-					method: "POST",
-					headers,
-					body: JSON.stringify(messagesPayload(request, model)),
-					signal: timeout.controller.signal,
-				});
+				let response: Response;
+				try {
+					response = await runFetch(`${options.baseUrl.replace(/\/+$/u, "")}/chat/completions`, {
+						method: "POST",
+						headers,
+						body: JSON.stringify(messagesPayload(request, model)),
+						signal: timeout.controller.signal,
+					});
+				} catch (error) {
+					throw toOcrTransportError(error);
+				}
+				captureCapability({ status: response.status });
+				if (!response.ok) {
+					const echoed = await readCapabilityErrorBody(response, timeout.controller.signal);
+					captureCapability({ diagnostics: echoed });
+					throw new TransportError("OCR upstream request failed", {
+						code: "OCR_UPSTREAM_FAILED",
+						status: response.status,
+						upstreamStatus: response.status,
+					});
+				}
+				const text = responseContent(await responseJson(response, model), false, model);
+				if (!text) throw emptyResponseError(model);
+				return { text, model };
 			} catch (error) {
 				throw toOcrTransportError(error);
+			} finally {
+				timeout.clear();
 			}
-			if (!response.ok) {
-				throw new TransportError("OCR upstream request failed", {
-					code: "OCR_UPSTREAM_FAILED",
-					status: response.status,
-					upstreamStatus: response.status,
-				});
-			}
-			const text = responseContent(await responseJson(response, model), false, model);
-			if (!text) throw emptyResponseError(model);
-			return { text, model };
-		} catch (error) {
-			throw toOcrTransportError(error);
-		} finally {
-			timeout.clear();
-		}
-	});
+		}),
+		{ backend: "openai-compatible", engine: "openai-compatible", model },
+	);
 }
 
 function cleanCaptchaText(text: string): string {

package/src/runtime/request-telemetry.ts

@@ -140,7 +140,8 @@ const MAX_INGESTIBLE_ARRAY_LENGTH = 64;
 const MAX_INGESTIBLE_OBJECT_KEYS = 32;
 const MAX_INGESTIBLE_DEPTH = 4;
 const INGESTIBLE_TOKEN = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/;
-const HEADER_PRIORITY = [
+/** @internal */
+export const HEADER_PRIORITY = [
 	"proxy",
 	"resolver",
 	"native",

package/src/runtime/resolver-runtime-options.ts

@@ -0,0 +1,50 @@
+import type { ProviderCache, ProviderDefinition, ProviderProxyPolicy } from "../types.js";
+import type { ResolverRuntimeOptions } from "./resolver.js";
+import type { ResolverTelemetrySink } from "./resolver-telemetry.js";
+import type { BrowserTelemetrySink } from "./browser-telemetry.js";
+
+/** Normalize the `proxy` declaration shorthand (`true`/`false`) into the policy object the resolver chain consumes. */
+export function resolveNativeProxyPolicy(
+	provider: ProviderDefinition,
+): ProviderProxyPolicy | undefined {
+	if (typeof provider.proxy === "object") return provider.proxy;
+	if (provider.proxy === true) return { mode: "optional" };
+	if (provider.proxy === false) return { mode: "disabled" };
+	return undefined;
+}
+
+/**
+ * One option set for every SDK-built resolver chain — the server's ctx.resolver and automatic
+ * SBSD solve, and the CLI helper contexts — so they share allowed hosts, cache, identity scope,
+ * proxy intent, and the telemetry sink. `identityScope` is server-owned; CLI contexts pass none.
+ */
+export function createResolverRuntimeOptions(
+	provider: ProviderDefinition,
+	cache: ProviderCache,
+	identityScope: string | undefined,
+	proxyPolicy: ProviderProxyPolicy | undefined,
+	proxyClientOptions: Omit<
+		NonNullable<ResolverRuntimeOptions["proxyIntent"]>,
+		"mode" | "userAgent"
+	>,
+	stealthProfile: { readonly userAgent: string } | undefined,
+	telemetry: ResolverTelemetrySink,
+	browserTelemetry?: BrowserTelemetrySink,
+): ResolverRuntimeOptions {
+	return {
+		allowedHosts: provider.allowedHosts,
+		cache,
+		telemetry,
+		browserTelemetry,
+		...(identityScope === undefined ? {} : { identityScope }),
+		...(proxyPolicy
+			? {
+					proxyIntent: {
+						mode: proxyPolicy.mode,
+						...proxyClientOptions,
+						...(stealthProfile ? { userAgent: stealthProfile.userAgent } : {}),
+					},
+				}
+			: {}),
+	};
+}

package/src/runtime/resolver-shared.ts

@@ -2,8 +2,12 @@ import { ProviderError } from "../errors.js";
 import type { ChallengeSolution, ProviderChallenge, ResolverContext } from "../types.js";
 import type { TraceRecorder } from "./trace.js";
 import type { ResolverTelemetryOutcome, ResolverTelemetrySink } from "./resolver-telemetry.js";
+import type { BrowserTelemetrySink } from "./browser-telemetry.js";
 
-type ResolverTelemetryBinding = (sink: ResolverTelemetrySink) => ResolverContext;
+type ResolverTelemetryBinding = (
+	sink: ResolverTelemetrySink,
+	browserSink?: BrowserTelemetrySink,
+) => ResolverContext;
 const telemetryBindings = new WeakMap<ResolverContext, ResolverTelemetryBinding>();
 
 /** Internal contract: reconstruct a chain with a new request sink, without mutating the host chain. */
@@ -27,6 +31,7 @@ export function inheritResolverTelemetryBinding(
 export function bindResolverTelemetry(
 	resolver: ResolverContext,
 	sink: ResolverTelemetrySink | undefined,
+	browserSink?: BrowserTelemetrySink,
 ): ResolverContext {
 	if (!sink) return resolver;
 	const metadata = (
@@ -34,9 +39,9 @@ export function bindResolverTelemetry(
 			readonly [RESOLVER_INSTRUMENTATION_METADATA]?: { readonly target: ResolverContext };
 		}
 	)[RESOLVER_INSTRUMENTATION_METADATA];
-	if (metadata) return bindResolverTelemetry(metadata.target, sink);
+	if (metadata) return bindResolverTelemetry(metadata.target, sink, browserSink);
 	const bind = telemetryBindings.get(resolver);
-	if (bind) return bind(sink);
+	if (bind) return bind(sink, browserSink);
 	const wrapper: ResolverSolveWithRecorder = {
 		async solve(challenge, signal, recorder) {
 			const startedAt = Date.now();
@@ -74,7 +79,7 @@ export function bindResolverTelemetry(
 }
 
 function createOpaqueResolverTelemetryBinding(resolver: ResolverContext): ResolverTelemetryBinding {
-	return (sink) => bindResolverTelemetry(resolver, sink);
+	return (sink, browserSink) => bindResolverTelemetry(resolver, sink, browserSink);
 }
 
 export const RESOLVER_INSTRUMENTATION_METADATA = Symbol.for(

package/src/runtime/resolver-telemetry.ts

@@ -147,7 +147,7 @@ function boundedInteger(value: number): number {
 	return Math.max(0, Math.floor(Number.isFinite(value) ? value : 0));
 }
 
-function boundedText(value: string, redact?: (text: string) => string): string {
+export function boundedText(value: string, redact?: (text: string) => string): string {
 	let result = value;
 	try {
 		result = redact?.(value) ?? value;