@telemetry-dev/anthropic 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -6,22 +6,27 @@ 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;
+	if (value === null || value === void 0 || value instanceof Function) return void 0;
+	return Object(value) === value ? value : void 0;
 }
 function readString(value) {
-	return typeof value === "string" ? value : void 0;
+	return String(value) === value ? value : void 0;
 }
 function readNumber(value) {
-	return typeof value === "number" ? value : void 0;
+	return Number(value) === value ? 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];
+	const single = readString(value);
+	if (single !== void 0) return [single];
 	if (!Array.isArray(value)) return void 0;
-	const strings = value.filter((item) => typeof item === "string");
+	const strings = value.flatMap((item) => {
+		const string = readString(item);
+		return string === void 0 ? [] : [string];
+	});
 	return strings.length > 0 ? strings : void 0;
 }
 function messagesRequest(body) {
@@ -47,14 +52,14 @@ function messagesRequest(body) {
 	};
 }
 function messagesUsage(usage) {
-	const u = asRecord(usage);
-	const outputDetails = asRecord(u?.output_tokens_details);
+	const record = asRecord(usage);
+	const details = asRecord(record?.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)
+		inputTokens: readNumber(record?.input_tokens),
+		outputTokens: readNumber(record?.output_tokens),
+		cacheReadInputTokens: readNumber(record?.cache_read_input_tokens),
+		cacheCreationInputTokens: readNumber(record?.cache_creation_input_tokens),
+		reasoningOutputTokens: readNumber(details?.thinking_tokens)
 	});
 }
 function mergeUsage(current, incoming) {
@@ -68,23 +73,23 @@ function mergeUsage(current, incoming) {
 	});
 }
 function messagesResponse(response) {
-	const r = asRecord(response) ?? {};
-	const role = readString(r.role) ?? "assistant";
+	const record = asRecord(response) ?? {};
+	const role = readString(record.role) ?? "assistant";
 	return {
-		responseModel: readString(r.model),
-		responseId: readString(r.id),
-		finishReason: readString(r.stop_reason),
-		output: r.content !== void 0 ? [{
+		responseModel: readString(record.model),
+		responseId: readString(record.id),
+		finishReason: readString(record.stop_reason),
+		output: record.content !== void 0 ? [{
 			role,
-			content: r.content
+			content: record.content
 		}] : void 0,
-		usage: messagesUsage(r.usage)
+		usage: messagesUsage(record.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;
+	if (value === null || value === void 0) return void 0;
+	const ctor = Object(value).constructor;
+	return ctor instanceof Function ? ctor.name : void 0;
 }
 function providerForClient(client) {
 	switch (constructorName(client)) {
@@ -99,7 +104,7 @@ function providerForResource(resource) {
 	return providerForClient(asRecord(resource)?._client);
 }
 function isWrapped(fn) {
-	if (typeof fn !== "function") return false;
+	if (!(fn instanceof Function)) return false;
 	return fn[WRAPPED] === true;
 }
 function markWrapped(fn, original) {
@@ -116,11 +121,10 @@ function endOnce(span) {
 	};
 }
 function mapRawResponse(response) {
+	const fields = { attributes: { "http.response.status_code": response.status } };
 	const requestId = response.headers.get("request-id");
-	return {
-		...requestId ? { responseId: requestId } : {},
-		attributes: { "http.response.status_code": response.status }
-	};
+	if (requestId) fields.responseId = requestId;
+	return fields;
 }
 function finalizeParsedValue(value, ctx) {
 	if (ctx.streaming) {
@@ -139,14 +143,14 @@ function makeTracedPromise(inner, ctx) {
 	const originalAsResponse = source.asResponse?.bind(source);
 	const originalThenUnwrap = source._thenUnwrap?.bind(source);
 	const handleError = (error) => {
-		ctx.end({ error });
+		ctx.end({ error: error instanceof Error ? error : new Error(String(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);
-	});
+	let traced;
+	if (constructorName(source) === "APIPromise") traced = source;
+	else traced = 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));
@@ -169,7 +173,9 @@ function makeTracedPromise(inner, ctx) {
 	};
 	traced._thenUnwrap = (transform) => {
 		if (!originalThenUnwrap) return rejectMissing("_thenUnwrap");
-		return makeTracedPromise(originalThenUnwrap(transform), ctx);
+		return makeTracedPromise(originalThenUnwrap((data, ...args) => {
+			return transform(data, ...args);
+		}), ctx);
 	};
 	return traced;
 }
@@ -301,28 +307,30 @@ function recordContentBlockDelta(event, state) {
 	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 record = asRecord(event) ?? {};
+	const type = readString(record.type);
 	const fields = {};
 	if (type === "message_start") {
-		const message = asRecord(e.message) ?? {};
+		const message = asRecord(record.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 === "content_block_start") recordContentBlockStart(record, state);
+	if (type === "content_block_delta") recordContentBlockDelta(record, state);
 	if (type === "message_delta") {
-		state.finishReason = readString((asRecord(e.delta) ?? {}).stop_reason) ?? state.finishReason;
-		state.usage = mergeUsage(state.usage, messagesUsage(e.usage));
+		state.finishReason = readString((asRecord(record.delta) ?? {}).stop_reason) ?? state.finishReason;
+		state.usage = mergeUsage(state.usage, messagesUsage(record.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";
+	const stream = asRecord(value);
+	if (!stream) return false;
+	const controller = asRecord(stream.controller);
+	const signal = asRecord(controller?.signal);
+	if (!controller || !(controller.abort instanceof Function) || !signal || typeof signal.aborted !== "boolean" || !(signal.addEventListener instanceof Function)) return false;
+	return stream[Symbol.asyncIterator] instanceof Function;
 }
 function createObservedMessagesStream(source, span, startedAt, end) {
 	const state = { blocks: /* @__PURE__ */ new Map() };
@@ -332,7 +340,7 @@ function createObservedMessagesStream(source, span, startedAt, end) {
 		if (consumed) return;
 		end({
 			...streamPartialFields(state),
-			error: signal.reason ?? /* @__PURE__ */ new Error("Request aborted")
+			error: signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Request aborted")
 		});
 	};
 	if (signal.aborted) endAborted();
@@ -350,10 +358,9 @@ function createObservedMessagesStream(source, span, startedAt, end) {
 			terminalError = error;
 			throw error;
 		} finally {
-			end({
-				...streamPartialFields(state),
-				...terminalError !== void 0 ? { error: terminalError } : {}
-			});
+			const fields = streamPartialFields(state);
+			if (terminalError !== void 0) fields.error = terminalError instanceof Error ? terminalError : new Error(String(terminalError));
+			end(fields);
 		}
 	}
 	return new Stream(() => iterator(), source.controller);
@@ -383,7 +390,7 @@ function wrapCreate(original, mapRequest, mapResponse, provider) {
 				mapResponse
 			});
 		} catch (error) {
-			end({ error });
+			end({ error: error instanceof Error ? error : new Error(String(error)) });
 			throw error;
 		}
 	};
@@ -393,13 +400,13 @@ 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;
+	if (!(original instanceof 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 () => {};
+	if (!(original instanceof Function) || isWrapped(original)) return () => {};
 	prototype[key] = wrapCreate(original, request, response, providerForResource);
 	return () => {
 		prototype[key] = original;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telemetry-dev/anthropic",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Anthropic SDK instrumentation for telemetry.dev: wraps the Messages API and emits OpenTelemetry GenAI spans.",
   "keywords": [
     "anthropic",
@@ -40,15 +40,15 @@
     "@opentelemetry/sdk-logs": "^0.218.0",
     "@opentelemetry/sdk-metrics": "^2.7.1",
     "@opentelemetry/sdk-trace-base": "^2.7.1",
+    "@telemetry-dev/sdk": "0.1.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"
+    "vitest": "npm:@voidzero-dev/vite-plus-test@0.1.20"
   },
   "peerDependencies": {
     "@anthropic-ai/sdk": ">=0.110.0 <1",
-    "@telemetry-dev/sdk": "^0.1.0"
+    "@telemetry-dev/sdk": "^0.1.1"
   },
   "scripts": {
     "build": "pnpm exec vp pack",

package/src/index.ts

@@ -13,64 +13,70 @@ 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) & {
+type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
+interface OpaqueValue {}
+type Value = string | number | boolean | null | undefined | OpaqueValue;
+interface ValueRecord {
+  [key: string]: JsonValue | undefined;
+  [key: symbol]: JsonValue | undefined;
+}
+interface CallableRecord {
+  [key: string]: JsonValue | AnyFunction | undefined;
+}
+type AnyFunction = (...args: never[]) => OpaqueValue;
+type WrappedFunction = AnyFunction & {
   [WRAPPED]?: true;
-  [WRAPPED_ORIGINAL]?: (...args: never[]) => unknown;
+  [WRAPPED_ORIGINAL]?: AnyFunction;
 };
-type ProviderResolver = (resource: unknown) => string;
+type ProviderResolver = (resource: Value) => 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;
+  data: ValueRecord;
   inputJson: string;
 }
-
 interface StreamState {
-  blocks: Map<number, UnknownRecord | ToolBlockState>;
+  blocks: Map<number, ValueRecord | ToolBlockState>;
   usage?: SpanFields["usage"];
   finishReason?: string;
 }
 
-function asRecord(value: unknown): UnknownRecord | undefined {
-  return value !== null && typeof value === "object" ? (value as UnknownRecord) : undefined;
+function asRecord<T>(value: T): (T & ValueRecord) | undefined {
+  if (value === null || value === undefined || value instanceof Function) return undefined;
+  return Object(value) === value ? (value as T & ValueRecord) : undefined;
 }
-
-function readString(value: unknown): string | undefined {
-  return typeof value === "string" ? value : undefined;
+function readString<T>(value: T): string | undefined {
+  return String(value) === value ? (value as string) : undefined;
 }
-
-function readNumber(value: unknown): number | undefined {
-  return typeof value === "number" ? value : undefined;
+function readNumber<T>(value: T): number | undefined {
+  return Number(value) === value ? (value as number) : 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];
+function stopSequences<T>(value: T): string[] | undefined {
+  const single = readString(value);
+  if (single !== undefined) return [single];
   if (!Array.isArray(value)) return undefined;
-  const strings = value.filter((item): item is string => typeof item === "string");
+  const strings = value.flatMap((item) => {
+    const string = readString(item);
+    return string === undefined ? [] : [string];
+  });
   return strings.length > 0 ? strings : undefined;
 }
-
-function messagesRequest(body: UnknownRecord): RequestMapping {
+function messagesRequest(body: ValueRecord): RequestMapping {
   const model = readString(body.model);
   const input =
     body.tools !== undefined || body.tool_choice !== undefined
@@ -91,19 +97,17 @@ function messagesRequest(body: UnknownRecord): RequestMapping {
     },
   };
 }
-
-function messagesUsage(usage: unknown): SpanFields["usage"] {
-  const u = asRecord(usage);
-  const outputDetails = asRecord(u?.output_tokens_details);
+function messagesUsage<T>(usage: T): SpanFields["usage"] {
+  const record = asRecord(usage);
+  const details = asRecord(record?.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),
+    inputTokens: readNumber(record?.input_tokens),
+    outputTokens: readNumber(record?.output_tokens),
+    cacheReadInputTokens: readNumber(record?.cache_read_input_tokens),
+    cacheCreationInputTokens: readNumber(record?.cache_creation_input_tokens),
+    reasoningOutputTokens: readNumber(details?.thinking_tokens),
   });
 }
-
 function mergeUsage(
   current: SpanFields["usage"],
   incoming: SpanFields["usage"],
@@ -118,28 +122,23 @@ function mergeUsage(
     reasoningOutputTokens: incoming.reasoningOutputTokens ?? current?.reasoningOutputTokens,
   });
 }
-
-function messagesResponse(response: unknown): SpanFields {
-  const r = asRecord(response) ?? {};
-  const role = readString(r.role) ?? "assistant";
+function messagesResponse<T>(response: T): SpanFields {
+  const record: ValueRecord = asRecord(response) ?? {};
+  const role = readString(record.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),
+    responseModel: readString(record.model),
+    responseId: readString(record.id),
+    finishReason: readString(record.stop_reason),
+    output: record.content !== undefined ? [{ role, content: record.content }] : undefined,
+    usage: messagesUsage(record.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 constructorName<T>(value: T): string | undefined {
+  if (value === null || value === undefined) return undefined;
+  const ctor = Object(value).constructor;
+  return ctor instanceof Function ? ctor.name : undefined;
 }
-
-function providerForClient(client: unknown): string {
+function providerForClient<T>(client: T): string {
   switch (constructorName(client)) {
     case "AnthropicBedrock":
     case "AsyncAnthropicBedrock":
@@ -151,23 +150,18 @@ function providerForClient(client: unknown): string {
       return "anthropic";
   }
 }
-
-function providerForResource(resource: unknown): string {
+function providerForResource<T>(resource: T): 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 isWrapped<T>(fn: T): fn is T & WrappedFunction {
+  if (!(fn instanceof Function)) return false;
+  return (fn as WrappedFunction)[WRAPPED] === true;
 }
-
-function markWrapped<T extends WrappedFunction>(fn: T, original: (...args: never[]) => unknown): T {
+function markWrapped<T extends WrappedFunction>(fn: T, original: AnyFunction): 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) => {
@@ -180,39 +174,32 @@ function endOnce(span: SpanHandle): (fields?: SpanFields) => void {
 type TracedResult<T> = Promise<T> & {
   asResponse(): Promise<Response>;
   withResponse(): Promise<WrappedResponse<T>>;
-  _thenUnwrap<U>(transform: (data: T, ...args: unknown[]) => U): TracedResult<U>;
+  _thenUnwrap<U>(transform: (data: T, ...args: Value[]) => U): TracedResult<U>;
 };
-
 interface TracePromiseContext {
   end: (fields?: SpanFields) => void;
   span: SpanHandle;
   startedAt: number;
   streaming: boolean;
-  mapResponse: (response: unknown) => SpanFields;
+  mapResponse: (response: Value) => SpanFields;
 }
-
 interface StreamLike<T> extends AsyncIterable<T> {
   controller: AbortController;
 }
-
-type InnerAPIPromise = {
-  then: Promise<unknown>["then"];
-  catch: Promise<unknown>["catch"];
-  finally: Promise<unknown>["finally"];
+interface InnerAPIPromise {
+  then: Promise<Value>["then"];
+  catch: Promise<Value>["catch"];
+  finally: Promise<Value>["finally"];
   asResponse?: () => Promise<Response>;
-  withResponse?: () => Promise<WrappedResponse<unknown>>;
-  _thenUnwrap?: <U>(transform: (data: unknown, ...args: unknown[]) => U) => InnerAPIPromise;
-};
-
+  _thenUnwrap?: <U>(transform: (data: Value, ...args: Value[]) => U) => InnerAPIPromise;
+}
 function mapRawResponse(response: Response): SpanFields {
+  const fields: SpanFields = { attributes: { "http.response.status_code": response.status } };
   const requestId = response.headers.get("request-id");
-  return {
-    ...(requestId ? { responseId: requestId } : {}),
-    attributes: { "http.response.status_code": response.status },
-  };
+  if (requestId) fields.responseId = requestId;
+  return fields;
 }
-
-function finalizeParsedValue(value: unknown, ctx: TracePromiseContext): unknown {
+function finalizeParsedValue(value: Value, ctx: TracePromiseContext): Value {
   if (ctx.streaming) {
     const wrapped = wrapStream(value, ctx.span, ctx.startedAt, ctx.end);
     if (wrapped !== value) return wrapped;
@@ -220,28 +207,26 @@ function finalizeParsedValue(value: unknown, ctx: TracePromiseContext): unknown
   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;
+function makeTracedPromise<T>(inner: InnerAPIPromise, ctx: TracePromiseContext): TracedResult<T> {
+  const source = inner;
   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 });
+  const handleError = (error: Value): never => {
+    ctx.end({ error: error instanceof Error ? error : new Error(String(error)) });
     throw error;
   };
-  const onParsed = (value: unknown) => finalizeParsedValue(value, ctx) as T;
+  const onParsed = (value: Value) => 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>);
+  let traced: TracedResult<T>;
+  if (constructorName(source) === "APIPromise") {
+    traced = source as TracedResult<T>;
+  } else {
+    traced = 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) =>
@@ -259,28 +244,27 @@ function makeTracedPromise<T>(inner: unknown, ctx: TracePromiseContext): TracedR
   traced.withResponse = () => {
     if (!originalAsResponse) return rejectMissing("withResponse");
     return Promise.all([parsed(), originalAsResponse()]).then(
-      ([data, response]) => ({
-        data,
-        response,
-        request_id: response.headers.get("request-id"),
-      }),
+      ([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>;
+  traced._thenUnwrap = <U>(transform: (data: T, ...args: Value[]) => U): TracedResult<U> => {
+    if (!originalThenUnwrap) {
+      return rejectMissing("_thenUnwrap") as Promise<never> & TracedResult<U>;
+    }
     return makeTracedPromise(
-      originalThenUnwrap(transform as (data: unknown, ...args: unknown[]) => U),
+      originalThenUnwrap((data, ...args) => {
+        return transform(data as T, ...args);
+      }),
       ctx,
     );
   };
   return traced;
 }
 
-function isToolBlockState(value: UnknownRecord | ToolBlockState): value is ToolBlockState {
+function isToolBlockState(value: ValueRecord | ToolBlockState): value is ToolBlockState {
   return "data" in value && "inputJson" in value;
 }
-
 function setFirstStreamUpdate(
   span: SpanHandle,
   startedAt: number,
@@ -295,23 +279,21 @@ function setFirstStreamUpdate(
     responseModel: fields.responseModel,
   });
 }
-
-function parseToolInput(inputJson: string): unknown {
+function parseToolInput(inputJson: string): JsonValue {
   if (inputJson.length === 0) return {};
   try {
-    return JSON.parse(inputJson) as unknown;
+    return JSON.parse(inputJson);
   } catch {
     return inputJson;
   }
 }
-
-function finalizeBlock(block: UnknownRecord | ToolBlockState): UnknownRecord {
+function finalizeBlock(block: ValueRecord | ToolBlockState) {
   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);
+  const existingInput: ValueRecord | undefined = asRecord(block.data.input);
+  const parsedInput: ValueRecord | undefined = asRecord(input);
   return {
     ...block.data,
     input:
@@ -320,37 +302,26 @@ function finalizeBlock(block: UnknownRecord | ToolBlockState): UnknownRecord {
         : input,
   };
 }
-
-function streamOutput(state: StreamState): UnknownRecord[] | undefined {
+function streamOutput(state: StreamState): ValueRecord[] | undefined {
   if (state.blocks.size === 0) return undefined;
-  return [
-    {
-      role: "assistant",
-      content: [...state.blocks.entries()]
-        .sort(([left], [right]) => left - right)
-        .map(([, block]) => finalizeBlock(block)),
-    },
-  ];
+  const content = [...state.blocks.entries()]
+    .sort(([left], [right]) => left - right)
+    .map(([, block]) => finalizeBlock(block));
+  return [{ role: "assistant", content: content as JsonValue[] }];
 }
-
 function streamPartialFields(state: StreamState): SpanFields {
-  return {
-    output: streamOutput(state),
-    usage: state.usage,
-    finishReason: state.finishReason,
-  };
+  return { output: streamOutput(state), usage: state.usage, finishReason: state.finishReason };
 }
-
-function recordContentBlockStart(event: UnknownRecord, state: StreamState): void {
+function recordContentBlockStart(event: ValueRecord, state: StreamState): void {
   const index = readNumber(event.index) ?? state.blocks.size;
-  const contentBlock = asRecord(event.content_block) ?? {};
+  const contentBlock: ValueRecord = 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 };
+    const data = { ...contentBlock, type };
     state.blocks.set(index, { data, inputJson: "" });
     return;
   }
@@ -360,12 +331,11 @@ function recordContentBlockStart(event: UnknownRecord, state: StreamState): void
   }
   state.blocks.set(index, { ...contentBlock });
 }
-
 function blockForDelta(
   index: number,
   deltaType: string | undefined,
   state: StreamState,
-): UnknownRecord | ToolBlockState {
+): ValueRecord | ToolBlockState {
   const existing = state.blocks.get(index);
   if (existing) return existing;
   if (deltaType === "input_json_delta") {
@@ -380,22 +350,19 @@ function blockForDelta(
   state.blocks.set(index, block);
   return block;
 }
-
-function appendStringField(target: UnknownRecord, key: string, value: string | undefined): void {
+function appendStringField(target: ValueRecord, 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 {
+function appendArrayField(target: ValueRecord, key: string, value: JsonValue | undefined): void {
   if (value === undefined) return;
-  const existing = Array.isArray(target[key]) ? (target[key] as unknown[]) : [];
+  const existing = Array.isArray(target[key]) ? target[key] : [];
   target[key] = [...existing, value];
 }
-
-function recordContentBlockDelta(event: UnknownRecord, state: StreamState): void {
+function recordContentBlockDelta(event: ValueRecord, state: StreamState): void {
   const index = readNumber(event.index) ?? 0;
-  const delta = asRecord(event.delta) ?? {};
+  const delta: ValueRecord = asRecord(event.delta) ?? {};
   const deltaType = readString(delta.type);
   const block = blockForDelta(index, deltaType, state);
   if (deltaType === "input_json_delta") {
@@ -405,67 +372,67 @@ function recordContentBlockDelta(event: UnknownRecord, state: StreamState): void
   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") {
+  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);
+function recordStreamEvent<T>(event: T, state: StreamState): SpanFields {
+  const record: ValueRecord = asRecord(event) ?? {};
+  const type = readString(record.type);
   const fields: SpanFields = {};
   if (type === "message_start") {
-    const message = asRecord(e.message) ?? {};
+    const message: ValueRecord = asRecord(record.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 === "content_block_start") recordContentBlockStart(record, state);
+  if (type === "content_block_delta") recordContentBlockDelta(record, state);
   if (type === "message_delta") {
-    const delta = asRecord(e.delta) ?? {};
+    const delta = asRecord(record.delta) ?? {};
     state.finishReason = readString(delta.stop_reason) ?? state.finishReason;
-    state.usage = mergeUsage(state.usage, messagesUsage(e.usage));
+    state.usage = mergeUsage(state.usage, messagesUsage(record.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 isStreamLike<T>(value: T): value is T & StreamLike<Value> {
+  const stream = asRecord(value);
+  if (!stream) return false;
+  const controller = asRecord(stream.controller);
+  const signal = asRecord(controller?.signal);
+  if (
+    !controller ||
+    !(controller.abort instanceof Function) ||
+    !signal ||
+    typeof signal.aborted !== "boolean" ||
+    !(signal.addEventListener instanceof Function)
+  )
+    return false;
+  return stream[Symbol.asyncIterator] instanceof Function;
 }
-
 function createObservedMessagesStream(
-  source: StreamLike<unknown>,
+  source: StreamLike<Value>,
   span: SpanHandle,
   startedAt: number,
   end: (fields?: SpanFields) => void,
-): Stream<unknown> {
+): Stream<Value> {
   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") });
+    end({
+      ...streamPartialFields(state),
+      error: signal.reason instanceof 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;
+    let terminalError: Value;
     try {
       for await (const event of source) {
         const fields = recordStreamEvent(event, state);
@@ -473,91 +440,86 @@ function createObservedMessagesStream(
         yield event;
       }
     } catch (error) {
-      terminalError = error;
+      terminalError = error as Value;
       throw error;
     } finally {
-      end({
-        ...streamPartialFields(state),
-        ...(terminalError !== undefined ? { error: terminalError } : {}),
-      });
+      const fields = streamPartialFields(state);
+      if (terminalError !== undefined)
+        fields.error =
+          terminalError instanceof Error ? terminalError : new Error(String(terminalError));
+      end(fields);
     }
   }
   return new Stream(() => iterator(), source.controller);
 }
-
-function wrapStream(
-  value: unknown,
+function wrapStream<T>(
+  value: T,
   span: SpanHandle,
   startedAt: number,
   end: (fields?: SpanFields) => void,
-): unknown {
+): T | Stream<Value> {
   if (!isStreamLike(value)) return value;
   return createObservedMessagesStream(value, span, startedAt, end);
 }
-
-function wrapCreate<Fn extends (...args: never[]) => unknown>(
+function wrapCreate<Fn extends AnyFunction>(
   original: Fn,
-  mapRequest: (body: UnknownRecord) => RequestMapping,
-  mapResponse: (response: unknown) => SpanFields,
+  mapRequest: (body: ValueRecord) => RequestMapping,
+  mapResponse: (response: Value) => SpanFields,
   provider: ProviderResolver,
 ): Fn {
   if (isWrapped(original)) return original;
-  const wrapped = function (this: unknown, ...args: unknown[]): unknown {
-    const body = asRecord(args[0]) ?? {};
+  const wrapped: WrappedFunction = function (this: Value, ...args: Value[]): OpaqueValue {
+    const body: ValueRecord = 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 });
+      return makeTracedPromise(result as InnerAPIPromise, {
+        end,
+        span,
+        startedAt,
+        streaming,
+        mapResponse,
+      }) as OpaqueValue;
     } catch (error) {
-      end({ error });
+      end({ error: error instanceof Error ? error : new Error(String(error)) });
       throw error;
     }
   };
-  return markWrapped(wrapped as WrappedFunction, original) as unknown as Fn;
+  return markWrapped(wrapped, original) as AnyFunction & Fn;
 }
-
-function patchInstanceMethod<T extends UnknownRecord>(
+function patchInstanceMethod<T extends ValueRecord>(
   target: T,
   key: keyof T,
-  request: (body: UnknownRecord) => RequestMapping,
-  response: (value: unknown) => SpanFields,
+  request: (body: ValueRecord) => RequestMapping,
+  response: (value: Value) => 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;
+  if (!(original instanceof Function)) return;
+  const callable = original as AnyFunction;
   target[key] = wrapCreate(
-    original.bind(target) as (...args: never[]) => unknown,
+    callable.bind(target),
     request,
     response,
     () => provider,
-  ) as T[keyof T];
+  ) as AnyFunction & T[keyof T];
 }
-
 function patchPrototype(
   klass: { prototype: object },
   key: string,
-  request: (body: UnknownRecord) => RequestMapping,
-  response: (value: unknown) => SpanFields,
+  request: (body: ValueRecord) => RequestMapping,
+  response: (value: Value) => SpanFields,
 ): () => void {
-  const prototype = klass.prototype as UnknownRecord;
+  const prototype = klass.prototype as CallableRecord;
   const original = prototype[key];
-  if (typeof original !== "function" || isWrapped(original)) return () => {};
-  prototype[key] = wrapCreate(
-    original as (...args: never[]) => unknown,
-    request,
-    response,
-    providerForResource,
-  );
+  if (!(original instanceof Function) || isWrapped(original)) return () => {};
+  prototype[key] = wrapCreate(original, request, response, providerForResource);
   return () => {
     prototype[key] = original;
   };
@@ -575,13 +537,11 @@ export function wrapAnthropic<T extends AnthropicClient>(client: T): T {
   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();