@telemetry-dev/sdk 0.1.9 → 0.1.11

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { INVALID_SPAN_CONTEXT, ROOT_CONTEXT, SpanKind, SpanStatusCode, context, defaultTextMapGetter, defaultTextMapSetter, propagation, trace } from "@opentelemetry/api";
+import { INVALID_SPAN_CONTEXT, ROOT_CONTEXT, SpanKind, SpanStatusCode, context, createContextKey, defaultTextMapGetter, defaultTextMapSetter, propagation, trace } from "@opentelemetry/api";
 import { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator, parseTraceParent } from "@opentelemetry/core";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { BatchLogRecordProcessor, LoggerProvider, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs";
 import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
-import { AlsContextManager, BATCHED_METRIC_INTERVAL_MS, DEFAULT_BASE_URL, DEFAULT_BATCH, DORMANT_INTERVAL_MS, DURATION_BUCKETS, OUTPUT_CHUNK_HISTOGRAM, PROPAGATED_KEY, SCOPE_NAME, SCOPE_NAME as SCOPE_NAME$1, SCOPE_VERSION, StampingSpanProcessor, TelemetrySpanProcessor, activeContext, activeContext as activeContext$1, als, createLogExporter, createMetricExporter, createMetricsPipeline, createTraceExporter, diag, jsonAttr, omitUndefined, otlpHeaders, propagateAttributes, propagatedFromContext, reportError, resolveEnv, sessionIdOf, sessionRootTracerProvider, sessionSampler, setLogLevel, withContext, withContext as withContext$1, withSessionParent } from "@telemetry-dev/otel";
+import { AlsContextManager, BATCHED_METRIC_INTERVAL_MS, DEFAULT_BASE_URL, DEFAULT_BATCH, DORMANT_INTERVAL_MS, DURATION_BUCKETS, OUTPUT_CHUNK_HISTOGRAM, PROPAGATED_KEY, SCOPE_NAME, SCOPE_NAME as SCOPE_NAME$1, SCOPE_VERSION, StampingSpanProcessor, TelemetrySpanProcessor, activeContext, activeContext as activeContext$1, als, createExportFailures, createLogExporter, createMetricExporter, createMetricsPipeline, createTraceExporter, diag, jsonAttr, omitUndefined, otlpHeaders, propagateAttributes, propagatedFromContext, reportError, resolveEnv, sessionIdOf, sessionRootTracerProvider, sessionSampler, setLogLevel, sha256, withContext, withContext as withContext$1, withSessionParent } from "@telemetry-dev/otel";
 import { SeverityNumber } from "@opentelemetry/api-logs";
 //#region src/config.ts
 const DEFAULT_MAX_ATTRIBUTE_LENGTH = 65536;
@@ -102,9 +102,11 @@ function initInner(options, overrides) {
 		"deployment.environment.name": config.environment,
 		...config.resourceAttributes
 	});
