@bitfab/sdk 0.75.0 → 0.76.1

package/dist/{autoTrace-kHOBg49M.js → autoTrace-BgN0zCQf.js}

@@ -101,6 +101,32 @@ function unscopedRuns() {
 	shared[UNSCOPED_RUNS_SYMBOL] = created;
 	return created;
 }
+function scopedIterator(runStorage, iterator) {
+	const scope = { recordedByHandler: false };
+	const inScope = (step) => runStorage.run(scope, step);
+	return {
+		next: (...args) => inScope(() => iterator.next(...args)),
+		return: (value) => inScope(() => iterator.return === void 0 ? Promise.resolve({
+			done: true,
+			value
+		}) : iterator.return(value)),
+		throw: (error) => inScope(() => iterator.throw === void 0 ? Promise.reject(error) : iterator.throw(error)),
+		[Symbol.asyncIterator]() {
+			return this;
+		}
+	};
+}
+function scopeStreamIterator(prototype) {
+	const original = prototype._streamIterator;
+	if (typeof original !== "function" || original[SCOPED_GENERATE_SYMBOL]) return;
+	const scoped = function(...args) {
+		const runStorage = storage();
+		const iterator = original.apply(this, args);
+		return runStorage ? scopedIterator(runStorage, iterator) : iterator;
+	};
+	scoped[SCOPED_GENERATE_SYMBOL] = true;
+	prototype._streamIterator = scoped;
+}
 function scopeGenerate(prototype) {
 	const original = prototype.generate;
 	if (typeof original !== "function" || original[SCOPED_GENERATE_SYMBOL]) return;
@@ -115,7 +141,10 @@ function scopeGenerate(prototype) {
 async function scopeModelClass(specifierParts, name) {
 	try {
 		const modelClass = (await importOptionalPeer(specifierParts))[name];
-		if (modelClass?.prototype) scopeGenerate(modelClass.prototype);
+		if (modelClass?.prototype) {
+			scopeGenerate(modelClass.prototype);
+			scopeStreamIterator(modelClass.prototype);
+		}
 	} catch {}
 }
 function installLangChainRunScopes() {
@@ -202,9 +231,25 @@ function openAiAgentsModelCallOpen() {
 	return currentOpenAiAgentsSpans().some((span) => typeof span.traceId === "string" && typeof span.spanId === "string" && state.bitfabTraceIds.has(span.traceId) && MODEL_CALL_SPAN_TYPES.has(String(span.spanData?.type)) && !state.endedSpanIds.get(span.traceId)?.has(span.spanId));
 }
 //#endregion
+//#region src/streamFinalizationError.ts
+var StreamFinalizationError = class extends Error {
+	constructor(message, output) {
+		super(message);
+		this.output = output;
+		this.name = "StreamFinalizationError";
+	}
+};
+//#endregion
 //#region src/clientCalls.ts
 const OPENROUTER_HOSTNAME = "openrouter.ai";
 const CLIENT_CALL_WATCH_STORAGE_SYMBOL = Symbol.for("bitfab.clientCallWatchStorage");
+const RESPONSE_DONE_EVENTS = [
+	"response.completed",
+	"response.incomplete",
+	"response.failed"
+];
+const TRANSCRIPT_DONE_EVENT = "transcript.text.done";
+const STREAM_END_EVENT = "end";
 const responsesRecordedByAutoTrace = /* @__PURE__ */ new WeakSet();
 function isRecord(value) {
 	return typeof value === "object" && value !== null;
@@ -219,11 +264,8 @@ function numberField(value, name) {
 function nonEmptyString(value) {
 	return typeof value === "string" && value !== "" ? value : void 0;
 }
-function presentFields(base, values, durationMs) {
-	const context = { ...base };
-	for (const [key, value] of Object.entries(values)) if (value !== void 0) context[key] = value;
-	context.durationMs = durationMs;
-	return context;
+function presentFields(values) {
+	return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
 }
 function sumOfPresent(values) {
 	const present = values.filter((value) => value !== void 0);
@@ -242,9 +284,41 @@ function roleEntries(items) {
 		}];
 	});
 }
+function isNil(value) {
+	return value === void 0 || value === null;
+}
+function isBlank(content) {
+	return isNil(content) || content === "" || Array.isArray(content) && content.length === 0;
+}
+function systemEntry(content) {
+	return isBlank(content) ? [] : [{
+		role: "system",
+		content: textOf(content)
+	}];
+}
+function userEntries(content) {
+	if (isBlank(content)) return [];
+	if (Array.isArray(content) && content.every((item) => typeof item === "string")) return content.map((item) => ({
+		role: "user",
+		content: item
+	}));
+	return [{
+		role: "user",
+		content: textOf(content)
+	}];
+}
 function renderedPrompt(entries) {
 	return entries.length > 0 ? JSON.stringify(entries) : void 0;
 }
+function modelOf(body, response) {
+	return nonEmptyString(field(response, "model")) ?? nonEmptyString(field(body, "model"));
+}
+function lastMatching(items, matches) {
+	for (let index = items.length - 1; index >= 0; index -= 1) if (matches(items[index])) return items[index];
+}
+function lastWith(events, name) {
+	return lastMatching(events, (event) => !isNil(field(event, name)));
+}
 function clientOf(receiver) {
 	try {
 		return field(receiver, "_client");
@@ -271,51 +345,143 @@ function isOpenRouterBaseUrl(baseUrl) {
 		return false;
 	}
 }
-function isOpenRouterCompletions(receiver) {
+function isOpenRouterResource(receiver) {
 	try {
 		return isOpenRouterBaseUrl(field(clientOf(receiver), "baseURL"));
 	} catch {
 		return false;
 	}
 }
-function isAnthropicMessages(receiver) {
-	return typeof clientClassStatic(receiver, "HUMAN_PROMPT") === "string";
+function isAnthropicResource(receiver) {
+	return typeof clientClassStatic(receiver, "AnthropicError") === "function" || typeof clientClassStatic(receiver, "HUMAN_PROMPT") === "string";
 }
-function isOpenAIResponses(receiver) {
+function isOpenAIResource(receiver) {
 	return typeof clientClassStatic(receiver, "OpenAI") === "function";
 }
-function isStreamingRequest(body) {
-	return field(body, "stream") === true;
+function isGeminiModels(receiver) {
+	try {
+		return isRecord(receiver) && isRecord(receiver.apiClient) && typeof receiver.generateContent === "function" && typeof receiver.generateContentStream === "function";
+	} catch {
+		return false;
+	}
+}
+function isChatCompletion(response) {
+	return isRecord(response) && Array.isArray(response.choices);
 }
-function openRouterPrompt(body) {
+function chatCompletionPrompt(body) {
 	const messages = field(body, "messages");
 	return Array.isArray(messages) ? renderedPrompt(roleEntries(messages)) : void 0;
 }
-function openRouterContext(body, response, durationMs) {
+function chatCompletionUsage(body, response) {
 	const usage = field(response, "usage");
-	return presentFields({ provider: "openrouter" }, {
-		model: nonEmptyString(field(response, "model")) ?? nonEmptyString(field(body, "model")),
+	return {
+		model: modelOf(body, response),
 		upstreamProvider: nonEmptyString(field(response, "provider")),
 		inputTokens: numberField(usage, "prompt_tokens"),
 		outputTokens: numberField(usage, "completion_tokens"),
 		cachedInputTokens: numberField(field(usage, "prompt_tokens_details"), "cached_tokens"),
 		reasoningTokens: numberField(field(usage, "completion_tokens_details"), "reasoning_tokens"),
 		costUsd: numberField(usage, "cost")
-	}, durationMs);
+	};
+}
+function chatToolCalls(chunks) {
+	const slots = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const toolCalls = field(field(firstChoice(chunk), "delta"), "tool_calls");
+		if (!Array.isArray(toolCalls)) continue;
+		for (const toolCall of toolCalls) {
+			const index = numberField(toolCall, "index") ?? 0;
+			const slot = slots.get(index) ?? { arguments: "" };
+			const fn = field(toolCall, "function");
+			const name = nonEmptyString(field(fn, "name"));
+			const args = nonEmptyString(field(fn, "arguments"));
+			slots.set(index, {
+				name: name ?? slot.name,
+				arguments: slot.arguments + (args ?? "")
+			});
+		}
+	}
+	return [...slots.entries()].sort(([left], [right]) => left - right).map(([, slot]) => ({
+		type: "function",
+		function: {
+			name: slot.name,
+			arguments: slot.arguments
+		}
+	}));
+}
+function firstChoice(chunk) {
+	const choices = field(chunk, "choices");
+	return Array.isArray(choices) ? choices[0] : void 0;
+}
+function chatStreamSummary(chunks) {
+	if (chunks.length === 0) return;
+	const last = lastWith(chunks, "usage") ?? chunks[chunks.length - 1];
+	const text = chunks.map((chunk) => field(field(firstChoice(chunk), "delta"), "content")).filter((content) => typeof content === "string").join("");
+	const finishReason = lastMatching(chunks.map((chunk) => field(firstChoice(chunk), "finish_reason")), (reason) => typeof reason === "string");
+	const toolCalls = chatToolCalls(chunks);
+	return {
+		object: "chat.completion",
+		model: field(last, "model"),
+		provider: field(last, "provider"),
+		choices: [{
+			index: 0,
+			message: {
+				role: "assistant",
+				content: text,
+				...toolCalls.length > 0 && { tool_calls: toolCalls }
+			},
+			finish_reason: finishReason ?? null
+		}],
+		usage: field(last, "usage")
+	};
+}
+function isEmbeddingList(response) {
+	return field(response, "object") === "list" && Array.isArray(field(response, "data"));
+}
+function embeddingPrompt(body) {
+	return renderedPrompt(userEntries(field(body, "input")));
+}
+function embeddingUsage(body, response) {
+	const usage = field(response, "usage");
+	const inputTokens = numberField(usage, "prompt_tokens");
+	return {
+		model: modelOf(body, response),
+		upstreamProvider: nonEmptyString(field(response, "provider")),
+		inputTokens,
+		outputTokens: inputTokens === void 0 ? void 0 : 0,
+		costUsd: numberField(usage, "cost")
+	};
+}
+function isTranscription(response) {
+	return typeof field(response, "text") === "string";
+}
+function transcriptionPrompt(body) {
+	return renderedPrompt(userEntries(field(body, "prompt")));
+}
+function transcriptionUsage(body, response) {
+	const usage = field(response, "usage");
+	return {
+		model: modelOf(body, response),
+		inputTokens: numberField(usage, "input_tokens"),
+		outputTokens: numberField(usage, "output_tokens"),
+		audioSeconds: numberField(usage, "seconds")
+	};
+}
+function transcriptionStreamSummary(events) {
+	return lastMatching(events, (event) => field(event, "type") === TRANSCRIPT_DONE_EVENT);
+}
+function isAnthropicMessage(response) {
+	return field(response, "type") === "message" && Array.isArray(field(response, "content"));
 }
 function anthropicPrompt(body) {
-	const system = field(body, "system");
 	const messages = field(body, "messages");
-	return renderedPrompt([...system === void 0 || system === null ? [] : [{
-		role: "system",
-		content: textOf(system)
-	}], ...Array.isArray(messages) ? roleEntries(messages) : []]);
+	return renderedPrompt([...systemEntry(field(body, "system")), ...Array.isArray(messages) ? roleEntries(messages) : []]);
 }
-function anthropicContext(body, response, durationMs) {
+function anthropicUsage(body, response) {
 	const usage = field(response, "usage");
 	const cacheRead = numberField(usage, "cache_read_input_tokens");
-	return presentFields({ provider: "anthropic" }, {
-		model: nonEmptyString(field(response, "model")) ?? nonEmptyString(field(body, "model")),
+	return {
+		model: modelOf(body, response),
 		inputTokens: sumOfPresent([
 			numberField(usage, "input_tokens"),
 			cacheRead,
@@ -323,16 +489,48 @@ function anthropicContext(body, response, durationMs) {
 		]),
 		outputTokens: numberField(usage, "output_tokens"),
 		cachedInputTokens: cacheRead
-	}, durationMs);
+	};
+}
+function anthropicStreamSummary(events) {
+	const message = field(events.find((event) => field(event, "type") === "message_start"), "message");
+	if (!isRecord(message)) return;
+	let usage = { ...isRecord(message.usage) ? message.usage : {} };
+	let stopReason = null;
+	const text = [];
+	for (const event of events) {
+		const type = field(event, "type");
+		if (type === "message_delta") {
+			const deltaUsage = field(event, "usage");
+			usage = {
+				...usage,
+				...isRecord(deltaUsage) ? presentFields(deltaUsage) : {}
+			};
+			stopReason = field(field(event, "delta"), "stop_reason") ?? stopReason;
+		}
+		if (type === "content_block_delta") {
+			const deltaText = field(field(event, "delta"), "text");
+			if (typeof deltaText === "string") text.push(deltaText);
+		}
+	}
+	return {
+		type: "message",
+		role: "assistant",
+		model: message.model,
+		content: [{
+			type: "text",
+			text: text.join("")
+		}],
+		stop_reason: stopReason,
+		usage
+	};
+}
+function isOpenAIResponse(response) {
+	return field(response, "object") === "response";
 }
 function openAIResponsesPrompt(body) {
-	const instructions = field(body, "instructions");
 	const input = field(body, "input");
 	return renderedPrompt([
-		...typeof instructions === "string" ? [{
-			role: "system",
-			content: instructions
-		}] : [],
+		...systemEntry(field(body, "instructions")),
 		...typeof input === "string" ? [{
 			role: "user",
 			content: input
@@ -340,54 +538,201 @@ function openAIResponsesPrompt(body) {
 		...Array.isArray(input) ? roleEntries(input) : []
 	]);
 }
-function openAIResponsesContext(body, response, durationMs) {
+function openAIResponsesUsage(body, response) {
 	const usage = field(response, "usage");
-	return presentFields({ provider: "openai" }, {
-		model: nonEmptyString(field(response, "model")) ?? nonEmptyString(field(body, "model")),
+	return {
+		model: modelOf(body, response),
 		inputTokens: numberField(usage, "input_tokens"),
 		outputTokens: numberField(usage, "output_tokens"),
 		cachedInputTokens: numberField(field(usage, "input_tokens_details"), "cached_tokens"),
 		reasoningTokens: numberField(field(usage, "output_tokens_details"), "reasoning_tokens"),
 		costUsd: numberField(usage, "cost")
-	}, durationMs);
+	};
+}
+function openAIResponsesStreamSummary(events) {
+	return field(lastMatching(events, (event) => RESPONSE_DONE_EVENTS.some((type) => field(event, "type") === type)), "response");
+}
+function isGeminiResponse(response) {
+	return field(response, "usageMetadata") !== void 0 || Array.isArray(field(response, "candidates"));
+}
+function geminiContentText(content) {
+	if (isNil(content)) return;
+	if (typeof content === "string") return content;
+	const parts = field(content, "parts");
+	if (Array.isArray(parts)) {
+		const texts = parts.map((part) => field(part, "text"));
+		if (texts.every((text) => typeof text === "string")) return texts.join("");
+	}
+	const text = field(content, "text");
+	return typeof text === "string" ? text : textOf(content);
+}
+function geminiEntries(contents) {
+	if (isNil(contents)) return [];
+	return (Array.isArray(contents) ? contents : [contents]).map((item) => ({
+		role: nonEmptyString(field(item, "role")) ?? "user",
+		content: geminiContentText(item) ?? ""
+	}));
+}
+function geminiPrompt(body) {
+	return renderedPrompt([...systemEntry(geminiContentText(field(field(body, "config"), "systemInstruction"))), ...geminiEntries(field(body, "contents"))]);
+}
+function geminiModel(body, response) {
+	const model = nonEmptyString(field(response, "modelVersion")) ?? nonEmptyString(field(body, "model"));
+	return model === void 0 ? void 0 : model.slice(model.lastIndexOf("/") + 1);
+}
+function geminiUsage(body, response) {
+	const usage = field(response, "usageMetadata");
+	const thoughts = numberField(usage, "thoughtsTokenCount");
+	return {
+		model: geminiModel(body, response),
+		inputTokens: sumOfPresent([numberField(usage, "promptTokenCount"), numberField(usage, "toolUsePromptTokenCount")]),
+		outputTokens: sumOfPresent([numberField(usage, "candidatesTokenCount"), thoughts]),
+		cachedInputTokens: numberField(usage, "cachedContentTokenCount"),
+		reasoningTokens: thoughts
+	};
+}
+function geminiChunkText(chunk) {
+	const candidates = field(chunk, "candidates");
+	return Array.isArray(candidates) ? geminiContentText(field(candidates[0], "content")) ?? "" : "";
+}
+function geminiStreamSummary(chunks) {
+	if (chunks.length === 0) return;
+	const last = lastWith(chunks, "usageMetadata") ?? chunks[chunks.length - 1];
+	return {
+		modelVersion: field(last, "modelVersion"),
+		text: chunks.map(geminiChunkText).join(""),
+		usageMetadata: field(last, "usageMetadata")
+	};
 }
 const OPENROUTER = {
 	key: "openrouter",
+	provider: "openrouter",
 	library: "openai",
-	matchesReceiver: isOpenRouterCompletions,
-	isResponse: (response) => isRecord(response) && Array.isArray(response.choices),
-	prompt: openRouterPrompt,
-	context: openRouterContext
+	endpoint: "chat.completions",
+	methods: ["create", "parse"],
+	streamMethods: ["stream"],
+	streamEvents: ["chunk"],
+	spanMethods: { stream: "create" },
+	matchesReceiver: isOpenRouterResource,
+	isResponse: isChatCompletion,
+	prompt: chatCompletionPrompt,
+	usage: chatCompletionUsage,
+	streamSummary: chatStreamSummary
+};
+const OPENAI_CHAT = {
+	...OPENROUTER,
+	key: "openai-chat",
+	provider: "openai",
+	matchesReceiver: isOpenAIResource
+};
+const OPENROUTER_EMBEDDINGS = {
+	key: "openrouter-embeddings",
+	provider: "openrouter",
+	library: "openai",
+	endpoint: "embeddings",
+	methods: ["create"],
+	streamMethods: [],
+	streamEvents: [],
+	matchesReceiver: isOpenRouterResource,
+	isResponse: isEmbeddingList,
+	prompt: embeddingPrompt,
+	usage: embeddingUsage
+};
+const OPENAI_EMBEDDINGS = {
+	...OPENROUTER_EMBEDDINGS,
+	key: "openai-embeddings",
+	provider: "openai",
+	matchesReceiver: isOpenAIResource
+};
+const OPENAI_TRANSCRIPTIONS = {
+	key: "openai-transcriptions",
+	provider: "openai",
+	library: "openai",
+	endpoint: "audio.transcriptions",
+	methods: ["create"],
+	streamMethods: [],
+	streamEvents: [],
+	matchesReceiver: isOpenAIResource,
+	isResponse: isTranscription,
+	prompt: transcriptionPrompt,
+	usage: transcriptionUsage,
+	streamSummary: transcriptionStreamSummary
 };
 const ANTHROPIC = {
 	key: "anthropic",
+	provider: "anthropic",
 	library: "@anthropic-ai/sdk",
-	matchesReceiver: isAnthropicMessages,
-	isResponse: (response) => field(response, "type") === "message" && Array.isArray(field(response, "content")),
+	endpoint: "messages",
+	methods: ["create", "parse"],
+	streamMethods: ["stream"],
+	streamEvents: ["streamEvent"],
+	matchesReceiver: isAnthropicResource,
+	isResponse: isAnthropicMessage,
 	prompt: anthropicPrompt,
-	context: anthropicContext
+	usage: anthropicUsage,
+	streamSummary: anthropicStreamSummary
 };
 const OPENAI_RESPONSES = {
 	key: "openai-responses",
+	provider: "openai",
 	library: "openai",
-	matchesReceiver: isOpenAIResponses,
-	isResponse: (response) => field(response, "object") === "response",
+	endpoint: "responses",
+	methods: ["create", "parse"],
+	streamMethods: ["stream"],
+	streamEvents: RESPONSE_DONE_EVENTS,
+	spanMethods: { stream: "create" },
+	matchesReceiver: isOpenAIResource,
+	isResponse: isOpenAIResponse,
 	prompt: openAIResponsesPrompt,
-	context: openAIResponsesContext
+	usage: openAIResponsesUsage,
+	streamSummary: openAIResponsesStreamSummary
+};
+const GEMINI = {
+	key: "gemini",
+	provider: "gemini",
+	library: "@google/genai",
+	endpoint: "models",
+	methods: ["generateContent"],
+	streamMethods: ["generateContentStream"],
+	streamEvents: [],
+	matchesReceiver: isGeminiModels,
+	isResponse: isGeminiResponse,
+	prompt: geminiPrompt,
+	usage: geminiUsage,
+	streamSummary: geminiStreamSummary
 };
-const CLIENT_CALL_PROVIDERS = new Map([
+const CLIENT_CALL_PROVIDERS = [
 	OPENROUTER,
+	OPENAI_CHAT,
+	OPENROUTER_EMBEDDINGS,
+	OPENAI_EMBEDDINGS,
+	OPENAI_TRANSCRIPTIONS,
 	ANTHROPIC,
-	OPENAI_RESPONSES
-].map((provider) => [provider.key, provider]));
+	OPENAI_RESPONSES,
+	GEMINI
+];
+const CLIENT_CALL_PROVIDERS_BY_KEY = new Map(CLIENT_CALL_PROVIDERS.map((provider) => [provider.key, provider]));
 function clientCallProvider(key) {
-	return key === void 0 ? void 0 : CLIENT_CALL_PROVIDERS.get(key);
+	return key === void 0 ? void 0 : CLIENT_CALL_PROVIDERS_BY_KEY.get(key);
+}
+function providerForClientCall(endpoint, method, receiver) {
+	return CLIENT_CALL_PROVIDERS.find((provider) => provider.endpoint === endpoint && (provider.methods.includes(method) || provider.streamMethods.includes(method)) && provider.matchesReceiver(receiver));
+}
+function clientCallStreams(provider, method, body) {
+	return provider.streamMethods.includes(method) || field(body, "stream") === true;
+}
+function clientCallContext(provider, body, response, durationMs) {
+	return {
+		provider: provider.provider,
+		...presentFields(provider.usage(body, response)),
+		durationMs
+	};
 }
 function recordClientCall(provider, span, body, response, durationMs) {
 	try {
 		const prompt = provider.prompt(body);
 		if (prompt !== void 0) span.setPrompt(prompt);
-		span.addContext(provider.context(body, response, durationMs));
+		span.addContext(clientCallContext(provider, body, response, durationMs));
 	} catch {}
 }
 let clientCallWatchStorage = null;
@@ -413,6 +758,12 @@ function watchClientCall(fn) {
 function markEnclosingWatches(watch) {
 	for (let current = watch.parent; current; current = current.parent) current.recorded = true;
 }
+function markCurrentWatches() {
+	markEnclosingWatches({
+		recorded: true,
+		parent: watchStorage()?.getStore() ?? null
+	});
+}
 function frameworkRecordsClientCall() {
 	return langChainHandlerRecordsCall() || openAiAgentsModelCallOpen();
 }
@@ -442,6 +793,147 @@ function recordAutoTracedClientCall(provider, invokeFn, body, span) {
 	settle(result);
 	return result;
 }
+function isThenable(value) {
+	return isRecord(value) && typeof value.then === "function";
+}
+function isIteratorStream(value) {
+	return isRecord(value) && typeof value.iterator === "function";
+}
+function isEventStream(value) {
+	return isRecord(value) && typeof value.on === "function";
+}
+function isAsyncIterator(value) {
+	return isRecord(value) && typeof value.next === "function";
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+const streamRecordingsByCall = /* @__PURE__ */ new WeakMap();
+const droppedStreams = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((recording) => recording.finish(void 0)) : void 0;
+function sharedClientCallStreamRecording(call, provider, body) {
+	let recording = streamRecordingsByCall.get(call);
+	if (recording === void 0) {
+		recording = new ClientCallStreamRecording(provider, body);
+		streamRecordingsByCall.set(call, recording);
+	}
+	return recording;
+}
+var ClientCallStreamRecording = class {
+	constructor(provider, body) {
+		this.provider = provider;
+		this.body = body;
+		this.events = [];
+		this.startedAt = Date.now();
+		this.finished = false;
+		this.observing = false;
+		this.resolveDone = () => {};
+		this.rejectDone = () => {};
+		this.done = new Promise((resolve, reject) => {
+			this.resolveDone = resolve;
+			this.rejectDone = reject;
+		});
+		this.done.catch(() => {});
+	}
+	start(span, invokeFn) {
+		this.span ?? (this.span = span);
+		markCurrentWatches();
+		let result;
+		try {
+			result = invokeFn();
+		} catch (error) {
+			this.finish(error);
+			throw error;
+		}
+		if (this.observing) return result;
+		this.observing = true;
+		if (isThenable(result)) result.then((stream) => this.observe(stream), (error) => this.finish(error));
+		else this.observe(result);
+		return result;
+	}
+	observe(stream) {
+		if (isRecord(stream)) droppedStreams?.register(stream, this);
+		try {
+			if (isIteratorStream(stream)) {
+				const iterator = stream.iterator;
+				stream.iterator = () => this.observed(iterator.call(stream));
+				return;
+			}
+			if (isEventStream(stream)) {
+				for (const name of this.provider.streamEvents) stream.on(name, (event) => {
+					this.events.push(event);
+				});
+				stream.on(STREAM_END_EVENT, () => {
+					this.finish(stream.errored === true && stream.aborted !== true ? /* @__PURE__ */ new Error("The stream failed") : void 0);
+				});
+				return;
+			}
+			if (isAsyncIterator(stream)) {
+				const observed = this.observed({
+					next: stream.next.bind(stream),
+					return: stream.return?.bind(stream),
+					throw: stream.throw?.bind(stream)
+				});
+				stream.next = observed.next;
+				stream.return = observed.return;
+				stream.throw = observed.throw;
+				return;
+			}
+		} catch {}
+		this.finish(void 0);
+	}
+	observed(iterator) {
+		const next = async (...args) => {
+			try {
+				const result = await iterator.next(...args);
+				if (result.done === true) this.finish(void 0);
+				else this.events.push(result.value);
+				return result;
+			} catch (error) {
+				this.finish(error);
+				throw error;
+			}
+		};
+		const end = async (value) => {
+			try {
+				return iterator.return === void 0 ? {
+					done: true,
+					value
+				} : await iterator.return(value);
+			} finally {
+				this.finish(void 0);
+			}
+		};
+		const fail = async (error) => {
+			try {
+				if (iterator.throw === void 0) throw error;
+				return await iterator.throw(error);
+			} catch (raised) {
+				this.finish(raised);
+				throw raised;
+			}
+		};
+		const observed = {
+			next,
+			return: end,
+			throw: fail,
+			[Symbol.asyncIterator]: () => observed
+		};
+		return observed;
+	}
+	finish(error) {
+		if (this.finished) return;
+		this.finished = true;
+		let summary;
+		try {
+			summary = this.events.length === 0 ? void 0 : this.provider.streamSummary?.(this.events);
+			const prompt = this.provider.prompt(this.body);
+			if (prompt !== void 0) this.span?.setPrompt(prompt);
+			if (!isNil(summary)) this.span?.addContext(clientCallContext(this.provider, this.body, summary, Date.now() - this.startedAt));
+		} catch {}
+		if (error === void 0) this.resolveDone(summary);
+		else this.rejectDone(new StreamFinalizationError(errorText(error), summary));
+	}
+};
 //#endregion
 //#region src/autoTrace.ts
 const autoTraceGlobal = globalThis;
@@ -676,11 +1168,13 @@ function invokeRecordedClientCall(definition, args, call) {
 			throw error;
 		}
 	});
-	if (outcome === void 0) return traced;
-	if ("value" in outcome && traced === outcome.value) return traced;
+	const settled = outcome;
+	outcome = void 0;
+	if (settled === void 0) return traced;
+	if ("value" in settled && traced === settled.value) return traced;
 	if (traced instanceof Promise) holdAutoTraceRoots(traced);
-	if ("error" in outcome) throw outcome.error;
-	return outcome.value;
+	if ("error" in settled) throw settled.error;
+	return settled.value;
 }
 function jevDefinition(receiver) {
 	const className = receiverClassName(receiver);
@@ -705,40 +1199,42 @@ function __bitfabAutoJev(receiver, ...args) {
 	if (!__bitfabAutoTraceActive()) return target.systemOne(...args);
 	return invokeRecordedClientCall(jevDefinition(receiver), args, () => target.systemOne(...args));
 }
-const CLIENT_CALL_METHOD = "create";
 const clientCallDefinitions = /* @__PURE__ */ new Map();
-function clientCallDefinition(provider, receiver) {
+function clientCallDefinition(provider, receiver, method) {
 	const className = receiverClassName(receiver);
-	const name = className === void 0 ? CLIENT_CALL_METHOD : `${className}.${CLIENT_CALL_METHOD}`;
-	const id = `ts-auto-v1:${provider.key}#${name}`;
+	const qualified = (methodName) => className === void 0 ? methodName : `${className}.${methodName}`;
+	const id = `ts-auto-v1:${provider.key}#${qualified(method)}`;
 	let definition = clientCallDefinitions.get(id);
 	if (definition === void 0) {
 		definition = {
 			id,
-			name,
+			name: qualified(provider.spanMethods?.[method] ?? method),
 			file: provider.library,
 			line: 0,
 			column: 0,
 			async: true,
-			clientCall: provider.key
+			clientCall: provider.key,
+			clientCallMethod: method
 		};
 		clientCallDefinitions.set(id, definition);
 	}
 	return definition;
 }
-function invokeClientCall(provider, receiver, args) {
-	const target = receiver;
-	if (!__bitfabAutoTraceActive() || isStreamingRequest(args[0]) || !provider.matchesReceiver(receiver) || frameworkRecordsClientCall()) return target.create(...args);
-	return invokeRecordedClientCall(clientCallDefinition(provider, receiver), args, () => target.create(...args));
+function __bitfabAutoClientCall(endpoint, receiver, method, ...args) {
+	const call = () => Reflect.apply(receiver[method], receiver, args);
+	if (!__bitfabAutoTraceActive()) return call();
+	const provider = providerForClientCall(endpoint, method, receiver);
+	if (provider === void 0 || clientCallStreams(provider, method, args[0]) && provider.streamSummary === void 0 || frameworkRecordsClientCall()) return call();
+	return invokeRecordedClientCall(clientCallDefinition(provider, receiver, method), args, call);
 }
 function __bitfabAutoOpenRouter(receiver, ...args) {
-	return invokeClientCall(OPENROUTER, receiver, args);
+	return __bitfabAutoClientCall("chat.completions", receiver, "create", ...args);
 }
 function __bitfabAutoAnthropic(receiver, ...args) {
-	return invokeClientCall(ANTHROPIC, receiver, args);
+	return __bitfabAutoClientCall("messages", receiver, "create", ...args);
 }
 function __bitfabAutoOpenAIResponses(receiver, ...args) {
-	return invokeClientCall(OPENAI_RESPONSES, receiver, args);
+	return __bitfabAutoClientCall("responses", receiver, "create", ...args);
 }
 function __bitfabAutoWrap(definition, fn) {
 	noteTransformedModule();
@@ -767,6 +1263,6 @@ function _resetAutoTraceTransformDetection() {
 	autoTraceGlobal.__bitfab_auto_trace_transformed_v1__ = void 0;
 }
 //#endregion
-export { unmapOpenAiAgentsTrace as A, asyncStorageReady as B, recordAutoTracedClientCall as C, mapOpenAiAgentsTrace as D, endOpenAiAgentsSpan as E, warnOnce as F, isAsyncStorageInitDone as H, writeOnce as I, isCaptureSuppressed as L, installLangChainRunScopes as M, markLangChainRunRecorded as N, openAiAgentsParentSpanId as O, warn as P, runWithCaptureSuppressed as R, frameworkRecordsClientCall as S, watchClientCall as T, registerAsyncLocalStorageClass as U, createAsyncLocalStorage as V, runWithAutoTraceRootContext as _, __bitfabAutoSpan as a, OPENROUTER as b, _resetAutoTraceTransformDetection as c, invokeAsDiscoveredCall as d, invokeThroughAutoTraceEntries as f, runWithAutoTraceNodeConfiguration as g, runWithAutoTraceFramesAt as h, __bitfabAutoOpenRouter as i, forgetLangChainRun as j, openAiAgentsSpanChain as k, clearAutoTraceNodeConfiguration as l, runWithAutoTraceEntry as m, __bitfabAutoJev as n, __bitfabAutoTraceActive as o, runAsAutoTraceRootFunction as p, __bitfabAutoOpenAIResponses as r, __bitfabAutoWrap as s, __bitfabAutoAnthropic as t, currentAutoTraceEntries as u, ANTHROPIC as v, recordWatchedClientCall as w, clientCallProvider as x, OPENAI_RESPONSES as y, assertAsyncStorageRegistered as z };
+export { recordWatchedClientCall as A, installLangChainRunScopes as B, OPENAI_RESPONSES as C, clientCallStreams as D, clientCallProvider as E, mapOpenAiAgentsTrace as F, isCaptureSuppressed as G, warn as H, openAiAgentsParentSpanId as I, asyncStorageReady as J, runWithCaptureSuppressed as K, openAiAgentsSpanChain as L, watchClientCall as M, StreamFinalizationError as N, frameworkRecordsClientCall as O, endOpenAiAgentsSpan as P, unmapOpenAiAgentsTrace as R, OPENAI_EMBEDDINGS as S, OPENROUTER as T, warnOnce as U, markLangChainRunRecorded as V, writeOnce as W, isAsyncStorageInitDone as X, createAsyncLocalStorage as Y, registerAsyncLocalStorageClass as Z, runWithAutoTraceNodeConfiguration as _, __bitfabAutoOpenRouter as a, GEMINI as b, __bitfabAutoWrap as c, currentAutoTraceEntries as d, invokeAsDiscoveredCall as f, runWithAutoTraceFramesAt as g, runWithAutoTraceEntry as h, __bitfabAutoOpenAIResponses as i, sharedClientCallStreamRecording as j, recordAutoTracedClientCall as k, _resetAutoTraceTransformDetection as l, runAsAutoTraceRootFunction as m, __bitfabAutoClientCall as n, __bitfabAutoSpan as o, invokeThroughAutoTraceEntries as p, assertAsyncStorageRegistered as q, __bitfabAutoJev as r, __bitfabAutoTraceActive as s, __bitfabAutoAnthropic as t, clearAutoTraceNodeConfiguration as u, runWithAutoTraceRootContext as v, OPENAI_TRANSCRIPTIONS as w, OPENAI_CHAT as x, ANTHROPIC as y, forgetLangChainRun as z };
 
-//# sourceMappingURL=autoTrace-kHOBg49M.js.map
+//# sourceMappingURL=autoTrace-BgN0zCQf.js.map