@fased/fased 0.1.58 → 0.1.59

package/dist/agents/anthropic-transport-stream.js

@@ -0,0 +1,736 @@
+import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./copilot-dynamic-headers.js";
+import { applyAnthropicPayloadPolicyToParams, resolveAnthropicPayloadPolicy } from "./anthropic-payload-policy.js";
+import { buildGuardedModelFetch } from "./provider-transport-fetch.js";
+import { transformTransportMessages } from "./transport-message-transform.js";
+import { createEmptyTransportUsage, createWritableTransportEventStream, failTransportStream, finalizeTransportStream, mergeTransportHeaders, sanitizeTransportPayloadText } from "./transport-stream-shared.js";
+import { calculateCost, getEnvApiKey, parseStreamingJson } from "@mariozechner/pi-ai/compat";
+
+//#region src/agents/anthropic-transport-stream.ts
+const CLAUDE_CODE_VERSION = "2.1.75";
+const CLAUDE_CODE_TOOLS = [
+	"Read",
+	"Write",
+	"Edit",
+	"Bash",
+	"Grep",
+	"Glob",
+	"AskUserQuestion",
+	"EnterPlanMode",
+	"ExitPlanMode",
+	"KillShell",
+	"NotebookEdit",
+	"Skill",
+	"Task",
+	"TaskOutput",
+	"TodoWrite",
+	"WebFetch",
+	"WebSearch"
+];
+const CLAUDE_CODE_TOOL_LOOKUP = new Map(CLAUDE_CODE_TOOLS.map((tool) => [tool.toLowerCase(), tool]));
+function supportsAdaptiveThinking(modelId) {
+	return modelId.includes("opus-4-6") || modelId.includes("opus-4.6") || modelId.includes("sonnet-4-6") || modelId.includes("sonnet-4.6");
+}
+function mapThinkingLevelToEffort(level, modelId) {
+	switch (level) {
+		case "minimal":
+		case "low": return "low";
+		case "medium": return "medium";
+		case "xhigh": return modelId.includes("opus-4-6") || modelId.includes("opus-4.6") ? "max" : "high";
+		default: return "high";
+	}
+}
+function clampReasoningLevel(level) {
+	return level === "xhigh" ? "high" : level;
+}
+function adjustMaxTokensForThinking(params) {
+	const budgets = {
+		minimal: 1024,
+		low: 2048,
+		medium: 8192,
+		high: 16384,
+		...params.customBudgets
+	};
+	const minOutputTokens = 1024;
+	const level = clampReasoningLevel(params.reasoningLevel);
+	let thinkingBudget = budgets[level];
+	const maxTokens = Math.min(params.baseMaxTokens + thinkingBudget, params.modelMaxTokens);
+	if (maxTokens <= thinkingBudget) {
+		thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
+	}
+	return {
+		maxTokens,
+		thinkingBudget
+	};
+}
+function isAnthropicOAuthToken(apiKey) {
+	return apiKey.includes("sk-ant-oat");
+}
+function toClaudeCodeName(name) {
+	return CLAUDE_CODE_TOOL_LOOKUP.get(name.toLowerCase()) ?? name;
+}
+function fromClaudeCodeName(name, tools) {
+	if (tools && tools.length > 0) {
+		const lowerName = name.toLowerCase();
+		const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
+		if (matchedTool) {
+			return matchedTool.name;
+		}
+	}
+	return name;
+}
+function resolveAnthropicMessagesEndpoint(baseURL) {
+	const base = (baseURL?.trim() || "https://api.anthropic.com").replace(/\/+$/, "");
+	return base.endsWith("/v1") ? `${base}/messages` : `${base}/v1/messages`;
+}
+async function* parseAnthropicServerSentJson(response) {
+	if (!response.body) {
+		const text = await response.text();
+		for (const line of text.split(/\r?\n/)) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed === "[DONE]") {
+				continue;
+			}
+			yield JSON.parse(trimmed);
+		}
+		return;
+	}
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const emitBlock = function* (block) {
+		const data = block.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).trim()).join("\n").trim();
+		if (!data || data === "[DONE]") {
+			return;
+		}
+		yield JSON.parse(data);
+	};
+	while (true) {
+		const chunk = await reader.read();
+		if (chunk.done) {
+			break;
+		}
+		buffer += decoder.decode(chunk.value, { stream: true });
+		let boundary = buffer.indexOf("\n\n");
+		while (boundary >= 0) {
+			const block = buffer.slice(0, boundary);
+			buffer = buffer.slice(boundary + 2);
+			for (const event of emitBlock(block)) {
+				yield event;
+			}
+			boundary = buffer.indexOf("\n\n");
+		}
+	}
+	buffer += decoder.decode();
+	if (buffer.trim()) {
+		for (const event of emitBlock(buffer)) {
+			yield event;
+		}
+	}
+}
+function createAnthropicMessagesClient(params) {
+	return { messages: { stream: async (payload, options) => {
+		const response = await params.fetch(resolveAnthropicMessagesEndpoint(params.baseURL), {
+			method: "POST",
+			headers: {
+				accept: "text/event-stream",
+				"content-type": "application/json",
+				"anthropic-version": "2023-06-01",
+				...params.authKind === "bearer" ? { authorization: `Bearer ${params.apiKey}` } : { "x-api-key": params.apiKey },
+				...params.defaultHeaders
+			},
+			body: JSON.stringify(payload),
+			signal: options?.signal
+		});
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new Error(`Anthropic transport request failed (${response.status} ${response.statusText})${text ? `: ${text.slice(0, 500)}` : ""}`);
+		}
+		return parseAnthropicServerSentJson(response);
+	} } };
+}
+function convertContentBlocks(content) {
+	const hasImages = content.some((item) => item.type === "image");
+	if (!hasImages) {
+		return sanitizeTransportPayloadText(content.map((item) => "text" in item ? item.text : "").join("\n"));
+	}
+	const blocks = content.map((block) => {
+		if (block.type === "text") {
+			return {
+				type: "text",
+				text: sanitizeTransportPayloadText(block.text)
+			};
+		}
+		return {
+			type: "image",
+			source: {
+				type: "base64",
+				media_type: block.mimeType,
+				data: block.data
+			}
+		};
+	});
+	if (!blocks.some((block) => block.type === "text")) {
+		blocks.unshift({
+			type: "text",
+			text: "(see attached image)"
+		});
+	}
+	return blocks;
+}
+function normalizeToolCallId(id) {
+	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function convertAnthropicMessages(messages, model, isOAuthToken) {
+	const params = [];
+	const transformedMessages = transformTransportMessages(messages, model, normalizeToolCallId);
+	for (let i = 0; i < transformedMessages.length; i += 1) {
+		const msg = transformedMessages[i];
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") {
+				if (msg.content.trim().length > 0) {
+					params.push({
+						role: "user",
+						content: sanitizeTransportPayloadText(msg.content)
+					});
+				}
+				continue;
+			}
+			const blocks = msg.content.map((item) => item.type === "text" ? {
+				type: "text",
+				text: sanitizeTransportPayloadText(item.text)
+			} : {
+				type: "image",
+				source: {
+					type: "base64",
+					media_type: item.mimeType,
+					data: item.data
+				}
+			});
+			let filteredBlocks = model.input.includes("image") ? blocks : blocks.filter((block) => block.type !== "image");
+			filteredBlocks = filteredBlocks.filter((block) => block.type !== "text" || block.text.trim().length > 0);
+			if (filteredBlocks.length === 0) {
+				continue;
+			}
+			params.push({
+				role: "user",
+				content: filteredBlocks
+			});
+			continue;
+		}
+		if (msg.role === "assistant") {
+			const blocks = [];
+			for (const block of msg.content) {
+				if (block.type === "text") {
+					if (block.text.trim().length > 0) {
+						blocks.push({
+							type: "text",
+							text: sanitizeTransportPayloadText(block.text)
+						});
+					}
+					continue;
+				}
+				if (block.type === "thinking") {
+					const thinkingBlock = block;
+					if (thinkingBlock.redacted) {
+						blocks.push({
+							type: "redacted_thinking",
+							data: thinkingBlock.thinkingSignature
+						});
+						continue;
+					}
+					if (block.thinking.trim().length === 0) {
+						continue;
+					}
+					if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
+						blocks.push({
+							type: "text",
+							text: sanitizeTransportPayloadText(block.thinking)
+						});
+					} else {
+						blocks.push({
+							type: "thinking",
+							thinking: sanitizeTransportPayloadText(block.thinking),
+							signature: block.thinkingSignature
+						});
+					}
+					continue;
+				}
+				if (block.type === "toolCall") {
+					blocks.push({
+						type: "tool_use",
+						id: block.id,
+						name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
+						input: block.arguments ?? {}
+					});
+				}
+			}
+			if (blocks.length > 0) {
+				params.push({
+					role: "assistant",
+					content: blocks
+				});
+			}
+			continue;
+		}
+		if (msg.role === "toolResult") {
+			const toolResult = msg;
+			const toolResults = [{
+				type: "tool_result",
+				tool_use_id: toolResult.toolCallId,
+				content: convertContentBlocks(toolResult.content),
+				is_error: toolResult.isError
+			}];
+			let j = i + 1;
+			while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
+				const nextMsg = transformedMessages[j];
+				toolResults.push({
+					type: "tool_result",
+					tool_use_id: nextMsg.toolCallId,
+					content: convertContentBlocks(nextMsg.content),
+					is_error: nextMsg.isError
+				});
+				j += 1;
+			}
+			i = j - 1;
+			params.push({
+				role: "user",
+				content: toolResults
+			});
+		}
+	}
+	return params;
+}
+function convertAnthropicTools(tools, isOAuthToken) {
+	if (!tools) {
+		return [];
+	}
+	return tools.map((tool) => ({
+		name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
+		description: tool.description,
+		input_schema: {
+			type: "object",
+			properties: tool.parameters.properties || {},
+			required: tool.parameters.required || []
+		}
+	}));
+}
+function mapStopReason(reason) {
+	switch (reason) {
+		case "end_turn": return "stop";
+		case "max_tokens": return "length";
+		case "tool_use": return "toolUse";
+		case "pause_turn": return "stop";
+		case "refusal":
+		case "sensitive": return "error";
+		case "stop_sequence": return "stop";
+		default: throw new Error(`Unhandled stop reason: ${String(reason)}`);
+	}
+}
+function createAnthropicTransportClient(params) {
+	const { model, context, apiKey, options } = params;
+	const needsInterleavedBeta = (options?.interleavedThinking ?? true) && !supportsAdaptiveThinking(model.id);
+	const fetch = buildGuardedModelFetch(model);
+	if (model.provider === "github-copilot") {
+		const betaFeatures = needsInterleavedBeta ? ["interleaved-thinking-2025-05-14"] : [];
+		return {
+			client: createAnthropicMessagesClient({
+				apiKey,
+				authKind: "bearer",
+				baseURL: model.baseUrl,
+				defaultHeaders: mergeTransportHeaders({
+					accept: "application/json",
+					"anthropic-dangerous-direct-browser-access": "true",
+					...betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}
+				}, model.headers, buildCopilotDynamicHeaders({
+					messages: context.messages,
+					hasImages: hasCopilotVisionInput(context.messages)
+				}), options?.headers),
+				fetch
+			}),
+			isOAuthToken: false
+		};
+	}
+	const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
+	if (needsInterleavedBeta) {
+		betaFeatures.push("interleaved-thinking-2025-05-14");
+	}
+	if (isAnthropicOAuthToken(apiKey)) {
+		return {
+			client: createAnthropicMessagesClient({
+				apiKey,
+				authKind: "bearer",
+				baseURL: model.baseUrl,
+				defaultHeaders: mergeTransportHeaders({
+					accept: "application/json",
+					"anthropic-dangerous-direct-browser-access": "true",
+					"anthropic-beta": `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}`,
+					"user-agent": `claude-cli/${CLAUDE_CODE_VERSION}`,
+					"x-app": "cli"
+				}, model.headers, options?.headers),
+				fetch
+			}),
+			isOAuthToken: true
+		};
+	}
+	return {
+		client: createAnthropicMessagesClient({
+			apiKey,
+			authKind: "api_key",
+			baseURL: model.baseUrl,
+			defaultHeaders: mergeTransportHeaders({
+				accept: "application/json",
+				"anthropic-dangerous-direct-browser-access": "true",
+				"anthropic-beta": betaFeatures.join(",")
+			}, model.headers, options?.headers),
+			fetch
+		}),
+		isOAuthToken: false
+	};
+}
+function buildAnthropicParams(model, context, isOAuthToken, options) {
+	const payloadPolicy = resolveAnthropicPayloadPolicy({
+		provider: model.provider,
+		api: model.api,
+		baseUrl: model.baseUrl,
+		cacheRetention: options?.cacheRetention,
+		enableCacheControl: true
+	});
+	const defaultMaxTokens = Math.min(model.maxTokens, 32e3);
+	const params = {
+		model: model.id,
+		messages: convertAnthropicMessages(context.messages, model, isOAuthToken),
+		max_tokens: options?.maxTokens || defaultMaxTokens,
+		stream: true
+	};
+	if (isOAuthToken) {
+		params.system = [{
+			type: "text",
+			text: "You are Claude Code, Anthropic's official CLI for Claude."
+		}, ...context.systemPrompt ? [{
+			type: "text",
+			text: sanitizeTransportPayloadText(context.systemPrompt)
+		}] : []];
+	} else if (context.systemPrompt) {
+		params.system = [{
+			type: "text",
+			text: sanitizeTransportPayloadText(context.systemPrompt)
+		}];
+	}
+	if (options?.temperature !== undefined && !options.thinkingEnabled) {
+		params.temperature = options.temperature;
+	}
+	if (context.tools) {
+		params.tools = convertAnthropicTools(context.tools, isOAuthToken);
+	}
+	if (model.reasoning) {
+		if (options?.thinkingEnabled) {
+			if (supportsAdaptiveThinking(model.id)) {
+				params.thinking = { type: "adaptive" };
+				if (options.effort) {
+					params.output_config = { effort: options.effort };
+				}
+			} else {
+				params.thinking = {
+					type: "enabled",
+					budget_tokens: options.thinkingBudgetTokens || 1024
+				};
+			}
+		} else if (options?.thinkingEnabled === false) {
+			params.thinking = { type: "disabled" };
+		}
+	}
+	if (options?.metadata && typeof options.metadata.user_id === "string") {
+		params.metadata = { user_id: options.metadata.user_id };
+	}
+	if (options?.toolChoice) {
+		params.tool_choice = typeof options.toolChoice === "string" ? { type: options.toolChoice } : options.toolChoice;
+	}
+	applyAnthropicPayloadPolicyToParams(params, payloadPolicy);
+	return params;
+}
+function resolveAnthropicTransportOptions(model, options, apiKey) {
+	const baseMaxTokens = options?.maxTokens || Math.min(model.maxTokens, 32e3);
+	const resolved = {
+		temperature: options?.temperature,
+		maxTokens: baseMaxTokens,
+		signal: options?.signal,
+		apiKey,
+		cacheRetention: options?.cacheRetention,
+		sessionId: options?.sessionId,
+		headers: options?.headers,
+		onPayload: options?.onPayload,
+		maxRetryDelayMs: options?.maxRetryDelayMs,
+		metadata: options?.metadata,
+		interleavedThinking: options?.interleavedThinking,
+		toolChoice: options?.toolChoice,
+		thinkingBudgets: options?.thinkingBudgets,
+		reasoning: options?.reasoning
+	};
+	if (!options?.reasoning) {
+		resolved.thinkingEnabled = false;
+		return resolved;
+	}
+	if (supportsAdaptiveThinking(model.id)) {
+		resolved.thinkingEnabled = true;
+		resolved.effort = mapThinkingLevelToEffort(options.reasoning, model.id);
+		return resolved;
+	}
+	const adjusted = adjustMaxTokensForThinking({
+		baseMaxTokens,
+		modelMaxTokens: model.maxTokens,
+		reasoningLevel: options.reasoning,
+		customBudgets: options.thinkingBudgets
+	});
+	resolved.maxTokens = adjusted.maxTokens;
+	resolved.thinkingEnabled = true;
+	resolved.thinkingBudgetTokens = adjusted.thinkingBudget;
+	return resolved;
+}
+function createAnthropicMessagesTransportStreamFn() {
+	return (rawModel, context, rawOptions) => {
+		const model = rawModel;
+		const options = rawOptions;
+		const { eventStream, stream } = createWritableTransportEventStream();
+		void (async () => {
+			const output = {
+				role: "assistant",
+				content: [],
+				api: "anthropic-messages",
+				provider: model.provider,
+				model: model.id,
+				usage: createEmptyTransportUsage(),
+				stopReason: "stop",
+				timestamp: Date.now()
+			};
+			try {
+				const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
+				if (!apiKey) {
+					throw new Error(`No API key for provider: ${model.provider}`);
+				}
+				const transportOptions = resolveAnthropicTransportOptions(model, options, apiKey);
+				const { client, isOAuthToken } = createAnthropicTransportClient({
+					model,
+					context,
+					apiKey,
+					options: transportOptions
+				});
+				let params = buildAnthropicParams(model, context, isOAuthToken, transportOptions);
+				const onPayload = transportOptions.onPayload;
+				const nextParams = await Promise.resolve(onPayload?.(params, model));
+				if (nextParams !== undefined) {
+					params = nextParams;
+				}
+				const anthropicStream = await client.messages.stream({
+					...params,
+					stream: true
+				}, transportOptions.signal ? { signal: transportOptions.signal } : undefined);
+				stream.push({
+					type: "start",
+					partial: output
+				});
+				const blocks = output.content;
+				for await (const event of anthropicStream) {
+					if (event.type === "message_start") {
+						const message = event.message;
+						const usage = message?.usage ?? {};
+						output.responseId = typeof message?.id === "string" ? message.id : undefined;
+						output.usage.input = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+						output.usage.output = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+						output.usage.cacheRead = typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : 0;
+						output.usage.cacheWrite = typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : 0;
+						output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+						calculateCost(model, output.usage);
+						continue;
+					}
+					if (event.type === "content_block_start") {
+						const contentBlock = event.content_block;
+						const index = typeof event.index === "number" ? event.index : -1;
+						if (contentBlock?.type === "text") {
+							const block = {
+								type: "text",
+								text: "",
+								index
+							};
+							output.content.push(block);
+							stream.push({
+								type: "text_start",
+								contentIndex: output.content.length - 1,
+								partial: output
+							});
+							continue;
+						}
+						if (contentBlock?.type === "thinking") {
+							const block = {
+								type: "thinking",
+								thinking: "",
+								thinkingSignature: "",
+								index
+							};
+							output.content.push(block);
+							stream.push({
+								type: "thinking_start",
+								contentIndex: output.content.length - 1,
+								partial: output
+							});
+							continue;
+						}
+						if (contentBlock?.type === "redacted_thinking") {
+							const block = {
+								type: "thinking",
+								thinking: "[Reasoning redacted]",
+								thinkingSignature: typeof contentBlock.data === "string" ? contentBlock.data : "",
+								redacted: true,
+								index
+							};
+							output.content.push(block);
+							stream.push({
+								type: "thinking_start",
+								contentIndex: output.content.length - 1,
+								partial: output
+							});
+							continue;
+						}
+						if (contentBlock?.type === "tool_use") {
+							const block = {
+								type: "toolCall",
+								id: typeof contentBlock.id === "string" ? contentBlock.id : "",
+								name: typeof contentBlock.name === "string" ? isOAuthToken ? fromClaudeCodeName(contentBlock.name, context.tools) : contentBlock.name : "",
+								arguments: contentBlock.input && typeof contentBlock.input === "object" ? contentBlock.input : {},
+								partialJson: "",
+								index
+							};
+							output.content.push(block);
+							stream.push({
+								type: "toolcall_start",
+								contentIndex: output.content.length - 1,
+								partial: output
+							});
+						}
+						continue;
+					}
+					if (event.type === "content_block_delta") {
+						const index = blocks.findIndex((block) => block.index === event.index);
+						const block = blocks[index];
+						const delta = event.delta;
+						if (block?.type === "text" && delta?.type === "text_delta" && typeof delta.text === "string") {
+							block.text += delta.text;
+							stream.push({
+								type: "text_delta",
+								contentIndex: index,
+								delta: delta.text,
+								partial: output
+							});
+							continue;
+						}
+						if (block?.type === "thinking" && delta?.type === "thinking_delta" && typeof delta.thinking === "string") {
+							block.thinking += delta.thinking;
+							stream.push({
+								type: "thinking_delta",
+								contentIndex: index,
+								delta: delta.thinking,
+								partial: output
+							});
+							continue;
+						}
+						if (block?.type === "toolCall" && delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
+							block.partialJson += delta.partial_json;
+							block.arguments = parseStreamingJson(block.partialJson);
+							stream.push({
+								type: "toolcall_delta",
+								contentIndex: index,
+								delta: delta.partial_json,
+								partial: output
+							});
+							continue;
+						}
+						if (block?.type === "thinking" && delta?.type === "signature_delta" && typeof delta.signature === "string") {
+							block.thinkingSignature = `${String(block.thinkingSignature ?? "")}${delta.signature}`;
+						}
+						continue;
+					}
+					if (event.type === "content_block_stop") {
+						const index = blocks.findIndex((block) => block.index === event.index);
+						const block = blocks[index];
+						if (!block) {
+							continue;
+						}
+						delete block.index;
+						if (block.type === "text") {
+							stream.push({
+								type: "text_end",
+								contentIndex: index,
+								content: block.text,
+								partial: output
+							});
+							continue;
+						}
+						if (block.type === "thinking") {
+							stream.push({
+								type: "thinking_end",
+								contentIndex: index,
+								content: block.thinking,
+								partial: output
+							});
+							continue;
+						}
+						if (block.type === "toolCall") {
+							if (typeof block.partialJson === "string" && block.partialJson.length > 0) {
+								block.arguments = parseStreamingJson(block.partialJson);
+							}
+							delete block.partialJson;
+							stream.push({
+								type: "toolcall_end",
+								contentIndex: index,
+								toolCall: block,
+								partial: output
+							});
+						}
+						continue;
+					}
+					if (event.type === "message_delta") {
+						const delta = event.delta;
+						const usage = event.usage;
+						if (delta?.stop_reason) {
+							output.stopReason = mapStopReason(delta.stop_reason);
+						}
+						if (typeof usage?.input_tokens === "number") {
+							output.usage.input = usage.input_tokens;
+						}
+						if (typeof usage?.output_tokens === "number") {
+							output.usage.output = usage.output_tokens;
+						}
+						if (typeof usage?.cache_read_input_tokens === "number") {
+							output.usage.cacheRead = usage.cache_read_input_tokens;
+						}
+						if (typeof usage?.cache_creation_input_tokens === "number") {
+							output.usage.cacheWrite = usage.cache_creation_input_tokens;
+						}
+						output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+						calculateCost(model, output.usage);
+					}
+				}
+				finalizeTransportStream({
+					stream,
+					output,
+					signal: transportOptions.signal
+				});
+			} catch (error) {
+				failTransportStream({
+					stream,
+					output,
+					signal: options?.signal,
+					error,
+					cleanup: () => {
+						for (const block of output.content) {
+							delete block.index;
+						}
+					}
+				});
+			}
+		})();
+		return eventStream;
+	};
+}
+
+//#endregion
+export { createAnthropicMessagesTransportStreamFn };