@telemetry-dev/anthropic 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 telemetry.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# @telemetry-dev/anthropic
+
+Anthropic SDK instrumentation for telemetry.dev. It wraps the Anthropic Messages API and emits OpenTelemetry GenAI spans through `@telemetry-dev/sdk`.
+
+## Install
+
+```sh
+pnpm add @telemetry-dev/sdk @telemetry-dev/anthropic @anthropic-ai/sdk
+```
+
+Set `TELEMETRY_DEV_API_KEY` for telemetry export and `ANTHROPIC_API_KEY` for Anthropic.
+
+## Per-client wrapping
+
+```ts
+import Anthropic from "@anthropic-ai/sdk";
+import { init, shutdown } from "@telemetry-dev/sdk";
+import { wrapAnthropic } from "@telemetry-dev/anthropic";
+
+init({ serviceName: "anthropic-worker" });
+
+const anthropic = wrapAnthropic(new Anthropic());
+const response = await anthropic.messages.create({
+  model: "claude-sonnet-4-6",
+  max_tokens: 256,
+  messages: [{ role: "user", content: "Say hello." }],
+});
+
+await shutdown();
+```
+
+`wrapAnthropic(client)` mutates and returns that client. It is idempotent.
+
+## Global instrumentation
+
+```ts
+import { instrumentAnthropic, uninstrumentAnthropic } from "@telemetry-dev/anthropic";
+
+instrumentAnthropic();
+// new Anthropic().messages.create(...) is now traced.
+uninstrumentAnthropic();
+```
+
+Global instrumentation patches `Messages.prototype.create`; call it once during process startup.
+
+## Instrumented surfaces
+
+- `client.messages.create(...)`, including `stream: true` responses.
+- `client.messages.stream(...)` when the SDK helper is used.
+- Anthropic, Bedrock, and Vertex clients. Provider attributes are emitted as `anthropic`, `aws.bedrock`, or `gcp.vertex_ai`.
+
+Captured request fields include model, max tokens, temperature, top-p, stop sequences, system instructions, tools, and messages. Captured response fields include model, finish reason, content blocks, message id, and token usage including cache and thinking token details when Anthropic returns them.
+
+## Streaming behavior
+
+Streaming spans start when the request is made and end when the stream is consumed, closes early, or errors. The integration aggregates text, tool input JSON fragments, thinking deltas, signatures, usage, and the latest known stop reason before ending the span.
+
+## Limitations
+
+- `beta.messages`, `messages.countTokens`, and other non-Messages surfaces are not instrumented.
+- `with_raw_response` and `with_streaming_response` helper namespaces are not patched directly.
+- If application code never consumes or closes a stream, the span cannot finish until the stream is finalized by the runtime.

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import { SpanFields, SpanHandle, StartSpanOptions } from "@telemetry-dev/sdk";
+
+//#region src/index.d.ts
+interface AnthropicClient {
+  messages: object;
+}
+declare function wrapAnthropic<T extends AnthropicClient>(client: T): T;
+declare function instrumentAnthropic(): void;
+declare function uninstrumentAnthropic(): void;
+//#endregion
+export { type SpanFields, type SpanHandle, type StartSpanOptions, instrumentAnthropic, uninstrumentAnthropic, wrapAnthropic };

package/dist/index.mjs