+	const failures = createExportFailures(config.onError);
 	const transport = {
 		fetchImpl: config.fetchImpl,
-		onError: config.onError
+		onError: config.onError,
+		failures
 	};
 	const headers = config.apiKey ? otlpHeaders(config.apiKey, config.sdkName) : void 0;
 	const spanExporter = overrides?.spanExporter ?? createTraceExporter({
@@ -154,7 +156,7 @@ function initInner(options, overrides) {
 	const ensureLogger = () => {
 		if (!logExporter) return void 0;
 		if (!logs) {
-			const logProcessor = config.exportMode === "immediate" ? new SimpleLogRecordProcessor(logExporter) : new BatchLogRecordProcessor(logExporter);
+			const logProcessor = config.exportMode === "immediate" ? new SimpleLogRecordProcessor({ exporter: logExporter }) : new BatchLogRecordProcessor({ exporter: logExporter });
 			const loggerProvider = new LoggerProvider({
 				resource,
 				logRecordLimits: { attributeValueLengthLimit: backstopLength },
@@ -173,7 +175,7 @@ function initInner(options, overrides) {
 		const parts = [provider[op]()];
 		if (logs) parts.push(logs[op]());
 		if (metrics) parts.push(metrics[op]());
-		return Promise.all(parts).then(() => void 0).catch((error) => reportError(config.onError, error));
+		return Promise.all(parts).then(() => void 0).catch((error) => failures.report(error));
 	};
 	const handoff = (p) => {
 		if (config.waitUntil) {
@@ -356,8 +358,8 @@ function prepareCaptureValue(key, value, cfg) {
 	let masked = value;
 	if (cfg.mask) try {
 		masked = cfg.mask(value, { key });
-	} catch (error) {
-		reportError(cfg.onError, error);
+	} catch {
+		reportError(cfg.onError, /* @__PURE__ */ new Error("mask hook raised; content dropped"));
 		return;
 	}
 	const serialized = jsonAttr(masked);
@@ -544,6 +546,303 @@ const NOOP_SPAN_HANDLE = {
 	end: () => {}
 };
 //#endregion
+//#region src/prompts.ts
+/**
+* Why getPrompt failed. `code` is the code of the API error (`prompt_not_found`,
+* `label_not_found`, `insufficient_scope`, `invalid_api_key`, …), or `missing_api_key`,
+* `timeout`, `network_error`, `invalid_response`, or `type_mismatch`. A response with a different
+* status and no API error gives `http_<status>`, for example `http_302` for a redirect: getPrompt
+* does not go to the location of a redirect.
+*/
+var PromptError = class extends Error {
+	name = "PromptError";
+	constructor(code, message, status, options) {
+		super(message, options);
+		this.code = code;
+		this.status = status;
+	}
+};
+const FETCH_TIMEOUT_MS = 1e4;
+/** How long a failed fetch with no copy answers calls, so that they do not each fetch again. */
+const ERROR_TTL_MS = 1e4;
+const MAX_CACHE_ENTRIES = 1e3;
+const VARIABLE = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
+const MODEL_CALL_OPERATIONS = new Set([
+	"chat",
+	"text_completion",
+	"generate_content"
+]);
+const PROMPT_KEY = createContextKey("telemetry.dev prompt");
+const cache = /* @__PURE__ */ new Map();
+const compiledVariables = /* @__PURE__ */ new WeakMap();
+async function getPrompt(name, options = {}) {
+	const type = options.type ?? "chat";
+	checkOptions(name, options, type);
+	const core = currentClient().core;
+	const env = resolveEnv();
+	const apiKey = options.apiKey ?? core?.config.apiKey ?? env.TELEMETRY_DEV_API_KEY;
+	const baseUrl = (options.baseUrl || core?.config.baseUrl || env.TELEMETRY_DEV_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, "");
+	const label = options.version === void 0 ? options.label ?? "production" : null;
+	const onError = core?.config.onError;
+	let response;
+	try {
+		if (!apiKey) throw new PromptError("missing_api_key", "No API key: pass apiKey or set TELEMETRY_DEV_API_KEY");
+		const url = new URL(`${baseUrl}/v1/prompts`);
+		url.searchParams.set("name", name);
+		if (label === null) url.searchParams.set("version", String(options.version));
+		else url.searchParams.set("label", label);
+		response = await load([
+			baseUrl,
+			keyFingerprint(apiKey),
+			name,
+			label === null ? `version:${options.version}` : `label:${label}`
+		].join("\0"), (options.cacheTtlSeconds ?? 60) * 1e3, () => fetchPrompt(url, {
+			authorization: `Bearer ${apiKey}`,
+			"x-telemetry-dev-sdk": core?.config.sdkName ?? "@telemetry-dev/sdk"
+		}, options.fetch ?? core?.config.fetchImpl ?? globalThis.fetch), onError);
+	} catch (error) {
+		if (options.fallback === void 0) throw error;
+		reportError(onError, error);
+		return createPrompt({
+			name,
+			type,
+			label,
+			version: null,
+			isFallback: true,
+			content: {
+				messages: type === "chat" ? options.fallback : [],
+				text: type === "text" ? options.fallback : null,
+				model: null,
+				parameters: {},
+				tools: [],
+				responseFormat: { type: "text" }
+			}
+		});
+	}
+	if (response.type !== type) throw new PromptError("type_mismatch", `${name} is a ${response.type} prompt; pass type: "${response.type}"`);
+	const chosen = response.rollout && inRollout(response) ? response.rollout : response;
+	return createPrompt({
+		name: response.name,
+		type,
+		label: response.label,
+		version: chosen.version,
+		isFallback: false,
+		content: chosen
+	});
+}
+/**
+* Runs `fn` with `prompt` as the prompt of each model call (generation span) that starts inside
+* it: the spans get `td.prompt.name`, `td.prompt.version`, `td.prompt.label`, and, when input
+* capture is on, `td.prompt.variables`. The variables are those of the last `compile()` of this
+* prompt object before withPrompt starts, or of the last `compile()` inside `fn`, so a compile in
+* another task does not change them once withPrompt runs.
+*/
+function withPrompt(prompt, fn) {
+	const scope = {
+		prompt,
+		variables: compiledVariables.get(prompt)
+	};
+	return withContext$1(activeContext$1().setValue(PROMPT_KEY, scope), fn);
+}
+/** The td.prompt.* attributes for a span with this operation that starts in `ctx`. */
+function promptAttributes(ctx, operation, capture) {
+	if (!MODEL_CALL_OPERATIONS.has(operation)) return void 0;
+	const scope = ctx.getValue(PROMPT_KEY) ?? activeContext$1().getValue(PROMPT_KEY);
+	if (!scope) return void 0;
+	const { prompt, variables } = scope;
+	return omitUndefined({
+		"td.prompt.name": prompt.name,
+		"td.prompt.version": prompt.version ?? void 0,
+		"td.prompt.label": prompt.label ?? void 0,
+		"td.prompt.variables": variables !== void 0 && capture.captureInput ? prepareCaptureValue("td.prompt.variables", variables, capture) : void 0
+	});
+}
+function checkOptions(name, options, type) {
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("name must be a non-empty string");
+	if (type !== "chat" && type !== "text") throw new TypeError("type must be \"chat\" or \"text\"");
+	if (options.label !== void 0 && options.version !== void 0) throw new TypeError("Pass label or version, not both");
+	if (options.version !== void 0 && (!Number.isSafeInteger(options.version) || options.version < 1)) throw new RangeError("version must be a positive integer");
+	const ttl = options.cacheTtlSeconds;
+	if (ttl !== void 0 && !(Number.isFinite(ttl) && ttl >= 0)) throw new RangeError("cacheTtlSeconds must be a non-negative number");
+	if (options.fallback !== void 0 && (type === "chat" ? !Array.isArray(options.fallback) : typeof options.fallback !== "string")) throw new TypeError(type === "chat" ? "fallback must be a list of messages" : "fallback must be a string");
+}
+/**
+* Returns the kept copy of a prompt, and fetches a new copy in the background when it is older
+* than the TTL. Only a call with no copy waits for a fetch. A failed fetch with no copy fails the
+* calls of the next ERROR_TTL_MS (or the TTL, if it is shorter) without a fetch.
+*/
+async function load(key, ttlMs, fetchResponse, onError) {
+	let entry = cache.get(key);
+	if (!entry) {
+		if (cache.size >= MAX_CACHE_ENTRIES) cache.delete(cache.keys().next().value);
+		entry = { checkedAt: 0 };
+		cache.set(key, entry);
+	}
+	const fresh = Date.now() < entry.checkedAt + (entry.response ? ttlMs : Math.min(ttlMs, ERROR_TTL_MS));
+	if (entry.response) {
+		if (!fresh) entry.pending ??= refresh(entry, fetchResponse, onError);
+		return entry.response;
+	}
+	if (fresh) throw entry.error;
+	return entry.pending ??= refresh(entry, fetchResponse, onError);
+}
+function refresh(entry, fetchResponse, onError) {
+	return fetchResponse().then((response) => {
+		entry.response = response;
+		return response;
+	}, (error) => {
+		if (!entry.response) {
+			entry.error = error;
+			throw error;
+		}
+		reportError(onError, error);
+		return entry.response;
+	}).finally(() => {
+		entry.checkedAt = Date.now();
+		entry.pending = void 0;
+	});
+}
+async function fetchPrompt(url, headers, fetchImpl) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+	try {
+		const res = await fetchImpl(url, {
+			method: "GET",
+			headers,
+			signal: controller.signal,
+			redirect: "manual"
+		});
+		const body = await res.json().catch(() => void 0);
+		if (!res.ok) {
+			const error = isRecord(body) && isRecord(body.error) ? body.error : {};
+			throw new PromptError(typeof error.code === "string" ? error.code : `http_${res.status}`, typeof error.message === "string" ? error.message : `telemetry.dev returned ${res.status}`, res.status);
+		}
+		const response = parseResponse(body);
+		if (!response) throw new PromptError("invalid_response", "telemetry.dev returned a prompt it cannot read");
+		return response;
+	} catch (error) {
+		if (controller.signal.aborted) throw new PromptError("timeout", `Fetching the prompt took more than ${FETCH_TIMEOUT_MS} ms`);
+		if (error instanceof PromptError) throw error;
+		throw new PromptError("network_error", "Could not reach telemetry.dev", void 0, { cause: error });
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function createPrompt(input) {
+	const { content, type } = input;
+	const prompt = Object.freeze({
+		name: input.name,
+		type,
+		version: input.version,
+		label: input.label,
+		messages: content.messages,
+		text: content.text,
+		model: content.model,
+		parameters: content.parameters,
+		tools: content.tools,
+		responseFormat: content.responseFormat,
+		isFallback: input.isFallback,
+		compile(variables = {}) {
+			compiledVariables.set(prompt, variables);
+			const scope = activeContext$1().getValue(PROMPT_KEY);
+			if (scope?.prompt === prompt) scope.variables = variables;
+			return type === "chat" ? compileMessages(content.messages, variables) : fill(content.text ?? "", variables);
+		}
+	});
+	return prompt;
+}
+function compileMessages(messages, variables) {
+	return messages.flatMap((message) => {
+		if (message.role !== "placeholder") return [{
+			role: message.role,
+			content: fill(message.content, variables)
+		}];
+		const value = Object.hasOwn(variables, message.name) ? variables[message.name] : void 0;
+		if (value == null) return [];
+		if (!Array.isArray(value)) throw new TypeError(`The ${message.name} variable must be a list of messages`);
+		return value;
+	});
+}
+function fill(text, variables) {
+	return text.replace(VARIABLE, (_tag, name) => {
+		const value = Object.hasOwn(variables, name) ? variables[name] : void 0;
+		if (value == null) return "";
+		return typeof value === "string" ? value : jsonAttr(value) ?? "";
+	});
+}
+function inRollout(response) {
+	const sessionId = sessionIdOf(activeContext$1()) ?? currentClient().core?.config.processSessionId;
+	return (sessionId === void 0 ? Math.floor(Math.random() * 100) : fnv1a(`${response.name}:${response.label}:${sessionId}`) % 100) < response.rollout.percent;
+}
+function fnv1a(text) {
+	let hash = 2166136261;
+	for (const byte of new TextEncoder().encode(text)) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+	return hash;
+}
+function keyFingerprint(apiKey) {
+	const digest = sha256(new TextEncoder().encode(apiKey)).subarray(0, 16);
+	return Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function parseResponse(body) {
+	if (!isRecord(body)) return void 0;
+	const { name, type, label, version, rollout } = body;
+	if (typeof name !== "string" || type !== "chat" && type !== "text" || label !== null && typeof label !== "string" || !isVersion(version)) return;
+	const content = parseContent(body, type);
+	if (!content) return void 0;
+	if (rollout == null) return deepFreeze({
+		name,
+		type,
+		label,
+		version,
+		...content,
+		rollout: null
+	});
+	if (!isRecord(rollout) || !isVersion(rollout.version) || !Number.isInteger(rollout.percent) || rollout.percent < 0 || rollout.percent > 100) return;
+	const rolloutContent = parseContent(rollout, type);
+	if (!rolloutContent) return void 0;
+	return deepFreeze({
+		name,
+		type,
+		label,
+		version,
+		...content,
+		rollout: {
+			percent: rollout.percent,
+			version: rollout.version,
+			...rolloutContent
+		}
+	});
+}
+function parseContent(value, type) {
+	const { messages, text, model, parameters, tools, responseFormat } = value;
+	if (!(type === "chat" ? Array.isArray(messages) && messages.every(isPromptMessage) : typeof text === "string") || !isRecord(model) || typeof model.provider !== "string" || typeof model.name !== "string" || !isRecord(parameters) || !Array.isArray(tools) || !tools.every((tool) => isRecord(tool) && typeof tool.name === "string") || !isRecord(responseFormat) || typeof responseFormat.type !== "string") return;
+	return {
+		messages: type === "chat" ? messages : [],
+		text: type === "text" ? text : null,
+		model,
+		parameters,
+		tools,
+		responseFormat
+	};
+}
+function isPromptMessage(value) {
+	if (!isRecord(value)) return false;
+	return value.role === "placeholder" ? typeof value.name === "string" : (value.role === "system" || value.role === "user" || value.role === "assistant") && typeof value.content === "string";
+}
+function isVersion(value) {
+	return Number.isSafeInteger(value) && value >= 1;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepFreeze(value) {
+	if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const item of Object.values(value)) deepFreeze(item);
+	}
+	return value;
+}
+//#endregion
 //#region src/span.ts
 const SPAN_META = /* @__PURE__ */ new WeakMap();
 const SEVERITY_ERROR = 17;
@@ -577,16 +876,16 @@ function resolveParent(parent) {
 	if (isContext(ref)) return withAmbientPropagated(ref);
 	return trace.setSpanContext(base, ref);
 }
-function applyError(span, error) {
+function applyError(span, error, capture) {
 	const err = error instanceof Error ? error : void 0;
 	const errorType = err === void 0 ? "Error" : err.name !== "Error" && err.name.length > 0 ? err.name : (err.constructor?.name ?? "Error") || "Error";
-	const message = err?.message ?? String(error);
 	span.setStatus({ code: SpanStatusCode.ERROR });
 	span.setAttribute("error.type", errorType);
+	const captureContent = capture.captureInput && capture.captureOutput;
 	span.addEvent("exception", omitUndefined({
 		"exception.type": errorType,
-		"exception.message": message,
-		"exception.stacktrace": err?.stack,
+		"exception.message": captureContent ? prepareCaptureValue("exception.message", err?.message ?? String(error), capture) : void 0,
+		"exception.stacktrace": captureContent && err?.stack !== void 0 ? prepareCaptureValue("exception.stacktrace", err.stack, capture) : void 0,
 		"log.severity_number": SEVERITY_ERROR
 	}));
 }
@@ -594,7 +893,7 @@ function applyFields(span, meta, fields) {
 	if (fields.name) span.updateName(fields.name);
 	const attrs = fieldsToAttributes(fields, meta.type, meta.capture);
 	if (Object.keys(attrs).length > 0) span.setAttributes(attrs);
-	if (fields.error !== void 0) applyError(span, fields.error);
+	if (fields.error !== void 0) applyError(span, fields.error, meta.capture);
 }
 function metaFor(core, options) {
 	const cfg = core.config;
@@ -619,6 +918,7 @@ function createSpanHandle(core, name, options = {}) {
 		"gen_ai.conversation.id": sessionId
 	}), sessionId, core.config.apiKey);
 	const attrs = fieldsToAttributes(options, meta.type, meta.capture);
+	const operation = attrs["gen_ai.operation.name"] ?? SPAN_TYPE_OPERATIONS[meta.type];
 	const span = core.tracer.startSpan(name, {
 		kind: options.kind ?? SpanKind.INTERNAL,
 		startTime: options.startTime,
@@ -626,13 +926,14 @@ function createSpanHandle(core, name, options = {}) {
 		attributes: {
 			"gen_ai.operation.name": SPAN_TYPE_OPERATIONS[meta.type],
 			...propagatedFromContext(parentCtx),
+			...promptAttributes(parentCtx, operation, meta.capture),
 			...attrs
 		}
 	}, parentCtx);
 	SPAN_META.set(span, meta);
 	if (Object.keys(attrs).length > 0) span.setAttributes(attrs);
 	if (options.name) span.updateName(options.name);
-	if (options.error !== void 0) applyError(span, options.error);
+	if (options.error !== void 0) applyError(span, options.error, meta.capture);
 	const spanContext = span.spanContext();
 	let previousOutputChunkTime;
 	const flags = (spanContext.traceFlags & 255).toString(16).padStart(2, "0");
@@ -813,4 +1114,4 @@ function observe(fn, options) {
 	return wrapped;
 }
 //#endregion
-export { SCOPE_NAME, TelemetrySpanProcessor, activeContext, boundedCapture, boundedCaptureDetails, captureEnabled, captureMasked, extractW3cContext, flush, getTraceparent, init, injectW3cContext, log, observe, propagateAttributes, shutdown, startActiveSpan, startSpan, updateActiveSpan, withContext };
+export { PromptError, SCOPE_NAME, TelemetrySpanProcessor, activeContext, boundedCapture, boundedCaptureDetails, captureEnabled, captureMasked, extractW3cContext, flush, getPrompt, getTraceparent, init, injectW3cContext, log, observe, propagateAttributes, shutdown, startActiveSpan, startSpan, updateActiveSpan, withContext, withPrompt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telemetry-dev/sdk",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Pure TypeScript SDK for telemetry.dev: LLM traces, logs, and GenAI metrics on OpenTelemetry, for Node and edge runtimes.",
   "keywords": [
     "genai",
@@ -36,13 +36,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@opentelemetry/api-logs": "^0.218.0",
-    "@opentelemetry/core": "^2.7.1",
-    "@opentelemetry/resources": "^2.7.1",
-    "@opentelemetry/sdk-logs": "^0.218.0",
-    "@opentelemetry/sdk-metrics": "^2.7.1",
-    "@opentelemetry/sdk-trace-base": "^2.7.1",
-    "@telemetry-dev/otel": "^0.1.6"
+    "@opentelemetry/api-logs": "^0.223.0",
+    "@opentelemetry/core": "^2.12.0",
+    "@opentelemetry/resources": "^2.12.0",
+    "@opentelemetry/sdk-logs": "^0.223.0",
+    "@opentelemetry/sdk-metrics": "^2.12.0",
+    "@opentelemetry/sdk-trace-base": "^2.12.0",
+    "@telemetry-dev/otel": "^0.1.7"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",

package/src/capture.ts

@@ -270,8 +270,9 @@ export function prepareCaptureValue(
   if (cfg.mask) {
     try {
       masked = cfg.mask(value, { key });
-    } catch (error) {
-      reportError(cfg.onError, error);
+    } catch {
+      // Hook errors can contain the unmasked value or chain the application exception.
+      reportError(cfg.onError, new Error("mask hook raised; content dropped"));
 
       return undefined;
     }

package/src/client.ts

@@ -19,6 +19,7 @@ import {
   als,
   AlsContextManager,
   BATCHED_METRIC_INTERVAL_MS,
+  createExportFailures,
   createLogExporter,
   createMetricExporter,
   createMetricsPipeline,
@@ -156,7 +157,10 @@ function initInner(options?: TelemetryOptions, overrides?: ClientOverrides): Tel
     ...config.resourceAttributes,
   });
 
-  const transport: Transport = { fetchImpl: config.fetchImpl, onError: config.onError };
+  // A failed flush repeats the failure of its export, so the flush and the exporters share one
+  // failure state.
+  const failures = createExportFailures(config.onError);
+  const transport: Transport = { fetchImpl: config.fetchImpl, onError: config.onError, failures };
   const headers = config.apiKey ? otlpHeaders(config.apiKey, config.sdkName) : undefined;
 
   const spanExporter =
@@ -244,8 +248,8 @@ function initInner(options?: TelemetryOptions, overrides?: ClientOverrides): Tel
     if (!logs) {
       const logProcessor =
         config.exportMode === "immediate"
-          ? new SimpleLogRecordProcessor(logExporter)
-          : new BatchLogRecordProcessor(logExporter);
+          ? new SimpleLogRecordProcessor({ exporter: logExporter })
+          : new BatchLogRecordProcessor({ exporter: logExporter });
 
       const loggerProvider = new LoggerProvider({
         resource,
@@ -274,7 +278,7 @@ function initInner(options?: TelemetryOptions, overrides?: ClientOverrides): Tel
 
     return Promise.all(parts)
       .then(() => undefined)
-      .catch((error: Error) => reportError(config.onError, error));
+      .catch((error: Error) => failures.report(error));
   };
 
   const handoff = (p: Promise<void>): Promise<void> => {

package/src/config.ts

@@ -14,15 +14,15 @@ export type { BatchOptions, ExportMode, LogLevel, SdkLogLevel } from "@telemetry
 
 /**
  * Redaction hook applied to captured content (input/output, log messages and attributes, and
- * content passed to `SpanHandle.serializeContent`) before JSON stringification. Not applied to
- * metadata or raw attributes.
+ * content passed to `SpanHandle.serializeContent`), including exception messages/stacks, before
+ * JSON stringification. Not applied to metadata or raw attributes.
  */
 export type MaskFn<T = unknown> = (value: T, ctx: { key: string }) => T;
 
 export interface TelemetryOptions {
   /** telemetry.dev ingest key (`td_live_…`). Falls back to `TELEMETRY_DEV_API_KEY`. When absent the SDK is a no-op. */
   apiKey?: string;
-  /** Ingest base URL. Falls back to `TELEMETRY_DEV_BASE_URL`, then `https://ingest.telemetry.dev`. */
+  /** Base URL for telemetry export and getPrompt. Falls back to `TELEMETRY_DEV_BASE_URL`, then `https://ingest.telemetry.dev`. */
   baseUrl?: string;
   /** Deployment environment label. Falls back to `TELEMETRY_DEV_ENVIRONMENT`, then `production`. */
   environment?: string;
@@ -38,9 +38,9 @@ export interface TelemetryOptions {
   exportMode?: ExportMode;
   /** OTel sampling policy. Defaults to OTEL_TRACES_SAMPLER / OTEL_TRACES_SAMPLER_ARG. */
   sampler?: Sampler;
-  /** Capture span inputs (args, prompts) by default. Default true. */
+  /** Capture span inputs (args, prompts). False also omits exception messages/stacks. Default true. */
   captureInput?: boolean;
-  /** Capture span outputs (results, completions) by default. Default true. */
+  /** Capture span outputs (results, completions). False also omits exception messages/stacks. Default true. */
   captureOutput?: boolean;
   /** Redaction hook run on captured content before stringify/truncate. */
   mask?: MaskFn;
@@ -63,7 +63,7 @@ export interface TelemetryOptions {
   fetch?: typeof fetch;
   /** Serverless extender (e.g. Cloudflare `ctx.waitUntil`). When provided, `flush()` does not await exports. */
   waitUntil?: (p: Promise<unknown>) => void;
-  /** Receives errors raised while emitting telemetry; repeated instrumentation failures from one stream may be coalesced into one report. The SDK never throws into user code. */
+  /** Receives errors raised while emitting telemetry; repeated instrumentation failures from one stream may be coalesced into one report. A series of failed exports is reported once, and the next failure after an export reaches the ingest is reported again. The SDK never throws into user code. */
   onError?: (cause: Error) => void;
   /** Header value for a custom telemetry.dev integration. */
   sdkName?: string;

package/src/index.ts

@@ -46,6 +46,25 @@ export { log, type LogOptions } from "./logs.ts";
 
 export { observe, type ObserveOptions } from "./observe.ts";
 
+export {
+  type ChatMessage,
+  type ChatPrompt,
+  type GetChatPromptOptions,
+  getPrompt,
+  type GetPromptOptions,
+  type GetTextPromptOptions,
+  type Prompt,
+  PromptError,
+  type PromptMessage,
+  type PromptModel,
+  type PromptParameters,
+  type PromptResponseFormat,
+  type PromptTool,
+  type PromptVariables,
+  type TextPrompt,
+  withPrompt,
+} from "./prompts.ts";
+
 export {
   activeContext,
   extractW3cContext,