@telemetry-dev/tanstack-ai 0.1.0

package/dist/index.mjs

@@ -0,0 +1,681 @@
+import { ROOT_CONTEXT, SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
+import { ProtobufMetricsSerializer, ProtobufTraceSerializer } from "@opentelemetry/otlp-transformer";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { AggregationTemporality, MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
+//#region src/config.ts
+const DEFAULT_BASE_URL = "https://ingest.telemetry.dev";
+function resolveConfig(options = {}) {
+	const env = typeof process !== "undefined" && process.env ? process.env : {};
+	const baseUrl = (options.baseUrl ?? env.TELEMETRY_DEV_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+	return {
+		apiKey: options.apiKey ?? env.TELEMETRY_DEV_API_KEY,
+		baseUrl,
+		environment: options.environment ?? env.TELEMETRY_DEV_ENVIRONMENT ?? "production",
+		serviceName: options.serviceName ?? env.OTEL_SERVICE_NAME ?? "unknown_service",
+		fetchImpl: options.fetch ?? globalThis.fetch,
+		waitUntil: options.waitUntil,
+		onError: options.onError
+	};
+}
+//#endregion
+//#region src/otel.ts
+const DURATION_BUCKETS = [
+	.01,
+	.02,
+	.04,
+	.08,
+	.16,
+	.32,
+	.64,
+	1.28,
+	2.56,
+	5.12,
+	10.24,
+	20.48,
+	40.96,
+	81.92
+];
+const TOKEN_BUCKETS = [
+	1,
+	4,
+	16,
+	64,
+	256,
+	1024,
+	4096,
+	16384,
+	65536,
+	262144,
+	1048576,
+	4194304,
+	16777216,
+	67108864
+];
+const SCOPE_NAME = "@telemetry-dev/tanstack-ai";
+const SCOPE_VERSION = "0.0.0";
+const RETRY_DELAYS_MS = [100, 500];
+const RETRYABLE_STATUSES = new Set([
+	429,
+	502,
+	503,
+	504
+]);
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const cancelBody = async (res) => {
+	try {
+		await res.body?.cancel();
+	} catch {}
+};
+const postOtlp = async ({ fetchImpl, url, headers, body }) => {
+	for (let attempt = 0;; attempt += 1) {
+		try {
+			const res = await fetchImpl(url, {
+				method: "POST",
+				headers,
+				body
+			});
+			if (res.ok || !RETRYABLE_STATUSES.has(res.status) || attempt === RETRY_DELAYS_MS.length) {
+				await cancelBody(res);
+				return res;
+			}
+			await cancelBody(res);
+		} catch (error) {
+			if (attempt === RETRY_DELAYS_MS.length) throw error;
+		}
+		await delay(RETRY_DELAYS_MS[attempt]);
+	}
+};
+const cache = /* @__PURE__ */ new Map();
+const buildCore = (config) => {
+	const { apiKey, baseUrl, environment, serviceName } = config;
+	const resource = resourceFromAttributes({
+		"service.name": serviceName,
+		"deployment.environment.name": environment
+	});
+	const headers = {
+		"content-type": "application/x-protobuf",
+		authorization: `Bearer ${apiKey}`
+	};
+	const tracer = new BasicTracerProvider({ resource }).getTracer(SCOPE_NAME, SCOPE_VERSION);
+	const sendSpans = async (spans, transport) => {
+		const body = ProtobufTraceSerializer.serializeRequest(spans);
+		if (!body || body.byteLength === 0) return;
+		const { fetchImpl, onError } = transport;
+		const res = await postOtlp({
+			fetchImpl,
+			url: `${baseUrl}/v1/traces`,
+			headers,
+			body
+		});
+		if (!res.ok) onError?.(/* @__PURE__ */ new Error(`telemetry.dev trace ingest failed: ${res.status}`));
+	};
+	const buildMetrics = (transport) => {
+		const { fetchImpl, onError } = transport;
+		const meterProvider = new MeterProvider({
+			resource,
+			readers: [new PeriodicExportingMetricReader({
+				exporter: {
+					export(resourceMetrics, resultCallback) {
+						const body = ProtobufMetricsSerializer.serializeRequest(resourceMetrics);
+						if (!body || body.byteLength === 0) {
+							resultCallback({ code: 0 });
+							return;
+						}
+						fetchImpl(`${baseUrl}/v1/metrics`, {
+							method: "POST",
+							headers,
+							body
+						}).then((res) => {
+							if (!res.ok) {
+								const error = /* @__PURE__ */ new Error(`telemetry.dev metric ingest failed: ${res.status}`);
+								onError?.(error);
+								resultCallback({
+									code: 1,
+									error
+								});
+								return;
+							}
+							resultCallback({ code: 0 });
+						}).catch((error) => {
+							onError?.(error);
+							resultCallback({
+								code: 1,
+								error: error instanceof Error ? error : void 0
+							});
+						});
+					},
+					selectAggregationTemporality: () => AggregationTemporality.DELTA,
+					forceFlush: () => Promise.resolve(),
+					shutdown: () => Promise.resolve()
+				},
+				exportIntervalMillis: 2 ** 31 - 1
+			})]
+		});
+		const meter = meterProvider.getMeter(SCOPE_NAME, SCOPE_VERSION);
+		return {
+			durationHistogram: meter.createHistogram("gen_ai.client.operation.duration", {
+				unit: "s",
+				advice: { explicitBucketBoundaries: DURATION_BUCKETS }
+			}),
+			tokenHistogram: meter.createHistogram("gen_ai.client.token.usage", {
+				unit: "{token}",
+				advice: { explicitBucketBoundaries: TOKEN_BUCKETS }
+			}),
+			shutdown: () => meterProvider.shutdown()
+		};
+	};
+	return {
+		tracer,
+		sendSpans,
+		buildMetrics
+	};
+};
+const coreFor = (config) => {
+	const key = `${config.apiKey}|${config.baseUrl}|${config.environment}|${config.serviceName}`;
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const core = buildCore(config);
+	cache.set(key, core);
+	return core;
+};
+const createEmitter = (config, overrides) => {
+	const core = coreFor(config);
+	const transport = {
+		fetchImpl: config.fetchImpl,
+		onError: config.onError
+	};
+	const onError = config.onError;
+	const sendSpans = overrides?.sendSpans ?? ((spans) => core.sendSpans(spans, transport));
+	let metrics;
+	const ensureMetrics = () => metrics ??= core.buildMetrics(transport);
+	const recordDuration = overrides?.recordDuration ?? ((seconds, attributes) => ensureMetrics().durationHistogram.record(seconds, attributes));
+	const recordTokens = overrides?.recordTokens ?? ((tokenType, count, attributes) => ensureMetrics().tokenHistogram.record(count, {
+		...attributes,
+		"gen_ai.token.type": tokenType
+	}));
+	const flush = (spans) => {
+		const pipeline = metrics;
+		metrics = void 0;
+		const p = (async () => {
+			try {
+				await sendSpans(spans);
+			} catch (e) {
+				onError?.(e);
+			}
+			try {
+				if (pipeline) await pipeline.shutdown();
+			} catch (e) {
+				onError?.(e);
+			}
+		})();
+		if (config.waitUntil) {
+			config.waitUntil(p);
+			return Promise.resolve();
+		}
+		return p;
+	};
+	return {
+		tracer: core.tracer,
+		recordDuration,
+		recordTokens,
+		flush
+	};
+};
+//#endregion
+//#region src/middleware.ts
+function omitUndefined(attributes) {
+	const out = {};
+	for (const key of Object.keys(attributes)) {
+		const value = attributes[key];
+		if (value !== void 0) out[key] = value;
+	}
+	return out;
+}
+function readId(value) {
+	if (typeof value === "string") return value.length > 0 ? value : null;
+	if (typeof value === "number" || typeof value === "bigint") return value.toString();
+	return null;
+}
+function jsonAttr(value) {
+	if (value === void 0) return void 0;
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+function firstNumber(...candidates) {
+	for (const candidate of candidates) if (typeof candidate === "number" && Number.isFinite(candidate)) return candidate;
+}
+function errorTypeName(err) {
+	if (err instanceof Error) return err.name || "Error";
+	if (err && typeof err === "object" && "name" in err) {
+		const n = err.name;
+		if (typeof n === "string" && n.length > 0) return n;
+	}
+	return "Error";
+}
+function errorMessage(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (err && typeof err === "object" && "message" in err) {
+		const m = err.message;
+		if (typeof m === "string") return m;
+	}
+	return String(err);
+}
+const SEVERITY_INFO = 9;
+const SEVERITY_ERROR = 17;
+const MAX_TOKENS_KEYS = [
+	"max_output_tokens",
+	"max_tokens",
+	"max_completion_tokens",
+	"maxOutputTokens",
+	"maxCompletionTokens",
+	"maxTokens"
+];
+function samplingAttributes(modelOptions) {
+	const sampling = modelOptions ?? {};
+	const nested = sampling["options"] && typeof sampling["options"] === "object" ? sampling["options"] : void 0;
+	return omitUndefined({
+		"gen_ai.request.temperature": firstNumber(sampling["temperature"], nested?.["temperature"]),
+		"gen_ai.request.top_p": firstNumber(sampling["top_p"], sampling["topP"], nested?.["top_p"]),
+		"gen_ai.request.max_tokens": firstNumber(...MAX_TOKENS_KEYS.map((key) => sampling[key]), nested?.["num_predict"])
+	});
+}
+/**
+* Build a TanStack AI chat middleware that streams `chat()` runs to telemetry.dev as
+* OpenTelemetry GenAI (`gen_ai.*`) spans + metrics: one root span per `chat()` call, one CLIENT
+* span per agent-loop iteration, and one span per tool execution. Per-run state is keyed by the
+* middleware context in a WeakMap, so a single `telemetryDev()` instance is safe to share across
+* concurrent and overlapping `chat()` calls (e.g. registered once at module scope).
+*/
+function telemetryDev(options, overrides) {
+	const config = resolveConfig(options);
+	if (!config.apiKey) return { name: "telemetry-dev" };
+	const emitter = createEmitter(config, overrides);
+	const onError = config.onError;
+	const states = /* @__PURE__ */ new WeakMap();
+	const closeIteration = (state) => {
+		const iteration = state.iteration;
+		if (!iteration) return;
+		const endedAt = /* @__PURE__ */ new Date();
+		const usage = iteration.usage;
+		iteration.span.setAttributes(omitUndefined({
+			"gen_ai.response.model": iteration.responseModel ?? void 0,
+			"gen_ai.response.finish_reasons": iteration.finishReason ? [iteration.finishReason] : void 0,
+			"gen_ai.usage.input_tokens": usage?.promptTokens,
+			"gen_ai.usage.output_tokens": usage?.completionTokens,
+			"gen_ai.usage.cache_read.input_tokens": usage?.promptTokensDetails?.cachedTokens,
+			"gen_ai.usage.cache_creation.input_tokens": usage?.promptTokensDetails?.cacheWriteTokens,
+			"gen_ai.usage.reasoning.output_tokens": usage?.completionTokensDetails?.reasoningTokens,
+			"gen_ai.usage.cost": usage?.cost,
+			"gen_ai.output.type": iteration.structured ? "json" : "text",
+			"gen_ai.output.messages": jsonAttr(iteration.outputText ?? void 0)
+		}));
+		iteration.span.end(endedAt);
+		state.childSpans.push(iteration.span);
+		state.iterationMetrics.push({
+			durationSec: Math.max(endedAt.getTime() - iteration.startedAt.getTime(), 0) / 1e3,
+			inputTokens: usage?.promptTokens ?? null,
+			outputTokens: usage?.completionTokens ?? null
+		});
+		if (iteration.structured && iteration.outputText !== null) state.structuredOutput = iteration.outputText;
+		state.iteration = null;
+	};
+	const setRootBaseAttributes = (state) => {
+		state.rootSpan.setAttributes(omitUndefined({
+			"gen_ai.operation.name": state.hasToolSpan ? "invoke_agent" : "chat",
+			"gen_ai.provider.name": state.provider,
+			"gen_ai.request.model": state.requestModel,
+			"gen_ai.response.model": state.responseModel ?? void 0,
+			"gen_ai.conversation.id": state.sessionId,
+			"gen_ai.input.messages": state.rootInput,
+			"user.id": state.userId ?? void 0,
+			...state.rootSampling
+		}));
+		if (state.restMetadata) for (const [key, value] of Object.entries(state.restMetadata)) {
+			const attr = typeof value === "string" ? value : jsonAttr(value);
+			if (attr !== void 0) state.rootSpan.setAttribute(`td.metadata.${key}`, attr);
+		}
+	};
+	const addSummaryEvent = (state, hasError, message) => {
+		const inputPresent = state.iterationMetrics.some((m) => m.inputTokens !== null);
+		const outputPresent = state.iterationMetrics.some((m) => m.outputTokens !== null);
+		const inputTokens = state.iterationMetrics.reduce((sum, m) => sum + (m.inputTokens ?? 0), 0);
+		const outputTokens = state.iterationMetrics.reduce((sum, m) => sum + (m.outputTokens ?? 0), 0);
+		state.rootSpan.addEvent("generation.summary", omitUndefined({
+			"log.severity_number": hasError ? SEVERITY_ERROR : SEVERITY_INFO,
+			"log.message": message,
+			"gen_ai.usage.input_tokens": inputPresent ? inputTokens : void 0,
+			"gen_ai.usage.output_tokens": outputPresent ? outputTokens : void 0
+		}));
+	};
+	const recordRunMetrics = (state) => {
+		const metricBase = omitUndefined({
+			"gen_ai.provider.name": state.provider,
+			"gen_ai.request.model": state.requestModel,
+			"gen_ai.response.model": state.responseModel ?? void 0
+		});
+		for (const m of state.iterationMetrics) {
+			const attrs = {
+				...metricBase,
+				"gen_ai.operation.name": "chat"
+			};
+			emitter.recordDuration(m.durationSec, attrs);
+			if (m.inputTokens !== null) emitter.recordTokens("input", m.inputTokens, attrs);
+			if (m.outputTokens !== null) emitter.recordTokens("output", m.outputTokens, attrs);
+		}
+		for (const t of state.toolMetrics) emitter.recordDuration(t.durationSec, {
+			...metricBase,
+			"gen_ai.operation.name": "execute_tool"
+		});
+	};
+	const failOpenSpans = (state, errType, message) => {
+		for (const [, entry] of state.openTools) {
+			entry.span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message
+			});
+			entry.span.setAttribute("error.type", errType);
+			entry.span.end();
+			state.childSpans.push(entry.span);
+		}
+		state.openTools.clear();
+		if (state.iteration) {
+			state.iteration.span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message
+			});
+			state.iteration.span.setAttribute("error.type", errType);
+			closeIteration(state);
+		}
+	};
+	return {
+		name: "telemetry-dev",
+		onStart(ctx) {
+			try {
+				const rawMetadata = ctx.options?.["metadata"];
+				const metadata = rawMetadata && typeof rawMetadata === "object" ? rawMetadata : void 0;
+				const userId = readId(metadata?.["userId"]);
+				const sessionId = readId(metadata?.["sessionId"]) ?? ctx.threadId;
+				let restMetadata;
+				if (metadata) {
+					const rest = {};
+					for (const [key, value] of Object.entries(metadata)) if (key !== "userId" && key !== "sessionId") rest[key] = value;
+					restMetadata = Object.keys(rest).length > 0 ? rest : void 0;
+				}
+				const rootSpan = emitter.tracer.startSpan("chat", {
+					startTime: /* @__PURE__ */ new Date(),
+					kind: SpanKind.INTERNAL
+				});
+				states.set(ctx, {
+					rootSpan,
+					rootCtx: trace.setSpan(ROOT_CONTEXT, rootSpan),
+					provider: ctx.provider,
+					requestModel: ctx.model,
+					responseModel: null,
+					userId,
+					sessionId,
+					restMetadata,
+					rootInput: void 0,
+					rootSampling: {},
+					rootCaptured: false,
+					iteration: null,
+					structuredOutput: null,
+					openTools: /* @__PURE__ */ new Map(),
+					childSpans: [],
+					hasToolSpan: false,
+					iterationMetrics: [],
+					toolMetrics: []
+				});
+			} catch (err) {
+				onError?.(err);
+			}
+		},
+		onConfig(ctx, chatConfig) {
+			if (ctx.phase !== "beforeModel" && ctx.phase !== "structuredOutput") return void 0;
+			try {
+				const state = states.get(ctx);
+				if (!state) return void 0;
+				closeIteration(state);
+				const inputMessages = [];
+				for (const prompt of chatConfig.systemPrompts) inputMessages.push({
+					role: "system",
+					content: typeof prompt === "string" ? prompt : prompt.content
+				});
+				for (const message of chatConfig.messages) inputMessages.push({
+					role: message.role,
+					content: message.content
+				});
+				const inputJson = jsonAttr(inputMessages);
+				const sampling = samplingAttributes(chatConfig.modelOptions ?? ctx.modelOptions);
+				if (!state.rootCaptured) {
+					state.rootCaptured = true;
+					state.rootInput = inputJson;
+					state.rootSampling = sampling;
+				}
+				const startedAt = /* @__PURE__ */ new Date();
+				const span = emitter.tracer.startSpan("chat", {
+					startTime: startedAt,
+					kind: SpanKind.CLIENT,
+					attributes: omitUndefined({
+						"gen_ai.operation.name": "chat",
+						"gen_ai.provider.name": ctx.provider,
+						"gen_ai.request.model": ctx.model,
+						"gen_ai.conversation.id": state.sessionId,
+						"gen_ai.input.messages": inputJson,
+						...sampling
+					})
+				}, state.rootCtx);
+				state.iteration = {
+					span,
+					otelCtx: trace.setSpan(state.rootCtx, span),
+					startedAt,
+					usage: null,
+					finishReason: null,
+					responseModel: null,
+					outputText: null,
+					structured: ctx.phase === "structuredOutput"
+				};
+			} catch (err) {
+				onError?.(err);
+			}
+		},
+		onChunk(ctx, chunk) {
+			if (chunk.type !== "RUN_FINISHED" && chunk.type !== "CUSTOM") return void 0;
+			try {
+				const state = states.get(ctx);
+				const iteration = state?.iteration;
+				if (!state || !iteration) return void 0;
+				if (chunk.type === "CUSTOM") {
+					if (iteration.structured && chunk.name === "structured-output.complete") {
+						const raw = chunk.value?.raw;
+						if (typeof raw === "string") iteration.outputText = raw;
+					}
+					return;
+				}
+				iteration.finishReason = chunk.finishReason ?? null;
+				if (chunk.model) {
+					iteration.responseModel = chunk.model;
+					state.responseModel = chunk.model;
+				}
+				if (chunk.usage) iteration.usage = chunk.usage;
+				if (!iteration.structured) iteration.outputText = ctx.accumulatedContent.length > 0 ? ctx.accumulatedContent : null;
+			} catch (err) {
+				onError?.(err);
+			}
+		},
+		onUsage(ctx, usage) {
+			try {
+				const state = states.get(ctx);
+				if (state?.iteration) state.iteration.usage = usage;
+			} catch (err) {
+				onError?.(err);
+			}
+		},
+		onBeforeToolCall(ctx, hookCtx) {
+			try {
+				const state = states.get(ctx);
+				if (!state) return void 0;
+				const startedAt = /* @__PURE__ */ new Date();
+				const span = emitter.tracer.startSpan("execute_tool", {
+					startTime: startedAt,
+					kind: SpanKind.INTERNAL,
+					attributes: omitUndefined({
+						"gen_ai.operation.name": "execute_tool",
+						"gen_ai.tool.name": hookCtx.toolName,
+						"gen_ai.tool.call.id": hookCtx.toolCallId,
+						"gen_ai.conversation.id": state.sessionId,
+						"gen_ai.tool.call.arguments": jsonAttr(hookCtx.args ?? null)
+					})
+				}, state.iteration?.otelCtx ?? state.rootCtx);
+				state.openTools.set(hookCtx.toolCallId, {
+					span,
+					startedAt
+				});
+				state.hasToolSpan = true;
+			} catch (err) {
+				onError?.(err);
+			}
+		},
+		onAfterToolCall(ctx, info) {
+			try {
+				const state = states.get(ctx);
+				const entry = state?.openTools.get(info.toolCallId);
+				if (!state || !entry) return;
+				state.openTools.delete(info.toolCallId);
+				const { span } = entry;
+				if (info.ok) {
+					const result = jsonAttr(info.result ?? null);
+					if (result !== void 0) span.setAttribute("gen_ai.tool.call.result", result);
+				} else {
+					const message = errorMessage(info.error);
+					const errType = info.error instanceof Error ? info.error.name : "tool_error";
+					span.setStatus({ code: SpanStatusCode.ERROR });
+					span.setAttribute("error.type", errType);
+					span.addEvent("exception", {
+						"exception.type": errType,
+						"exception.message": message,
+						"log.severity_number": SEVERITY_ERROR
+					});
+				}
+				span.end();
+				state.childSpans.push(span);
+				state.toolMetrics.push({ durationSec: Math.max(info.duration, 0) / 1e3 });
+			} catch (err) {
+				onError?.(err);
+			}
+		},
+		async onToolPhaseComplete(ctx, info) {
+			if (info.needsApproval.length === 0 && info.needsClientExecution.length === 0) return;
+			try {
+				const state = states.get(ctx);
+				if (!state) return;
+				states.delete(ctx);
+				for (const [, entry] of state.openTools) {
+					entry.span.end();
+					state.childSpans.push(entry.span);
+				}
+				state.openTools.clear();
+				const finishReason = state.iteration?.finishReason ?? "tool_calls";
+				closeIteration(state);
+				state.hasToolSpan = true;
+				setRootBaseAttributes(state);
+				state.rootSpan.setAttributes(omitUndefined({
+					"gen_ai.output.messages": jsonAttr(ctx.accumulatedContent.length > 0 ? ctx.accumulatedContent : void 0),
+					"gen_ai.response.finish_reasons": [finishReason]
+				}));
+				addSummaryEvent(state, false, `Generation paused awaiting tools (${[...info.needsApproval, ...info.needsClientExecution].map((t) => t.toolName).join(", ")})`);
+				state.rootSpan.end();
+				recordRunMetrics(state);
+				await emitter.flush([state.rootSpan, ...state.childSpans]);
+			} catch (err) {
+				onError?.(err);
+			}
+		},
+		async onFinish(ctx, info) {
+			try {
+				const state = states.get(ctx);
+				if (!state) return;
+				states.delete(ctx);
+				for (const [, entry] of state.openTools) {
+					entry.span.end();
+					state.childSpans.push(entry.span);
+				}
+				state.openTools.clear();
+				closeIteration(state);
+				setRootBaseAttributes(state);
+				state.rootSpan.setAttributes(omitUndefined({
+					"gen_ai.output.messages": jsonAttr(state.structuredOutput ?? info.content),
+					"gen_ai.response.finish_reasons": info.finishReason ? [info.finishReason] : void 0
+				}));
+				const finishReason = info.finishReason ?? "unknown";
+				const inputTokens = state.iterationMetrics.reduce((sum, m) => sum + (m.inputTokens ?? 0), 0);
+				const outputTokens = state.iterationMetrics.reduce((sum, m) => sum + (m.outputTokens ?? 0), 0);
+				const tokenParts = [];
+				if (state.iterationMetrics.some((m) => m.inputTokens !== null)) tokenParts.push(`${inputTokens} in`);
+				if (state.iterationMetrics.some((m) => m.outputTokens !== null)) tokenParts.push(`${outputTokens} out`);
+				addSummaryEvent(state, false, `Generation completed (${finishReason})${tokenParts.length > 0 ? `: ${tokenParts.join(" / ")} tokens` : ""}`);
+				state.rootSpan.end();
+				recordRunMetrics(state);
+				await emitter.flush([state.rootSpan, ...state.childSpans]);
+			} catch (err) {
+				onError?.(err);
+			}
+		},
+		async onError(ctx, info) {
+			try {
+				const state = states.get(ctx);
+				if (!state) return;
+				states.delete(ctx);
+				const errType = errorTypeName(info.error);
+				const message = errorMessage(info.error);
+				failOpenSpans(state, errType, message);
+				setRootBaseAttributes(state);
+				state.rootSpan.setStatus({
+					code: SpanStatusCode.ERROR,
+					message
+				});
+				state.rootSpan.setAttribute("error.type", errType);
+				state.rootSpan.addEvent("exception", {
+					"exception.type": errType,
+					"exception.message": message,
+					"log.severity_number": SEVERITY_ERROR
+				});
+				addSummaryEvent(state, true, `Generation failed (${errType})`);
+				state.rootSpan.end();
+				recordRunMetrics(state);
+				await emitter.flush([state.rootSpan, ...state.childSpans]);
+			} catch (err) {
+				onError?.(err);
+			}
+		},
+		async onAbort(ctx, info) {
+			try {
+				const state = states.get(ctx);
+				if (!state) return;
+				states.delete(ctx);
+				const message = info.reason ?? "cancelled";
+				failOpenSpans(state, "cancelled", message);
+				setRootBaseAttributes(state);
+				state.rootSpan.setStatus({
+					code: SpanStatusCode.ERROR,
+					message
+				});
+				state.rootSpan.setAttribute("error.type", "cancelled");
+				state.rootSpan.setAttribute("gen_ai.response.finish_reasons", ["cancelled"]);
+				addSummaryEvent(state, true, `Generation cancelled (${message})`);
+				state.rootSpan.end();
+				recordRunMetrics(state);
+				await emitter.flush([state.rootSpan, ...state.childSpans]);
+			} catch (err) {
+				onError?.(err);
+			}
+		}
+	};
+}
+//#endregion
+export { telemetryDev };