@@ -0,0 +1,430 @@
+import { startSpan } from "@telemetry-dev/sdk";
+import { Stream } from "@anthropic-ai/sdk/core/streaming";
+import { Messages } from "@anthropic-ai/sdk/resources/messages";
+//#region src/index.ts
+const WRAPPED = Symbol("telemetry.dev.anthropic.wrapped");
+const WRAPPED_ORIGINAL = Symbol("telemetry.dev.anthropic.original");
+const wrappedClients = /* @__PURE__ */ new WeakSet();
+function asRecord(value) {
+	return value !== null && typeof value === "object" ? value : void 0;
+}
+function readString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function readNumber(value) {
+	return typeof value === "number" ? value : void 0;
+}
+function compactUsage(usage) {
+	if (!usage) return void 0;
+	return Object.values(usage).some((value) => value !== void 0) ? usage : void 0;
+}
+function stopSequences(value) {
+	if (typeof value === "string") return [value];
+	if (!Array.isArray(value)) return void 0;
+	const strings = value.filter((item) => typeof item === "string");
+	return strings.length > 0 ? strings : void 0;
+}
+function messagesRequest(body) {
+	const model = readString(body.model);
+	const input = body.tools !== void 0 || body.tool_choice !== void 0 ? {
+		messages: body.messages,
+		tools: body.tools,
+		tool_choice: body.tool_choice
+	} : body.messages;
+	return {
+		name: `chat ${model ?? "unknown"}`,
+		fields: {
+			type: "generation",
+			model,
+			input,
+			systemInstructions: body.system,
+			temperature: readNumber(body.temperature),
+			topP: readNumber(body.top_p),
+			topK: readNumber(body.top_k),
+			maxTokens: readNumber(body.max_tokens),
+			stopSequences: stopSequences(body.stop_sequences)
+		}
+	};
+}
+function messagesUsage(usage) {
+	const u = asRecord(usage);
+	const outputDetails = asRecord(u?.output_tokens_details);
+	return compactUsage({
+		inputTokens: readNumber(u?.input_tokens),
+		outputTokens: readNumber(u?.output_tokens),
+		cacheReadInputTokens: readNumber(u?.cache_read_input_tokens),
+		cacheCreationInputTokens: readNumber(u?.cache_creation_input_tokens),
+		reasoningOutputTokens: readNumber(outputDetails?.thinking_tokens)
+	});
+}
+function mergeUsage(current, incoming) {
+	if (!incoming) return current;
+	return compactUsage({
+		inputTokens: incoming.inputTokens ?? current?.inputTokens,
+		outputTokens: incoming.outputTokens ?? current?.outputTokens,
+		cacheReadInputTokens: incoming.cacheReadInputTokens ?? current?.cacheReadInputTokens,
+		cacheCreationInputTokens: incoming.cacheCreationInputTokens ?? current?.cacheCreationInputTokens,
+		reasoningOutputTokens: incoming.reasoningOutputTokens ?? current?.reasoningOutputTokens
+	});
+}
+function messagesResponse(response) {
+	const r = asRecord(response) ?? {};
+	const role = readString(r.role) ?? "assistant";
+	return {
+		responseModel: readString(r.model),
+		responseId: readString(r.id),
+		finishReason: readString(r.stop_reason),
+		output: r.content !== void 0 ? [{
+			role,
+			content: r.content
+		}] : void 0,
+		usage: messagesUsage(r.usage)
+	};
+}
+function constructorName(value) {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return;
+	const ctor = value.constructor;
+	return typeof ctor === "function" ? ctor.name : void 0;
+}
+function providerForClient(client) {
+	switch (constructorName(client)) {
+		case "AnthropicBedrock":
+		case "AsyncAnthropicBedrock": return "aws.bedrock";
+		case "AnthropicVertex":
+		case "AsyncAnthropicVertex": return "gcp.vertex_ai";
+		default: return "anthropic";
+	}
+}
+function providerForResource(resource) {
+	return providerForClient(asRecord(resource)?._client);
+}
+function isWrapped(fn) {
+	if (typeof fn !== "function") return false;
+	return fn[WRAPPED] === true;
+}
+function markWrapped(fn, original) {
+	Object.defineProperty(fn, WRAPPED, { value: true });
+	Object.defineProperty(fn, WRAPPED_ORIGINAL, { value: original });
+	return fn;
+}
+function endOnce(span) {
+	let ended = false;
+	return (fields) => {
+		if (ended) return;
+		ended = true;
+		span.end(fields);
+	};
+}
+function mapRawResponse(response) {
+	const requestId = response.headers.get("request-id");
+	return {
+		...requestId ? { responseId: requestId } : {},
+		attributes: { "http.response.status_code": response.status }
+	};
+}
+function finalizeParsedValue(value, ctx) {
+	if (ctx.streaming) {
+		const wrapped = wrapStream(value, ctx.span, ctx.startedAt, ctx.end);
+		if (wrapped !== value) return wrapped;
+	}
+	ctx.end(ctx.mapResponse(value));
+	return value;
+}
+function rejectMissing(method) {
+	return Promise.reject(/* @__PURE__ */ new TypeError(`wrapped result has no ${method}`));
+}
+function makeTracedPromise(inner, ctx) {
+	const source = inner;
+	const originalThen = source.then.bind(source);
+	const originalAsResponse = source.asResponse?.bind(source);
+	const originalThenUnwrap = source._thenUnwrap?.bind(source);
+	const handleError = (error) => {
+		ctx.end({ error });
+		throw error;
+	};
+	const onParsed = (value) => finalizeParsedValue(value, ctx);
+	const parsed = () => originalThen(onParsed, handleError);
+	const traced = constructorName(source) === "APIPromise" ? source : new Promise((resolve, reject) => {
+		parsed().then(resolve, reject);
+	});
+	if (traced === source) {
+		traced.then = ((onfulfilled, onrejected) => parsed().then(onfulfilled, onrejected));
+		traced.catch = ((onrejected) => parsed().catch(onrejected));
+		traced.finally = ((onfinally) => parsed().finally(onfinally));
+	}
+	traced.asResponse = () => {
+		if (!originalAsResponse) return rejectMissing("asResponse");
+		return originalAsResponse().then((response) => {
+			ctx.end(mapRawResponse(response));
+			return response;
+		}, handleError);
+	};
+	traced.withResponse = () => {
+		if (!originalAsResponse) return rejectMissing("withResponse");
+		return Promise.all([parsed(), originalAsResponse()]).then(([data, response]) => ({
+			data,
+			response,
+			request_id: response.headers.get("request-id")
+		}), handleError);
+	};
+	traced._thenUnwrap = (transform) => {
+		if (!originalThenUnwrap) return rejectMissing("_thenUnwrap");
+		return makeTracedPromise(originalThenUnwrap(transform), ctx);
+	};
+	return traced;
+}
+function isToolBlockState(value) {
+	return "data" in value && "inputJson" in value;
+}
+function setFirstStreamUpdate(span, startedAt, sawFirst, fields) {
+	if (sawFirst.value) return;
+	sawFirst.value = true;
+	span.update({
+		timeToFirstChunkMs: Date.now() - startedAt,
+		responseId: fields.responseId,
+		responseModel: fields.responseModel
+	});
+}
+function parseToolInput(inputJson) {
+	if (inputJson.length === 0) return {};
+	try {
+		return JSON.parse(inputJson);
+	} catch {
+		return inputJson;
+	}
+}
+function finalizeBlock(block) {
+	if (!isToolBlockState(block)) return block;
+	const input = parseToolInput(block.inputJson);
+	if (block.data.input === void 0) return {
+		...block.data,
+		input
+	};
+	if (block.inputJson.length === 0) return block.data;
+	const existingInput = asRecord(block.data.input);
+	const parsedInput = asRecord(input);
+	return {
+		...block.data,
+		input: existingInput && parsedInput && !Array.isArray(existingInput) && !Array.isArray(parsedInput) ? {
+			...existingInput,
+			...parsedInput
+		} : input
+	};
+}
+function streamOutput(state) {
+	if (state.blocks.size === 0) return void 0;
+	return [{
+		role: "assistant",
+		content: [...state.blocks.entries()].sort(([left], [right]) => left - right).map(([, block]) => finalizeBlock(block))
+	}];
+}
+function streamPartialFields(state) {
+	return {
+		output: streamOutput(state),
+		usage: state.usage,
+		finishReason: state.finishReason
+	};
+}
+function recordContentBlockStart(event, state) {
+	const index = readNumber(event.index) ?? state.blocks.size;
+	const contentBlock = asRecord(event.content_block) ?? {};
+	const type = readString(contentBlock.type);
+	if (type === "text") {
+		state.blocks.set(index, {
+			type,
+			text: readString(contentBlock.text) ?? ""
+		});
+		return;
+	}
+	if (type === "tool_use" || type === "server_tool_use") {
+		const data = {
+			...contentBlock,
+			type
+		};
+		state.blocks.set(index, {
+			data,
+			inputJson: ""
+		});
+		return;
+	}
+	if (type === "thinking") {
+		state.blocks.set(index, {
+			type,
+			thinking: readString(contentBlock.thinking) ?? ""
+		});
+		return;
+	}
+	state.blocks.set(index, { ...contentBlock });
+}
+function blockForDelta(index, deltaType, state) {
+	const existing = state.blocks.get(index);
+	if (existing) return existing;
+	if (deltaType === "input_json_delta") {
+		const block = {
+			data: { type: "tool_use" },
+			inputJson: ""
+		};
+		state.blocks.set(index, block);
+		return block;
+	}
+	const block = deltaType === "thinking_delta" ? {
+		type: "thinking",
+		thinking: ""
+	} : {
+		type: "text",
+		text: ""
+	};
+	state.blocks.set(index, block);
+	return block;
+}
+function appendStringField(target, key, value) {
+	if (value === void 0) return;
+	target[key] = `${readString(target[key]) ?? ""}${value}`;
+}
+function appendArrayField(target, key, value) {
+	if (value === void 0) return;
+	target[key] = [...Array.isArray(target[key]) ? target[key] : [], value];
+}
+function recordContentBlockDelta(event, state) {
+	const index = readNumber(event.index) ?? 0;
+	const delta = asRecord(event.delta) ?? {};
+	const deltaType = readString(delta.type);
+	const block = blockForDelta(index, deltaType, state);
+	if (deltaType === "input_json_delta") {
+		if (isToolBlockState(block)) block.inputJson += readString(delta.partial_json) ?? "";
+		return;
+	}
+	const data = isToolBlockState(block) ? block.data : block;
+	if (deltaType === "text_delta") appendStringField(data, "text", readString(delta.text));
+	if (deltaType === "citations_delta") appendArrayField(data, "citations", delta.citation);
+	if (deltaType === "thinking_delta") appendStringField(data, "thinking", readString(delta.thinking));
+	if (deltaType === "signature_delta" && delta.signature !== void 0) data.signature = delta.signature;
+}
+function recordStreamEvent(event, state) {
+	const e = asRecord(event) ?? {};
+	const type = readString(e.type);
+	const fields = {};
+	if (type === "message_start") {
+		const message = asRecord(e.message) ?? {};
+		fields.responseId = readString(message.id);
+		fields.responseModel = readString(message.model);
+		state.usage = mergeUsage(state.usage, messagesUsage(message.usage));
+	}
+	if (type === "content_block_start") recordContentBlockStart(e, state);
+	if (type === "content_block_delta") recordContentBlockDelta(e, state);
+	if (type === "message_delta") {
+		state.finishReason = readString((asRecord(e.delta) ?? {}).stop_reason) ?? state.finishReason;
+		state.usage = mergeUsage(state.usage, messagesUsage(e.usage));
+	}
+	return fields;
+}
+function isStreamLike(value) {
+	if (value === null || typeof value !== "object") return false;
+	const stream = value;
+	const signal = asRecord(stream.controller)?.signal;
+	return typeof stream[Symbol.asyncIterator] === "function" && signal !== void 0 && typeof asRecord(signal)?.addEventListener === "function";
+}
+function createObservedMessagesStream(source, span, startedAt, end) {
+	const state = { blocks: /* @__PURE__ */ new Map() };
+	let consumed = false;
+	const signal = source.controller.signal;
+	const endAborted = () => {
+		if (consumed) return;
+		end({
+			...streamPartialFields(state),
+			error: signal.reason ?? /* @__PURE__ */ new Error("Request aborted")
+		});
+	};
+	if (signal.aborted) endAborted();
+	else signal.addEventListener("abort", endAborted, { once: true });
+	async function* iterator() {
+		consumed = true;
+		const sawFirst = { value: false };
+		let terminalError;
+		try {
+			for await (const event of source) {
+				setFirstStreamUpdate(span, startedAt, sawFirst, recordStreamEvent(event, state));
+				yield event;
+			}
+		} catch (error) {
+			terminalError = error;
+			throw error;
+		} finally {
+			end({
+				...streamPartialFields(state),
+				...terminalError !== void 0 ? { error: terminalError } : {}
+			});
+		}
+	}
+	return new Stream(() => iterator(), source.controller);
+}
+function wrapStream(value, span, startedAt, end) {
+	if (!isStreamLike(value)) return value;
+	return createObservedMessagesStream(value, span, startedAt, end);
+}
+function wrapCreate(original, mapRequest, mapResponse, provider) {
+	if (isWrapped(original)) return original;
+	const wrapped = function(...args) {
+		const body = asRecord(args[0]) ?? {};
+		const streaming = body.stream === true;
+		const request = mapRequest(body);
+		const span = startSpan(request.name, {
+			...request.fields,
+			provider: provider(this)
+		});
+		const end = endOnce(span);
+		const startedAt = Date.now();
+		try {
+			return makeTracedPromise(original.apply(this, args), {
+				end,
+				span,
+				startedAt,
+				streaming,
+				mapResponse
+			});
+		} catch (error) {
+			end({ error });
+			throw error;
+		}
+	};
+	return markWrapped(wrapped, original);
+}
+function patchInstanceMethod(target, key, request, response, provider) {
+	const current = target[key];
+	if (isWrapped(current) && Object.hasOwn(target, key)) return;
+	const original = isWrapped(current) ? current[WRAPPED_ORIGINAL] : current;
+	if (typeof original !== "function") return;
+	target[key] = wrapCreate(original.bind(target), request, response, () => provider);
+}
+function patchPrototype(klass, key, request, response) {
+	const prototype = klass.prototype;
+	const original = prototype[key];
+	if (typeof original !== "function" || isWrapped(original)) return () => {};
+	prototype[key] = wrapCreate(original, request, response, providerForResource);
+	return () => {
+		prototype[key] = original;
+	};
+}
+let installed = false;
+let restorePatches = [];
+function wrapAnthropic(client) {
+	if (wrappedClients.has(client)) return client;
+	const provider = providerForClient(client);
+	const messages = asRecord(client.messages);
+	if (messages) patchInstanceMethod(messages, "create", messagesRequest, messagesResponse, provider);
+	wrappedClients.add(client);
+	return client;
+}
+function instrumentAnthropic() {
+	if (installed) return;
+	restorePatches = [patchPrototype(Messages, "create", messagesRequest, messagesResponse)];
+	installed = true;
+}
+function uninstrumentAnthropic() {
+	if (!installed) return;
+	for (const restore of restorePatches.reverse()) restore();
+	restorePatches = [];
+	installed = false;
+}
+//#endregion
+export { instrumentAnthropic, uninstrumentAnthropic, wrapAnthropic };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@telemetry-dev/anthropic",
+  "version": "0.1.0",
+  "description": "Anthropic SDK instrumentation for telemetry.dev: wraps the Messages API and emits OpenTelemetry GenAI spans.",
+  "keywords": [
+    "anthropic",
+    "claude",
+    "genai",
+    "llm",
+    "observability",
+    "opentelemetry",
+    "telemetry",
+    "tracing"
+  ],
+  "homepage": "https://telemetry.dev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/telemetry-dev/telemetry.dev.git",
+    "directory": "packages/anthropic"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "0.110.0",
+    "@opentelemetry/sdk-logs": "^0.218.0",
+    "@opentelemetry/sdk-metrics": "^2.7.1",
+    "@opentelemetry/sdk-trace-base": "^2.7.1",
+    "@types/node": "^24",
+    "typescript": "^5",
+    "vite-plus": "0.1.20",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@0.1.20",
+    "@telemetry-dev/sdk": "0.1.0"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": ">=0.110.0 <1",
+    "@telemetry-dev/sdk": "^0.1.0"
+  },
+  "scripts": {
+    "build": "pnpm exec vp pack",
+    "dev": "pnpm exec vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}

package/src/index.ts

@@ -0,0 +1,590 @@
+import {
+  startSpan,
+  type SpanFields,
+  type SpanHandle,
+  type StartSpanOptions,
+} from "@telemetry-dev/sdk";
+import { Stream } from "@anthropic-ai/sdk/core/streaming";
+import { Messages } from "@anthropic-ai/sdk/resources/messages";
+
+export type { SpanFields, SpanHandle, StartSpanOptions } from "@telemetry-dev/sdk";
+
+const WRAPPED = Symbol("telemetry.dev.anthropic.wrapped");
+const WRAPPED_ORIGINAL = Symbol("telemetry.dev.anthropic.original");
+const wrappedClients = new WeakSet<object>();
+
+type UnknownRecord = Record<string, unknown>;
+type WrappedFunction = ((...args: unknown[]) => unknown) & {
+  [WRAPPED]?: true;
+  [WRAPPED_ORIGINAL]?: (...args: never[]) => unknown;
+};
+type ProviderResolver = (resource: unknown) => string;
+
+interface AnthropicClient {
+  messages: object;
+}
+
+interface RequestMapping {
+  name: string;
+  fields: StartSpanOptions;
+}
+
+interface WrappedResponse<T> {
+  data: T;
+  response: Response;
+  request_id: string | null;
+}
+
+interface ToolBlockState {
+  data: UnknownRecord;
+  inputJson: string;
+}
+
+interface StreamState {
+  blocks: Map<number, UnknownRecord | ToolBlockState>;
+  usage?: SpanFields["usage"];
+  finishReason?: string;
+}
+
+function asRecord(value: unknown): UnknownRecord | undefined {
+  return value !== null && typeof value === "object" ? (value as UnknownRecord) : undefined;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function readNumber(value: unknown): number | undefined {
+  return typeof value === "number" ? value : undefined;
+}
+
+function compactUsage(usage: SpanFields["usage"]): SpanFields["usage"] {
+  if (!usage) return undefined;
+  return Object.values(usage).some((value) => value !== undefined) ? usage : undefined;
+}
+
+function stopSequences(value: unknown): string[] | undefined {
+  if (typeof value === "string") return [value];
+  if (!Array.isArray(value)) return undefined;
+  const strings = value.filter((item): item is string => typeof item === "string");
+  return strings.length > 0 ? strings : undefined;
+}
+
+function messagesRequest(body: UnknownRecord): RequestMapping {
+  const model = readString(body.model);
+  const input =
+    body.tools !== undefined || body.tool_choice !== undefined
+      ? { messages: body.messages, tools: body.tools, tool_choice: body.tool_choice }
+      : body.messages;
+  return {
+    name: `chat ${model ?? "unknown"}`,
+    fields: {
+      type: "generation",
+      model,
+      input,
+      systemInstructions: body.system,
+      temperature: readNumber(body.temperature),
+      topP: readNumber(body.top_p),
+      topK: readNumber(body.top_k),
+      maxTokens: readNumber(body.max_tokens),
+      stopSequences: stopSequences(body.stop_sequences),
+    },
+  };
+}
+
+function messagesUsage(usage: unknown): SpanFields["usage"] {
+  const u = asRecord(usage);
+  const outputDetails = asRecord(u?.output_tokens_details);
+  return compactUsage({
+    inputTokens: readNumber(u?.input_tokens),
+    outputTokens: readNumber(u?.output_tokens),
+    cacheReadInputTokens: readNumber(u?.cache_read_input_tokens),
+    cacheCreationInputTokens: readNumber(u?.cache_creation_input_tokens),
+    reasoningOutputTokens: readNumber(outputDetails?.thinking_tokens),
+  });
+}
+
+function mergeUsage(
+  current: SpanFields["usage"],
+  incoming: SpanFields["usage"],
+): SpanFields["usage"] {
+  if (!incoming) return current;
+  return compactUsage({
+    inputTokens: incoming.inputTokens ?? current?.inputTokens,
+    outputTokens: incoming.outputTokens ?? current?.outputTokens,
+    cacheReadInputTokens: incoming.cacheReadInputTokens ?? current?.cacheReadInputTokens,
+    cacheCreationInputTokens:
+      incoming.cacheCreationInputTokens ?? current?.cacheCreationInputTokens,
+    reasoningOutputTokens: incoming.reasoningOutputTokens ?? current?.reasoningOutputTokens,
+  });
+}
+
+function messagesResponse(response: unknown): SpanFields {
+  const r = asRecord(response) ?? {};
+  const role = readString(r.role) ?? "assistant";
+  return {
+    responseModel: readString(r.model),
+    responseId: readString(r.id),
+    finishReason: readString(r.stop_reason),
+    output: r.content !== undefined ? [{ role, content: r.content }] : undefined,
+    usage: messagesUsage(r.usage),
+  };
+}
+
+function constructorName(value: unknown): string | undefined {
+  if (value === null || (typeof value !== "object" && typeof value !== "function")) {
+    return undefined;
+  }
+  const ctor = value.constructor;
+  return typeof ctor === "function" ? ctor.name : undefined;
+}
+
+function providerForClient(client: unknown): string {
+  switch (constructorName(client)) {
+    case "AnthropicBedrock":
+    case "AsyncAnthropicBedrock":
+      return "aws.bedrock";
+    case "AnthropicVertex":
+    case "AsyncAnthropicVertex":
+      return "gcp.vertex_ai";
+    default:
+      return "anthropic";
+  }
+}
+
+function providerForResource(resource: unknown): string {
+  return providerForClient(asRecord(resource)?._client);
+}
+
+function isWrapped(fn: unknown): fn is WrappedFunction {
+  if (typeof fn !== "function") return false;
+  const wrapped = fn as WrappedFunction;
+  return wrapped[WRAPPED] === true;
+}
+
+function markWrapped<T extends WrappedFunction>(fn: T, original: (...args: never[]) => unknown): T {
+  Object.defineProperty(fn, WRAPPED, { value: true });
+  Object.defineProperty(fn, WRAPPED_ORIGINAL, { value: original });
+  return fn;
+}
+
+function endOnce(span: SpanHandle): (fields?: SpanFields) => void {
+  let ended = false;
+  return (fields?: SpanFields) => {
+    if (ended) return;
+    ended = true;
+    span.end(fields);
+  };
+}
+
+type TracedResult<T> = Promise<T> & {
+  asResponse(): Promise<Response>;
+  withResponse(): Promise<WrappedResponse<T>>;
+  _thenUnwrap<U>(transform: (data: T, ...args: unknown[]) => U): TracedResult<U>;
+};
+
+interface TracePromiseContext {
+  end: (fields?: SpanFields) => void;
+  span: SpanHandle;
+  startedAt: number;
+  streaming: boolean;
+  mapResponse: (response: unknown) => SpanFields;
+}
+
+interface StreamLike<T> extends AsyncIterable<T> {
+  controller: AbortController;
+}
+
+type InnerAPIPromise = {
+  then: Promise<unknown>["then"];
+  catch: Promise<unknown>["catch"];
+  finally: Promise<unknown>["finally"];
+  asResponse?: () => Promise<Response>;
+  withResponse?: () => Promise<WrappedResponse<unknown>>;
+  _thenUnwrap?: <U>(transform: (data: unknown, ...args: unknown[]) => U) => InnerAPIPromise;
+};
+
+function mapRawResponse(response: Response): SpanFields {
+  const requestId = response.headers.get("request-id");
+  return {
+    ...(requestId ? { responseId: requestId } : {}),
+    attributes: { "http.response.status_code": response.status },
+  };
+}
+
+function finalizeParsedValue(value: unknown, ctx: TracePromiseContext): unknown {
+  if (ctx.streaming) {
+    const wrapped = wrapStream(value, ctx.span, ctx.startedAt, ctx.end);
+    if (wrapped !== value) return wrapped;
+  }
+  ctx.end(ctx.mapResponse(value));
+  return value;
+}
+
+function rejectMissing(method: string): Promise<never> {
+  return Promise.reject(new TypeError(`wrapped result has no ${method}`));
+}
+
+function makeTracedPromise<T>(inner: unknown, ctx: TracePromiseContext): TracedResult<T> {
+  const source = inner as InnerAPIPromise;
+  const originalThen = source.then.bind(source);
+  const originalAsResponse = source.asResponse?.bind(source);
+  const originalThenUnwrap = source._thenUnwrap?.bind(source);
+  const handleError = (error: unknown): never => {
+    ctx.end({ error });
+    throw error;
+  };
+  const onParsed = (value: unknown) => finalizeParsedValue(value, ctx) as T;
+  const parsed = () => originalThen(onParsed, handleError);
+  const traced =
+    constructorName(source) === "APIPromise"
+      ? (source as TracedResult<T>)
+      : (new Promise<T>((resolve, reject) => {
+          parsed().then(resolve, reject);
+        }) as TracedResult<T>);
+  if (traced === source) {
+    // oxlint-disable-next-line unicorn/no-thenable -- preserve Anthropic APIPromise subclass contract.
+    traced.then = ((onfulfilled, onrejected) =>
+      parsed().then(onfulfilled, onrejected)) as TracedResult<T>["then"];
+    traced.catch = ((onrejected) => parsed().catch(onrejected)) as TracedResult<T>["catch"];
+    traced.finally = ((onfinally) => parsed().finally(onfinally)) as TracedResult<T>["finally"];
+  }
+  traced.asResponse = () => {
+    if (!originalAsResponse) return rejectMissing("asResponse");
+    return originalAsResponse().then((response) => {
+      ctx.end(mapRawResponse(response));
+      return response;
+    }, handleError);
+  };
+  traced.withResponse = () => {
+    if (!originalAsResponse) return rejectMissing("withResponse");
+    return Promise.all([parsed(), originalAsResponse()]).then(
+      ([data, response]) => ({
+        data,
+        response,
+        request_id: response.headers.get("request-id"),
+      }),
+      handleError,
+    );
+  };
+  traced._thenUnwrap = <U>(transform: (data: T, ...args: unknown[]) => U): TracedResult<U> => {
+    if (!originalThenUnwrap) return rejectMissing("_thenUnwrap") as unknown as TracedResult<U>;
+    return makeTracedPromise(
+      originalThenUnwrap(transform as (data: unknown, ...args: unknown[]) => U),
+      ctx,
+    );
+  };
+  return traced;
+}
+
+function isToolBlockState(value: UnknownRecord | ToolBlockState): value is ToolBlockState {
+  return "data" in value && "inputJson" in value;
+}
+
+function setFirstStreamUpdate(
+  span: SpanHandle,
+  startedAt: number,
+  sawFirst: { value: boolean },
+  fields: SpanFields,
+): void {
+  if (sawFirst.value) return;
+  sawFirst.value = true;
+  span.update({
+    timeToFirstChunkMs: Date.now() - startedAt,
+    responseId: fields.responseId,
+    responseModel: fields.responseModel,
+  });
+}
+
+function parseToolInput(inputJson: string): unknown {
+  if (inputJson.length === 0) return {};
+  try {
+    return JSON.parse(inputJson) as unknown;
+  } catch {
+    return inputJson;
+  }
+}
+
+function finalizeBlock(block: UnknownRecord | ToolBlockState): UnknownRecord {
+  if (!isToolBlockState(block)) return block;
+  const input = parseToolInput(block.inputJson);
+  if (block.data.input === undefined) return { ...block.data, input };
+  if (block.inputJson.length === 0) return block.data;
+  const existingInput = asRecord(block.data.input);
+  const parsedInput = asRecord(input);
+  return {
+    ...block.data,
+    input:
+      existingInput && parsedInput && !Array.isArray(existingInput) && !Array.isArray(parsedInput)
+        ? { ...existingInput, ...parsedInput }
+        : input,
+  };
+}
+
+function streamOutput(state: StreamState): UnknownRecord[] | undefined {
+  if (state.blocks.size === 0) return undefined;
+  return [
+    {
+      role: "assistant",
+      content: [...state.blocks.entries()]
+        .sort(([left], [right]) => left - right)
+        .map(([, block]) => finalizeBlock(block)),
+    },
+  ];
+}
+
+function streamPartialFields(state: StreamState): SpanFields {
+  return {
+    output: streamOutput(state),
+    usage: state.usage,
+    finishReason: state.finishReason,
+  };
+}
+
+function recordContentBlockStart(event: UnknownRecord, state: StreamState): void {
+  const index = readNumber(event.index) ?? state.blocks.size;
+  const contentBlock = asRecord(event.content_block) ?? {};
+  const type = readString(contentBlock.type);
+  if (type === "text") {
+    state.blocks.set(index, { type, text: readString(contentBlock.text) ?? "" });
+    return;
+  }
+  if (type === "tool_use" || type === "server_tool_use") {
+    const data: UnknownRecord = { ...contentBlock, type };
+    state.blocks.set(index, { data, inputJson: "" });
+    return;
+  }
+  if (type === "thinking") {
+    state.blocks.set(index, { type, thinking: readString(contentBlock.thinking) ?? "" });
+    return;
+  }
+  state.blocks.set(index, { ...contentBlock });
+}
+
+function blockForDelta(
+  index: number,
+  deltaType: string | undefined,
+  state: StreamState,
+): UnknownRecord | ToolBlockState {
+  const existing = state.blocks.get(index);
+  if (existing) return existing;
+  if (deltaType === "input_json_delta") {
+    const block = { data: { type: "tool_use" }, inputJson: "" };
+    state.blocks.set(index, block);
+    return block;
+  }
+  const block =
+    deltaType === "thinking_delta"
+      ? { type: "thinking", thinking: "" }
+      : { type: "text", text: "" };
+  state.blocks.set(index, block);
+  return block;
+}
+
+function appendStringField(target: UnknownRecord, key: string, value: string | undefined): void {
+  if (value === undefined) return;
+  const existing = readString(target[key]) ?? "";
+  target[key] = `${existing}${value}`;
+}
+
+function appendArrayField(target: UnknownRecord, key: string, value: unknown): void {
+  if (value === undefined) return;
+  const existing = Array.isArray(target[key]) ? (target[key] as unknown[]) : [];
+  target[key] = [...existing, value];
+}
+
+function recordContentBlockDelta(event: UnknownRecord, state: StreamState): void {
+  const index = readNumber(event.index) ?? 0;
+  const delta = asRecord(event.delta) ?? {};
+  const deltaType = readString(delta.type);
+  const block = blockForDelta(index, deltaType, state);
+  if (deltaType === "input_json_delta") {
+    if (isToolBlockState(block)) block.inputJson += readString(delta.partial_json) ?? "";
+    return;
+  }
+  const data = isToolBlockState(block) ? block.data : block;
+  if (deltaType === "text_delta") appendStringField(data, "text", readString(delta.text));
+  if (deltaType === "citations_delta") appendArrayField(data, "citations", delta.citation);
+  if (deltaType === "thinking_delta") {
+    appendStringField(data, "thinking", readString(delta.thinking));
+  }
+  if (deltaType === "signature_delta" && delta.signature !== undefined)
+    data.signature = delta.signature;
+}
+
+function recordStreamEvent(event: unknown, state: StreamState): SpanFields {
+  const e = asRecord(event) ?? {};
+  const type = readString(e.type);
+  const fields: SpanFields = {};
+  if (type === "message_start") {
+    const message = asRecord(e.message) ?? {};
+    fields.responseId = readString(message.id);
+    fields.responseModel = readString(message.model);
+    state.usage = mergeUsage(state.usage, messagesUsage(message.usage));
+  }
+  if (type === "content_block_start") recordContentBlockStart(e, state);
+  if (type === "content_block_delta") recordContentBlockDelta(e, state);
+  if (type === "message_delta") {
+    const delta = asRecord(e.delta) ?? {};
+    state.finishReason = readString(delta.stop_reason) ?? state.finishReason;
+    state.usage = mergeUsage(state.usage, messagesUsage(e.usage));
+  }
+  return fields;
+}
+
+function isStreamLike(value: unknown): value is StreamLike<unknown> {
+  if (value === null || typeof value !== "object") return false;
+  const stream = value as Partial<StreamLike<unknown>>;
+  const signal = asRecord(stream.controller)?.signal;
+  return (
+    typeof stream[Symbol.asyncIterator] === "function" &&
+    signal !== undefined &&
+    typeof asRecord(signal)?.addEventListener === "function"
+  );
+}
+
+function createObservedMessagesStream(
+  source: StreamLike<unknown>,
+  span: SpanHandle,
+  startedAt: number,
+  end: (fields?: SpanFields) => void,
+): Stream<unknown> {
+  const state: StreamState = { blocks: new Map() };
+  // The iterator's finally block never runs when iteration never starts, so an
+  // abort on an unconsumed stream must end the span here. Once iteration begins,
+  // the finally block owns the span end (the SDK aborts the controller as normal
+  // cleanup when the caller stops early, which is not an error).
+  let consumed = false;
+  const signal = source.controller.signal;
+  const endAborted = () => {
+    if (consumed) return;
+    end({ ...streamPartialFields(state), error: signal.reason ?? new Error("Request aborted") });
+  };
+  if (signal.aborted) endAborted();
+  else signal.addEventListener("abort", endAborted, { once: true });
+  async function* iterator() {
+    consumed = true;
+    const sawFirst = { value: false };
+    let terminalError: unknown;
+    try {
+      for await (const event of source) {
+        const fields = recordStreamEvent(event, state);
+        setFirstStreamUpdate(span, startedAt, sawFirst, fields);
+        yield event;
+      }
+    } catch (error) {
+      terminalError = error;
+      throw error;
+    } finally {
+      end({
+        ...streamPartialFields(state),
+        ...(terminalError !== undefined ? { error: terminalError } : {}),
+      });
+    }
+  }
+  return new Stream(() => iterator(), source.controller);
+}
+
+function wrapStream(
+  value: unknown,
+  span: SpanHandle,
+  startedAt: number,
+  end: (fields?: SpanFields) => void,
+): unknown {
+  if (!isStreamLike(value)) return value;
+  return createObservedMessagesStream(value, span, startedAt, end);
+}
+
+function wrapCreate<Fn extends (...args: never[]) => unknown>(
+  original: Fn,
+  mapRequest: (body: UnknownRecord) => RequestMapping,
+  mapResponse: (response: unknown) => SpanFields,
+  provider: ProviderResolver,
+): Fn {
+  if (isWrapped(original)) return original;
+  const wrapped = function (this: unknown, ...args: unknown[]): unknown {
+    const body = asRecord(args[0]) ?? {};
+    const streaming = body.stream === true;
+    const request = mapRequest(body);
+    const span = startSpan(request.name, { ...request.fields, provider: provider(this) });
+    const end = endOnce(span);
+    const startedAt = Date.now();
+
+    try {
+      const result = original.apply(this, args as never[]);
+      return makeTracedPromise(result, { end, span, startedAt, streaming, mapResponse });
+    } catch (error) {
+      end({ error });
+      throw error;
+    }
+  };
+  return markWrapped(wrapped as WrappedFunction, original) as unknown as Fn;
+}
+
+function patchInstanceMethod<T extends UnknownRecord>(
+  target: T,
+  key: keyof T,
+  request: (body: UnknownRecord) => RequestMapping,
+  response: (value: unknown) => SpanFields,
+  provider: string,
+): void {
+  const current = target[key];
+  // An inherited wrapper (from the global prototype patch) is not an own wrapper:
+  // install one over the original so the client keeps emitting spans after
+  // uninstrumentAnthropic().
+  if (isWrapped(current) && Object.hasOwn(target, key)) return;
+  const original = isWrapped(current) ? current[WRAPPED_ORIGINAL] : current;
+  if (typeof original !== "function") return;
+  target[key] = wrapCreate(
+    original.bind(target) as (...args: never[]) => unknown,
+    request,
+    response,
+    () => provider,
+  ) as T[keyof T];
+}
+
+function patchPrototype(
+  klass: { prototype: object },
+  key: string,
+  request: (body: UnknownRecord) => RequestMapping,
+  response: (value: unknown) => SpanFields,
+): () => void {
+  const prototype = klass.prototype as UnknownRecord;
+  const original = prototype[key];
+  if (typeof original !== "function" || isWrapped(original)) return () => {};
+  prototype[key] = wrapCreate(
+    original as (...args: never[]) => unknown,
+    request,
+    response,
+    providerForResource,
+  );
+  return () => {
+    prototype[key] = original;
+  };
+}
+
+let installed = false;
+let restorePatches: Array<() => void> = [];
+
+export function wrapAnthropic<T extends AnthropicClient>(client: T): T {
+  if (wrappedClients.has(client)) return client;
+  const provider = providerForClient(client);
+  const messages = asRecord(client.messages);
+  if (messages)
+    patchInstanceMethod(messages, "create", messagesRequest, messagesResponse, provider);
+  wrappedClients.add(client);
+  return client;
+}
+
+export function instrumentAnthropic(): void {
+  if (installed) return;
+  restorePatches = [patchPrototype(Messages, "create", messagesRequest, messagesResponse)];
+  installed = true;
+}
+
+export function uninstrumentAnthropic(): void {
+  if (!installed) return;
+  for (const restore of restorePatches.reverse()) restore();
+  restorePatches = [];
+  installed = false;
+}