@better-agent/providers 0.1.0-canary.0

package/dist/anthropic/index.mjs

@@ -0,0 +1,1909 @@
+import { n as extractPassthroughOptions, r as omitNullish, t as baFetch } from "../fetch-CW0dWlVC.mjs";
+import { Events } from "@better-agent/core/events";
+import { BetterAgentError } from "@better-agent/shared/errors";
+import { err, ok } from "@better-agent/shared/neverthrow";
+import { z } from "zod";
+import { safeJsonParse } from "@better-agent/shared/utils";
+import { TOOL_JSON_SCHEMA, isCallableToolDefinition } from "@better-agent/core";
+
+//#region src/anthropic/client/auth.ts
+const buildAnthropicHeaders = (config, options = {}) => {
+	const headers = {
+		"anthropic-version": config.anthropicVersion ?? "2023-06-01",
+		...config.headers ?? {},
+		...options.headers ?? {}
+	};
+	if (config.authToken) headers.Authorization = `Bearer ${config.authToken}`;
+	else if (config.apiKey) headers["x-api-key"] = config.apiKey;
+	if (options.beta?.length) headers["anthropic-beta"] = options.beta.join(",");
+	return headers;
+};
+
+//#endregion
+//#region src/anthropic/client/errors.ts
+const mapAnthropicHttpError = (httpError, ctx) => {
+	if (!httpError) return BetterAgentError.fromCode("UPSTREAM_FAILED", "Anthropic request failed", { context: { provider: "anthropic" } }).at({
+		at: ctx.at,
+		data: { path: ctx.path }
+	});
+	const { status, statusText, error } = httpError;
+	const message = error?.message ?? statusText ?? "Anthropic request failed";
+	const code = String(error?.type ?? status);
+	return BetterAgentError.fromCode("UPSTREAM_FAILED", message, {
+		status,
+		context: {
+			provider: "anthropic",
+			upstreamCode: code,
+			raw: error
+		}
+	}).at({
+		at: ctx.at,
+		data: {
+			path: ctx.path,
+			status
+		}
+	});
+};
+
+//#endregion
+//#region src/anthropic/responses/schemas.ts
+const ANTHROPIC_KNOWN_RESPONSE_MODELS = [
+	"claude-3-haiku-20240307",
+	"claude-haiku-4-5-20251001",
+	"claude-haiku-4-5",
+	"claude-opus-4-0",
+	"claude-opus-4-20250514",
+	"claude-opus-4-1-20250805",
+	"claude-opus-4-1",
+	"claude-opus-4-5",
+	"claude-opus-4-5-20251101",
+	"claude-sonnet-4-0",
+	"claude-sonnet-4-20250514",
+	"claude-sonnet-4-5-20250929",
+	"claude-sonnet-4-5",
+	"claude-sonnet-4-6",
+	"claude-opus-4-6"
+];
+const AnthropicKnownResponseModelsSchema = z.enum(ANTHROPIC_KNOWN_RESPONSE_MODELS);
+const AnthropicResponseModelIdSchema = z.string();
+const AnthropicCacheControlSchema = z.object({
+	type: z.literal("ephemeral"),
+	ttl: z.enum(["5m", "1h"]).optional()
+});
+const AnthropicTextContentSchema = z.object({
+	type: z.literal("text"),
+	text: z.string(),
+	citations: z.array(z.unknown()).optional(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicThinkingContentSchema = z.object({
+	type: z.literal("thinking"),
+	thinking: z.string(),
+	signature: z.string()
+});
+const AnthropicRedactedThinkingContentSchema = z.object({
+	type: z.literal("redacted_thinking"),
+	data: z.string()
+});
+const AnthropicContentSourceSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("base64"),
+		media_type: z.string(),
+		data: z.string()
+	}),
+	z.object({
+		type: z.literal("url"),
+		url: z.string()
+	}),
+	z.object({
+		type: z.literal("text"),
+		media_type: z.literal("text/plain"),
+		data: z.string()
+	})
+]);
+const AnthropicImageContentSchema = z.object({
+	type: z.literal("image"),
+	source: AnthropicContentSourceSchema,
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicDocumentContentSchema = z.object({
+	type: z.literal("document"),
+	source: AnthropicContentSourceSchema,
+	title: z.string().optional(),
+	context: z.string().optional(),
+	citations: z.object({ enabled: z.boolean() }).optional(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicToolResultContentSchema = z.object({
+	type: z.literal("tool_result"),
+	tool_use_id: z.string(),
+	content: z.union([z.string(), z.array(z.unknown())]),
+	is_error: z.boolean().optional(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicToolCallContentSchema = z.object({
+	type: z.literal("tool_use"),
+	id: z.string(),
+	name: z.string(),
+	input: z.unknown(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicServerToolUseContentSchema = z.object({
+	type: z.literal("server_tool_use"),
+	id: z.string(),
+	name: z.enum([
+		"web_fetch",
+		"web_search",
+		"code_execution",
+		"bash_code_execution",
+		"text_editor_code_execution",
+		"tool_search_tool_regex",
+		"tool_search_tool_bm25"
+	]),
+	input: z.unknown(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicProviderToolResultSchema = z.object({
+	tool_use_id: z.string(),
+	cache_control: AnthropicCacheControlSchema.optional()
+}).passthrough();
+const AnthropicWebSearchToolResultContentSchema = AnthropicProviderToolResultSchema.extend({
+	type: z.literal("web_search_tool_result"),
+	content: z.array(z.object({
+		url: z.string(),
+		title: z.string().nullable(),
+		page_age: z.string().nullable(),
+		encrypted_content: z.string(),
+		type: z.string()
+	}))
+});
+const AnthropicWebFetchToolResultContentSchema = AnthropicProviderToolResultSchema.extend({
+	type: z.literal("web_fetch_tool_result"),
+	content: z.unknown()
+});
+const AnthropicToolSearchToolResultContentSchema = AnthropicProviderToolResultSchema.extend({
+	type: z.literal("tool_search_tool_result"),
+	content: z.unknown()
+});
+const AnthropicCodeExecutionToolResultContentSchema = AnthropicProviderToolResultSchema.extend({
+	type: z.literal("code_execution_tool_result"),
+	content: z.unknown()
+});
+const AnthropicBashCodeExecutionToolResultContentSchema = AnthropicProviderToolResultSchema.extend({
+	type: z.literal("bash_code_execution_tool_result"),
+	content: z.unknown()
+});
+const AnthropicTextEditorCodeExecutionToolResultContentSchema = AnthropicProviderToolResultSchema.extend({
+	type: z.literal("text_editor_code_execution_tool_result"),
+	content: z.unknown()
+});
+const AnthropicMcpToolUseContentSchema = z.object({
+	type: z.literal("mcp_tool_use"),
+	id: z.string(),
+	name: z.string(),
+	server_name: z.string().optional(),
+	input: z.unknown(),
+	cache_control: AnthropicCacheControlSchema.optional()
+}).passthrough();
+const AnthropicMcpToolResultContentSchema = z.object({
+	type: z.literal("mcp_tool_result"),
+	tool_use_id: z.string(),
+	content: z.unknown(),
+	is_error: z.boolean().optional(),
+	cache_control: AnthropicCacheControlSchema.optional()
+}).passthrough();
+const AnthropicCompactionContentSchema = z.object({
+	type: z.literal("compaction"),
+	content: z.string(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicResponseContentBlockSchema = z.discriminatedUnion("type", [
+	AnthropicTextContentSchema,
+	AnthropicThinkingContentSchema,
+	AnthropicRedactedThinkingContentSchema,
+	AnthropicImageContentSchema,
+	AnthropicDocumentContentSchema,
+	AnthropicToolResultContentSchema,
+	AnthropicToolCallContentSchema,
+	AnthropicServerToolUseContentSchema,
+	AnthropicWebSearchToolResultContentSchema,
+	AnthropicWebFetchToolResultContentSchema,
+	AnthropicToolSearchToolResultContentSchema,
+	AnthropicCodeExecutionToolResultContentSchema,
+	AnthropicBashCodeExecutionToolResultContentSchema,
+	AnthropicTextEditorCodeExecutionToolResultContentSchema,
+	AnthropicMcpToolUseContentSchema,
+	AnthropicMcpToolResultContentSchema,
+	AnthropicCompactionContentSchema
+]);
+const AnthropicMessageSchema = z.object({
+	role: z.enum(["user", "assistant"]),
+	content: z.array(z.union([
+		AnthropicTextContentSchema,
+		AnthropicImageContentSchema,
+		AnthropicDocumentContentSchema,
+		AnthropicToolResultContentSchema,
+		AnthropicThinkingContentSchema,
+		AnthropicRedactedThinkingContentSchema,
+		AnthropicToolCallContentSchema,
+		AnthropicServerToolUseContentSchema,
+		AnthropicWebSearchToolResultContentSchema,
+		AnthropicWebFetchToolResultContentSchema,
+		AnthropicToolSearchToolResultContentSchema,
+		AnthropicCodeExecutionToolResultContentSchema,
+		AnthropicBashCodeExecutionToolResultContentSchema,
+		AnthropicTextEditorCodeExecutionToolResultContentSchema,
+		AnthropicMcpToolUseContentSchema,
+		AnthropicMcpToolResultContentSchema,
+		AnthropicCompactionContentSchema
+	]))
+});
+const AnthropicMetadataSchema = z.object({ user_id: z.string().optional() });
+const AnthropicThinkingConfigSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("adaptive") }),
+	z.object({
+		type: z.literal("enabled"),
+		budget_tokens: z.number().optional()
+	}),
+	z.object({ type: z.literal("disabled") })
+]);
+const AnthropicToolChoiceSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("auto"),
+		disable_parallel_tool_use: z.boolean().optional()
+	}),
+	z.object({
+		type: z.literal("any"),
+		disable_parallel_tool_use: z.boolean().optional()
+	}),
+	z.object({
+		type: z.literal("tool"),
+		name: z.string(),
+		disable_parallel_tool_use: z.boolean().optional()
+	})
+]);
+const AnthropicFunctionToolSchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	input_schema: z.record(z.string(), z.unknown()),
+	cache_control: AnthropicCacheControlSchema.optional(),
+	strict: z.boolean().optional(),
+	eager_input_streaming: z.boolean().optional(),
+	defer_loading: z.boolean().optional(),
+	allowed_callers: z.array(z.enum([
+		"direct",
+		"code_execution_20250825",
+		"code_execution_20260120"
+	])).optional(),
+	input_examples: z.array(z.unknown()).optional()
+});
+const AnthropicCodeExecution20250522ToolSchema = z.object({
+	type: z.literal("code_execution_20250522"),
+	name: z.literal("code_execution"),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicCodeExecution20250825ToolSchema = z.object({
+	type: z.literal("code_execution_20250825"),
+	name: z.literal("code_execution")
+});
+const AnthropicCodeExecution20260120ToolSchema = z.object({
+	type: z.literal("code_execution_20260120"),
+	name: z.literal("code_execution")
+});
+const AnthropicComputerBaseToolSchema = z.object({
+	display_width_px: z.number().int(),
+	display_height_px: z.number().int(),
+	display_number: z.number().int().optional(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicComputer20241022ToolSchema = AnthropicComputerBaseToolSchema.extend({
+	type: z.literal("computer_20241022"),
+	name: z.literal("computer")
+});
+const AnthropicComputer20250124ToolSchema = AnthropicComputerBaseToolSchema.extend({
+	type: z.literal("computer_20250124"),
+	name: z.literal("computer")
+});
+const AnthropicComputer20251124ToolSchema = AnthropicComputerBaseToolSchema.extend({
+	type: z.literal("computer_20251124"),
+	name: z.literal("computer"),
+	enable_zoom: z.boolean().optional()
+});
+const AnthropicTextEditor20241022ToolSchema = z.object({
+	type: z.literal("text_editor_20241022"),
+	name: z.literal("str_replace_editor"),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicTextEditor20250124ToolSchema = z.object({
+	type: z.literal("text_editor_20250124"),
+	name: z.literal("str_replace_editor"),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicTextEditor20250429ToolSchema = z.object({
+	type: z.literal("text_editor_20250429"),
+	name: z.literal("str_replace_based_edit_tool"),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicTextEditor20250728ToolSchema = z.object({
+	type: z.literal("text_editor_20250728"),
+	name: z.literal("str_replace_based_edit_tool"),
+	max_characters: z.number().optional(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicBash20241022ToolSchema = z.object({
+	type: z.literal("bash_20241022"),
+	name: z.literal("bash"),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicBash20250124ToolSchema = z.object({
+	type: z.literal("bash_20250124"),
+	name: z.literal("bash"),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicMemory20250818ToolSchema = z.object({
+	type: z.literal("memory_20250818"),
+	name: z.literal("memory")
+});
+const AnthropicWebSearchUserLocationSchema = z.object({
+	type: z.literal("approximate"),
+	city: z.string().optional(),
+	region: z.string().optional(),
+	country: z.string().optional(),
+	timezone: z.string().optional()
+});
+const AnthropicWebSearch20250305ToolSchema = z.object({
+	type: z.literal("web_search_20250305"),
+	name: z.literal("web_search"),
+	max_uses: z.number().optional(),
+	allowed_domains: z.array(z.string()).optional(),
+	blocked_domains: z.array(z.string()).optional(),
+	user_location: AnthropicWebSearchUserLocationSchema.optional(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicWebSearch20260209ToolSchema = z.object({
+	type: z.literal("web_search_20260209"),
+	name: z.literal("web_search"),
+	max_uses: z.number().optional(),
+	allowed_domains: z.array(z.string()).optional(),
+	blocked_domains: z.array(z.string()).optional(),
+	user_location: AnthropicWebSearchUserLocationSchema.optional(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicWebFetchBaseToolSchema = z.object({
+	max_uses: z.number().optional(),
+	allowed_domains: z.array(z.string()).optional(),
+	blocked_domains: z.array(z.string()).optional(),
+	citations: z.object({ enabled: z.boolean() }).optional(),
+	max_content_tokens: z.number().optional(),
+	cache_control: AnthropicCacheControlSchema.optional()
+});
+const AnthropicWebFetch20250910ToolSchema = AnthropicWebFetchBaseToolSchema.extend({
+	type: z.literal("web_fetch_20250910"),
+	name: z.literal("web_fetch")
+});
+const AnthropicWebFetch20260209ToolSchema = AnthropicWebFetchBaseToolSchema.extend({
+	type: z.literal("web_fetch_20260209"),
+	name: z.literal("web_fetch")
+});
+const AnthropicToolSearchRegex20251119ToolSchema = z.object({
+	type: z.literal("tool_search_tool_regex_20251119"),
+	name: z.literal("tool_search_tool_regex")
+});
+const AnthropicToolSearchBm2520251119ToolSchema = z.object({
+	type: z.literal("tool_search_tool_bm25_20251119"),
+	name: z.literal("tool_search_tool_bm25")
+});
+const AnthropicHostedToolRequestSchema = z.union([
+	AnthropicCodeExecution20250522ToolSchema,
+	AnthropicCodeExecution20250825ToolSchema,
+	AnthropicCodeExecution20260120ToolSchema,
+	AnthropicComputer20241022ToolSchema,
+	AnthropicComputer20250124ToolSchema,
+	AnthropicComputer20251124ToolSchema,
+	AnthropicTextEditor20241022ToolSchema,
+	AnthropicTextEditor20250124ToolSchema,
+	AnthropicTextEditor20250429ToolSchema,
+	AnthropicTextEditor20250728ToolSchema,
+	AnthropicBash20241022ToolSchema,
+	AnthropicBash20250124ToolSchema,
+	AnthropicMemory20250818ToolSchema,
+	AnthropicWebSearch20250305ToolSchema,
+	AnthropicWebSearch20260209ToolSchema,
+	AnthropicWebFetch20250910ToolSchema,
+	AnthropicWebFetch20260209ToolSchema,
+	AnthropicToolSearchRegex20251119ToolSchema,
+	AnthropicToolSearchBm2520251119ToolSchema
+]);
+const AnthropicMessagesToolSchema = z.union([AnthropicFunctionToolSchema, AnthropicHostedToolRequestSchema]);
+const AnthropicMessagesRequestSchema = z.object({
+	model: AnthropicResponseModelIdSchema,
+	max_tokens: z.number().int().positive(),
+	messages: z.array(AnthropicMessageSchema),
+	system: z.union([z.string(), z.array(AnthropicTextContentSchema)]).optional(),
+	cache_control: AnthropicCacheControlSchema.optional(),
+	metadata: AnthropicMetadataSchema.optional(),
+	output_config: z.object({
+		effort: z.enum([
+			"low",
+			"medium",
+			"high",
+			"max"
+		]).optional(),
+		format: z.object({
+			type: z.literal("json_schema"),
+			schema: z.record(z.string(), z.unknown())
+		}).optional()
+	}).optional(),
+	stop_sequences: z.array(z.string()).optional(),
+	stream: z.boolean().optional(),
+	speed: z.enum(["fast", "standard"]).optional(),
+	temperature: z.number().optional(),
+	thinking: AnthropicThinkingConfigSchema.optional(),
+	tool_choice: AnthropicToolChoiceSchema.optional(),
+	tools: z.array(AnthropicMessagesToolSchema).optional(),
+	top_k: z.number().optional(),
+	top_p: z.number().optional(),
+	mcp_servers: z.array(z.object({
+		type: z.literal("url"),
+		name: z.string(),
+		url: z.string(),
+		authorization_token: z.string().nullish(),
+		tool_configuration: z.object({
+			enabled: z.boolean().nullish(),
+			allowed_tools: z.array(z.string()).nullish()
+		}).nullish()
+	})).optional(),
+	container: z.object({
+		id: z.string().optional(),
+		skills: z.array(z.object({
+			type: z.enum(["anthropic", "custom"]),
+			skill_id: z.string(),
+			version: z.string().optional()
+		})).optional()
+	}).optional(),
+	context_management: z.object({ edits: z.array(z.unknown()) }).optional()
+}).passthrough();
+const AnthropicUsageSchema = z.object({
+	input_tokens: z.number().int().optional(),
+	output_tokens: z.number().int().optional(),
+	cache_creation_input_tokens: z.number().int().optional(),
+	cache_read_input_tokens: z.number().int().optional(),
+	iterations: z.array(z.object({
+		type: z.enum(["compaction", "message"]),
+		input_tokens: z.number().int(),
+		output_tokens: z.number().int()
+	})).optional()
+});
+const AnthropicMessagesResponseSchema = z.object({
+	id: z.string(),
+	type: z.literal("message"),
+	role: z.literal("assistant"),
+	model: AnthropicResponseModelIdSchema,
+	content: z.array(AnthropicResponseContentBlockSchema),
+	stop_reason: z.string().nullable().optional(),
+	stop_sequence: z.string().nullable().optional(),
+	usage: AnthropicUsageSchema.default({})
+}).passthrough();
+const AnthropicContentBlockDeltaSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("text_delta"),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("thinking_delta"),
+		thinking: z.string()
+	}),
+	z.object({
+		type: z.literal("input_json_delta"),
+		partial_json: z.string()
+	}),
+	z.object({
+		type: z.literal("signature_delta"),
+		signature: z.string()
+	}),
+	z.object({
+		type: z.literal("citations_delta"),
+		citation: z.unknown()
+	}),
+	z.object({
+		type: z.literal("compaction_delta"),
+		content: z.string().optional()
+	})
+]);
+const AnthropicResponseStreamEventSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("ping") }),
+	z.object({
+		type: z.literal("message_start"),
+		message: AnthropicMessagesResponseSchema
+	}),
+	z.object({
+		type: z.literal("message_delta"),
+		delta: z.object({
+			stop_reason: z.string().nullable().optional(),
+			stop_sequence: z.string().nullable().optional()
+		}).passthrough(),
+		usage: z.object({
+			input_tokens: z.number().int().optional(),
+			output_tokens: z.number().int().optional(),
+			cache_creation_input_tokens: z.number().int().optional(),
+			cache_read_input_tokens: z.number().int().optional(),
+			iterations: z.array(z.object({
+				type: z.enum(["compaction", "message"]),
+				input_tokens: z.number().int(),
+				output_tokens: z.number().int()
+			})).optional()
+		}).passthrough().optional()
+	}),
+	z.object({ type: z.literal("message_stop") }),
+	z.object({
+		type: z.literal("content_block_start"),
+		index: z.number().int(),
+		content_block: AnthropicResponseContentBlockSchema
+	}),
+	z.object({
+		type: z.literal("content_block_delta"),
+		index: z.number().int(),
+		delta: AnthropicContentBlockDeltaSchema
+	}),
+	z.object({
+		type: z.literal("content_block_stop"),
+		index: z.number().int()
+	}),
+	z.object({
+		type: z.literal("error"),
+		error: z.object({
+			type: z.string().optional(),
+			message: z.string().optional()
+		}).passthrough()
+	})
+]);
+
+//#endregion
+//#region src/anthropic/client/stream.ts
+const parseSSERecord = (record) => {
+	const lines = record.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean);
+	if (!lines.length) return ok(null);
+	const data = lines.filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+	if (!data) return ok(null);
+	if (data === "[DONE]") return ok(null);
+	const parsed = safeJsonParse(data);
+	if (parsed.isErr()) return err(BetterAgentError.wrap({
+		err: parsed.error,
+		message: "Anthropic stream returned invalid JSON",
+		opts: {
+			code: "UPSTREAM_FAILED",
+			context: {
+				provider: "anthropic",
+				raw: data
+			}
+		}
+	}).at({ at: "anthropic.stream.parse" }));
+	const event = AnthropicResponseStreamEventSchema.safeParse(parsed.value);
+	if (!event.success) return err(BetterAgentError.fromCode("UPSTREAM_FAILED", "Anthropic stream returned an unknown event payload", { context: {
+		provider: "anthropic",
+		issues: event.error.issues
+	} }).at({ at: "anthropic.stream.validate" }));
+	return ok(event.data);
+};
+async function* parseAnthropicSSEStream(stream) {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			while (true) {
+				const recordBoundary = buffer.indexOf("\n\n");
+				if (recordBoundary === -1) break;
+				const record = buffer.slice(0, recordBoundary);
+				buffer = buffer.slice(recordBoundary + 2);
+				const parsed = parseSSERecord(record);
+				if (parsed.isErr()) {
+					yield err(parsed.error);
+					return;
+				}
+				if (parsed.value) yield ok(parsed.value);
+			}
+		}
+		buffer += decoder.decode();
+		const remaining = buffer.trim();
+		if (!remaining) return;
+		const parsed = parseSSERecord(remaining);
+		if (parsed.isErr()) {
+			yield err(parsed.error);
+			return;
+		}
+		if (parsed.value) yield ok(parsed.value);
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+//#endregion
+//#region src/anthropic/client/create-client.ts
+const createAnthropicClient = (config = {}) => {
+	const baseUrl = (config.baseURL ?? "https://api.anthropic.com/v1").replace(/\/+$/, "");
+	const post = async (path, body, at, options) => {
+		try {
+			const result = await baFetch(`${baseUrl}${path}`, {
+				method: "POST",
+				body: JSON.stringify(body),
+				headers: {
+					...buildAnthropicHeaders(config, options),
+					"Content-Type": "application/json"
+				},
+				signal: options?.signal ?? null,
+				throw: false
+			});
+			if (result.error) return err(mapAnthropicHttpError(result.error, {
+				at,
+				path
+			}));
+			if (!result.data) return err(BetterAgentError.fromCode("UPSTREAM_FAILED", "Anthropic returned no data", { context: { provider: "anthropic" } }).at({
+				at,
+				data: { path }
+			}));
+			return ok(result.data);
+		} catch (e) {
+			return err(BetterAgentError.wrap({
+				err: e,
+				message: "Anthropic request failed",
+				opts: {
+					code: "UPSTREAM_FAILED",
+					context: { provider: "anthropic" }
+				}
+			}).at({
+				at,
+				data: { path }
+			}));
+		}
+	};
+	const stream = async (path, body, at, options) => {
+		try {
+			const response = await fetch(`${baseUrl}${path}`, {
+				method: "POST",
+				body: JSON.stringify(body),
+				headers: {
+					...buildAnthropicHeaders(config, options),
+					Accept: "text/event-stream",
+					"Content-Type": "application/json"
+				},
+				signal: options?.signal ?? null
+			});
+			if (!response.ok) {
+				const parsed = safeJsonParse(await response.text());
+				const error = parsed.isOk() && parsed.value && typeof parsed.value === "object" ? parsed.value.error ? parsed.value : { error: parsed.value } : void 0;
+				return err(mapAnthropicHttpError({
+					status: response.status,
+					statusText: response.statusText,
+					error: error?.error
+				}, {
+					at,
+					path
+				}));
+			}
+			if (!response.body) return err(BetterAgentError.fromCode("UPSTREAM_FAILED", "Anthropic stream response did not include a body", { context: { provider: "anthropic" } }).at({
+				at,
+				data: { path }
+			}));
+			return ok(parseAnthropicSSEStream(response.body));
+		} catch (e) {
+			return err(BetterAgentError.wrap({
+				err: e,
+				message: "Anthropic streaming request failed",
+				opts: {
+					code: "UPSTREAM_FAILED",
+					context: { provider: "anthropic" }
+				}
+			}).at({
+				at,
+				data: { path }
+			}));
+		}
+	};
+	return { messages: {
+		create: (body, options) => post("/messages", body, "anthropic.messages.create", options),
+		stream: (body, options) => stream("/messages", body, "anthropic.messages.stream", options)
+	} };
+};
+
+//#endregion
+//#region src/anthropic/tools/index.ts
+function createAnthropicNativeToolBuilders() {
+	return {
+		codeExecution_20250522: (config = {}) => createNativeTool("code_execution_20250522", config),
+		codeExecution_20250825: (config = {}) => createNativeTool("code_execution_20250825", config),
+		codeExecution_20260120: (config = {}) => createNativeTool("code_execution_20260120", config),
+		computer_20241022: (config) => createNativeTool("computer_20241022", config),
+		computer_20250124: (config) => createNativeTool("computer_20250124", config),
+		computer_20251124: (config) => createNativeTool("computer_20251124", config),
+		textEditor_20241022: (config = {}) => createNativeTool("text_editor_20241022", config),
+		textEditor_20250124: (config = {}) => createNativeTool("text_editor_20250124", config),
+		textEditor_20250429: (config = {}) => createNativeTool("text_editor_20250429", config),
+		textEditor_20250728: (config = {}) => createNativeTool("text_editor_20250728", config),
+		bash_20241022: (config = {}) => createNativeTool("bash_20241022", config),
+		bash_20250124: (config = {}) => createNativeTool("bash_20250124", config),
+		memory_20250818: (config = {}) => createNativeTool("memory_20250818", config),
+		webSearch_20250305: (config = {}) => createNativeTool("web_search_20250305", config),
+		webSearch_20260209: (config = {}) => createNativeTool("web_search_20260209", config),
+		webFetch_20250910: (config = {}) => createNativeTool("web_fetch_20250910", config),
+		webFetch_20260209: (config = {}) => createNativeTool("web_fetch_20260209", config),
+		toolSearchRegex_20251119: (config = {}) => createNativeTool("tool_search_tool_regex_20251119", config),
+		toolSearchBm25_20251119: (config = {}) => createNativeTool("tool_search_tool_bm25_20251119", config)
+	};
+}
+function createNativeTool(type, config) {
+	return {
+		kind: "hosted",
+		provider: "anthropic",
+		type,
+		config
+	};
+}
+function isAnthropicNativeToolDefinition(tool) {
+	if (!tool || typeof tool !== "object") return false;
+	const t = tool;
+	return t.kind === "hosted" && t.provider === "anthropic" && typeof t.type === "string";
+}
+function mapAnthropicNativeToolToRequest(tool) {
+	switch (tool.type) {
+		case "code_execution_20250522": return {
+			type: "code_execution_20250522",
+			name: "code_execution",
+			...tool.config
+		};
+		case "code_execution_20250825": return {
+			type: "code_execution_20250825",
+			name: "code_execution",
+			...tool.config
+		};
+		case "code_execution_20260120": return {
+			type: "code_execution_20260120",
+			name: "code_execution",
+			...tool.config
+		};
+		case "computer_20241022": return {
+			type: "computer_20241022",
+			name: "computer",
+			...tool.config
+		};
+		case "computer_20250124": return {
+			type: "computer_20250124",
+			name: "computer",
+			...tool.config
+		};
+		case "computer_20251124": return {
+			type: "computer_20251124",
+			name: "computer",
+			...tool.config
+		};
+		case "text_editor_20241022": return {
+			type: "text_editor_20241022",
+			name: "str_replace_editor",
+			...tool.config
+		};
+		case "text_editor_20250124": return {
+			type: "text_editor_20250124",
+			name: "str_replace_editor",
+			...tool.config
+		};
+		case "text_editor_20250429": return {
+			type: "text_editor_20250429",
+			name: "str_replace_based_edit_tool",
+			...tool.config
+		};
+		case "text_editor_20250728": return {
+			type: "text_editor_20250728",
+			name: "str_replace_based_edit_tool",
+			...tool.config
+		};
+		case "bash_20241022": return {
+			type: "bash_20241022",
+			name: "bash",
+			...tool.config
+		};
+		case "bash_20250124": return {
+			type: "bash_20250124",
+			name: "bash",
+			...tool.config
+		};
+		case "memory_20250818": return {
+			type: "memory_20250818",
+			name: "memory",
+			...tool.config
+		};
+		case "web_search_20250305": return {
+			type: "web_search_20250305",
+			name: "web_search",
+			...tool.config
+		};
+		case "web_search_20260209": return {
+			type: "web_search_20260209",
+			name: "web_search",
+			...tool.config
+		};
+		case "web_fetch_20250910": return {
+			type: "web_fetch_20250910",
+			name: "web_fetch",
+			...tool.config
+		};
+		case "web_fetch_20260209": return {
+			type: "web_fetch_20260209",
+			name: "web_fetch",
+			...tool.config
+		};
+		case "tool_search_tool_regex_20251119": return {
+			type: "tool_search_tool_regex_20251119",
+			name: "tool_search_tool_regex",
+			...tool.config
+		};
+		case "tool_search_tool_bm25_20251119": return {
+			type: "tool_search_tool_bm25_20251119",
+			name: "tool_search_tool_bm25",
+			...tool.config
+		};
+	}
+}
+
+//#endregion
+//#region src/anthropic/responses/mappers.ts
+/**
+* Keys explicitly handled by the Anthropic responses mapper.
+*/
+const ANTHROPIC_RESPONSE_KNOWN_KEYS = new Set([
+	"input",
+	"tools",
+	"toolChoice",
+	"modalities",
+	"structured_output",
+	"anthropicBeta",
+	"cacheControl",
+	"container",
+	"contextManagement",
+	"disableParallelToolUse",
+	"effort",
+	"max_tokens",
+	"mcpServers",
+	"metadata",
+	"speed",
+	"stop_sequences",
+	"structuredOutputMode",
+	"temperature",
+	"thinking",
+	"toolStreaming",
+	"top_k",
+	"top_p"
+]);
+const DEFAULT_MAX_TOKENS = 4096;
+const PDF_INPUT_BETA = "pdfs-2024-09-25";
+const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+const normalizeProviderToolName = (name) => {
+	if (name === "bash_code_execution" || name === "text_editor_code_execution") return "code_execution";
+	return name;
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const decodeBase64Text = (data) => Buffer.from(data, "base64").toString("utf8");
+const isUrlSource = (source) => isRecord(source) && source.kind === "url" && typeof source.url === "string";
+const isBase64Source = (source) => isRecord(source) && source.kind === "base64" && typeof source.data === "string" && typeof source.mimeType === "string";
+const buildBinarySource = (source) => {
+	if (isUrlSource(source)) return {
+		type: "url",
+		url: source.url
+	};
+	if (isBase64Source(source)) return {
+		type: "base64",
+		media_type: source.mimeType,
+		data: source.data
+	};
+	return null;
+};
+const serializeToolResultContent = (result) => typeof result === "string" ? result : JSON.stringify(result);
+const parseMaybeJson = (value) => {
+	if (!value.trim()) return {};
+	const parsed = safeJsonParse(value);
+	return parsed.isOk() ? parsed.value : value;
+};
+const getAnthropicModelCapabilities = (modelId) => {
+	if (modelId.includes("claude-sonnet-4-6") || modelId.includes("claude-opus-4-6")) return { supportsStructuredOutput: true };
+	if (modelId.includes("claude-sonnet-4-5") || modelId.includes("claude-opus-4-5") || modelId.includes("claude-haiku-4-5")) return { supportsStructuredOutput: true };
+	if (modelId.includes("claude-opus-4-1")) return { supportsStructuredOutput: true };
+	return { supportsStructuredOutput: false };
+};
+const getAnthropicPartProviderMetadata = (part) => {
+	const providerMetadata = part.providerMetadata;
+	if (!isRecord(providerMetadata)) return void 0;
+	const anthropic = providerMetadata.anthropic;
+	if (!isRecord(anthropic)) return void 0;
+	return {
+		cacheControl: isRecord(anthropic.cacheControl) && anthropic.cacheControl.type === "ephemeral" && (anthropic.cacheControl.ttl == null || anthropic.cacheControl.ttl === "5m" || anthropic.cacheControl.ttl === "1h") ? {
+			type: "ephemeral",
+			...anthropic.cacheControl.ttl != null ? { ttl: anthropic.cacheControl.ttl } : {}
+		} : void 0,
+		citations: isRecord(anthropic.citations) && typeof anthropic.citations.enabled === "boolean" ? { enabled: anthropic.citations.enabled } : void 0,
+		context: typeof anthropic.context === "string" ? anthropic.context : void 0,
+		title: typeof anthropic.title === "string" ? anthropic.title : void 0
+	};
+};
+const getAnthropicTextProviderMetadata = (citations) => citations?.length ? { anthropic: { citations } } : void 0;
+const mapAnthropicStopReason = (stopReason, isJsonResponseFromTool) => {
+	switch (stopReason) {
+		case "pause_turn":
+		case "end_turn":
+		case "stop_sequence": return "stop";
+		case "refusal": return "content-filter";
+		case "tool_use": return isJsonResponseFromTool ? "stop" : "tool-calls";
+		case "max_tokens":
+		case "model_context_window_exceeded": return "length";
+		case "compaction": return "other";
+		default: return "other";
+	}
+};
+const mapAnthropicUsage = (usage) => {
+	const cacheCreation = usage?.cache_creation_input_tokens ?? 0;
+	const cacheRead = usage?.cache_read_input_tokens ?? 0;
+	const iteratedInput = usage?.iterations?.reduce((sum, item) => sum + item.input_tokens, 0) ?? usage?.input_tokens;
+	const iteratedOutput = usage?.iterations?.reduce((sum, item) => sum + item.output_tokens, 0) ?? usage?.output_tokens;
+	const inputTokens = typeof iteratedInput === "number" ? iteratedInput + cacheCreation + cacheRead : void 0;
+	const outputTokens = typeof iteratedOutput === "number" ? iteratedOutput : void 0;
+	return omitNullish({
+		inputTokens,
+		outputTokens,
+		totalTokens: typeof inputTokens === "number" && typeof outputTokens === "number" ? inputTokens + outputTokens : void 0,
+		cachedInputTokens: cacheRead || void 0
+	});
+};
+const mapContextManagementEdit = (edit) => {
+	if (!isRecord(edit) || typeof edit.type !== "string") return edit;
+	switch (edit.type) {
+		case "clear_tool_uses_20250919": return omitNullish({
+			type: edit.type,
+			trigger: edit.trigger,
+			keep: edit.keep,
+			clear_at_least: edit.clearAtLeast,
+			clear_tool_inputs: edit.clearToolInputs,
+			exclude_tools: edit.excludeTools
+		});
+		case "clear_thinking_20251015": return omitNullish({
+			type: edit.type,
+			keep: edit.keep
+		});
+		case "compact_20260112": return omitNullish({
+			type: edit.type,
+			trigger: edit.trigger,
+			pause_after_compaction: edit.pauseAfterCompaction,
+			instructions: edit.instructions
+		});
+		default: return edit;
+	}
+};
+const mapHostedToolBeta = (type) => {
+	switch (type) {
+		case "code_execution_20250522": return "code-execution-2025-05-22";
+		case "code_execution_20250825": return "code-execution-2025-08-25";
+		case "computer_20241022":
+		case "text_editor_20241022":
+		case "bash_20241022": return "computer-use-2024-10-22";
+		case "computer_20250124":
+		case "text_editor_20250124":
+		case "text_editor_20250429":
+		case "bash_20250124": return "computer-use-2025-01-24";
+		case "computer_20251124": return "computer-use-2025-11-24";
+		case "memory_20250818": return "context-management-2025-06-27";
+		case "web_fetch_20250910": return "web-fetch-2025-09-10";
+		case "web_fetch_20260209":
+		case "web_search_20260209": return "code-execution-web-tools-2026-02-09";
+		default: return null;
+	}
+};
+const mapMessagePartsToAnthropicContent = (content, role, modelId, betas) => {
+	const toValidationError = (message, at, context) => BetterAgentError.fromCode("VALIDATION_FAILED", message, { context: {
+		provider: "anthropic",
+		model: modelId,
+		role,
+		...context ?? {}
+	} }).at({ at });
+	const parts = typeof content === "string" ? [{
+		type: "text",
+		text: content
+	}] : content;
+	if (!Array.isArray(parts)) return err(toValidationError("Message content must be a string or array.", "anthropic.map.input.content"));
+	const anthropicContent = [];
+	for (const part of parts) {
+		if (!isRecord(part) || typeof part.type !== "string") return err(toValidationError("Message part must be an object with a type.", "anthropic.map.input.part"));
+		if (part.type === "text") {
+			if (typeof part.text !== "string") return err(toValidationError("Text message parts require a text string.", "anthropic.map.input.text"));
+			const anthropicProviderOptions = getAnthropicPartProviderMetadata(part);
+			anthropicContent.push({
+				type: "text",
+				text: part.text,
+				...anthropicProviderOptions?.cacheControl != null ? { cache_control: anthropicProviderOptions.cacheControl } : {}
+			});
+			continue;
+		}
+		if (role === "assistant" || role === "system" || role === "developer") return err(toValidationError(`Role '${role}' only supports text content for Anthropic.`, "anthropic.map.input.roleContent", { partType: part.type }));
+		if (part.type === "image") {
+			if (!isRecord(part.source) || typeof part.source.kind !== "string") return err(toValidationError("Image parts require a valid source.", "anthropic.map.input.imageSource"));
+			if (part.source.kind === "provider-file") return err(toValidationError("Anthropic Messages API does not support provider-file image inputs in this adapter.", "anthropic.map.input.imageProviderFile"));
+			const anthropicProviderOptions = getAnthropicPartProviderMetadata(part);
+			const imageSource = isUrlSource(part.source) || isBase64Source(part.source) ? buildBinarySource(part.source) : null;
+			if (imageSource == null) return err(toValidationError("Image parts require a URL or base64 source.", "anthropic.map.input.imageSourceKind"));
+			anthropicContent.push({
+				type: "image",
+				source: imageSource,
+				...anthropicProviderOptions?.cacheControl != null ? { cache_control: anthropicProviderOptions.cacheControl } : {}
+			});
+			continue;
+		}
+		if (part.type === "file") {
+			if (!isRecord(part.source) || typeof part.source.kind !== "string") return err(toValidationError("File parts require a valid source.", "anthropic.map.input.fileSource"));
+			if (part.source.kind === "provider-file") return err(toValidationError("Anthropic Messages API does not support provider-file document inputs in this adapter.", "anthropic.map.input.fileProviderFile"));
+			const mimeType = typeof part.source.mimeType === "string" ? part.source.mimeType : void 0;
+			const filename = typeof part.source.filename === "string" ? part.source.filename : void 0;
+			const anthropicProviderOptions = getAnthropicPartProviderMetadata(part);
+			const citationsEnabled = anthropicProviderOptions?.citations?.enabled;
+			const documentContext = anthropicProviderOptions?.context;
+			const documentTitle = anthropicProviderOptions?.title ?? filename;
+			const cacheControl = anthropicProviderOptions?.cacheControl;
+			if (typeof mimeType === "string" && mimeType.startsWith("image/")) {
+				const imageSource = buildBinarySource(part.source);
+				if (imageSource == null) return err(toValidationError("Image file inputs require a URL or base64 source.", "anthropic.map.input.fileImageSource"));
+				anthropicContent.push({
+					type: "image",
+					source: imageSource,
+					...cacheControl != null ? { cache_control: cacheControl } : {}
+				});
+				continue;
+			}
+			if (mimeType === "application/pdf") {
+				betas.add(PDF_INPUT_BETA);
+				const documentSource = buildBinarySource(part.source);
+				if (documentSource == null) return err(toValidationError("PDF inputs require a URL or base64 source.", "anthropic.map.input.filePdfSource"));
+				anthropicContent.push({
+					type: "document",
+					source: documentSource,
+					...documentTitle != null ? { title: documentTitle } : {},
+					...documentContext != null ? { context: documentContext } : {},
+					...citationsEnabled != null ? { citations: { enabled: citationsEnabled } } : {},
+					...cacheControl != null ? { cache_control: cacheControl } : {}
+				});
+				continue;
+			}
+			if (mimeType === "text/plain") {
+				const documentSource = isUrlSource(part.source) ? {
+					type: "url",
+					url: part.source.url
+				} : isBase64Source(part.source) ? {
+					type: "text",
+					media_type: "text/plain",
+					data: decodeBase64Text(part.source.data)
+				} : null;
+				if (documentSource == null) return err(toValidationError("Text document inputs require a URL or base64 source.", "anthropic.map.input.fileTextSource"));
+				anthropicContent.push({
+					type: "document",
+					source: documentSource,
+					...documentTitle != null ? { title: documentTitle } : {},
+					...documentContext != null ? { context: documentContext } : {},
+					...citationsEnabled != null ? { citations: { enabled: citationsEnabled } } : {},
+					...cacheControl != null ? { cache_control: cacheControl } : {}
+				});
+				continue;
+			}
+			return err(toValidationError("Anthropic file inputs currently support image/*, application/pdf, and text/plain only.", "anthropic.map.input.fileUnsupported", { mimeType }));
+		}
+		return err(toValidationError(`Unsupported Anthropic input part type '${part.type}'.`, "anthropic.map.input.unsupportedPart"));
+	}
+	return ok(anthropicContent);
+};
+function mapToAnthropicMessagesRequest(args) {
+	try {
+		const { modelId } = args;
+		const o = args.options;
+		const stream = args.stream === true;
+		const betas = new Set(o.anthropicBeta ?? []);
+		const systemParts = [];
+		const messages = [];
+		const inputItems = typeof o.input === "string" ? [{
+			type: "message",
+			role: "user",
+			content: o.input
+		}] : o.input;
+		if (Array.isArray(inputItems)) for (const item of inputItems) {
+			if (typeof item === "string") {
+				messages.push({
+					role: "user",
+					content: [{
+						type: "text",
+						text: item
+					}]
+				});
+				continue;
+			}
+			if (!isRecord(item) || typeof item.type !== "string") return err(BetterAgentError.fromCode("VALIDATION_FAILED", "Anthropic input items must be messages or tool-call results.", { context: {
+				provider: "anthropic",
+				model: modelId
+			} }).at({ at: "anthropic.map.input.item" }));
+			if (item.type === "message") {
+				const role = typeof item.role === "string" ? item.role : "user";
+				const content = mapMessagePartsToAnthropicContent(item.content, role, String(modelId), betas);
+				if (content.isErr()) return err(content.error);
+				if (role === "system" || role === "developer") {
+					for (const part of content.value) if (part.type === "text") systemParts.push({
+						type: "text",
+						text: part.text
+					});
+				} else if (role === "assistant" || role === "user") messages.push({
+					role,
+					content: content.value
+				});
+				else return err(BetterAgentError.fromCode("VALIDATION_FAILED", `Anthropic does not support role '${role}'.`, { context: {
+					provider: "anthropic",
+					model: modelId,
+					role
+				} }).at({ at: "anthropic.map.input.role" }));
+				continue;
+			}
+			if (item.type === "tool-call" && "result" in item) {
+				const toolResult = item;
+				messages.push({
+					role: "assistant",
+					content: [{
+						type: "tool_use",
+						id: toolResult.callId,
+						name: toolResult.name,
+						input: parseMaybeJson(toolResult.arguments ?? "{}")
+					}]
+				});
+				messages.push({
+					role: "user",
+					content: [{
+						type: "tool_result",
+						tool_use_id: toolResult.callId,
+						content: serializeToolResultContent(toolResult.result),
+						is_error: toolResult.isError
+					}]
+				});
+				continue;
+			}
+			return err(BetterAgentError.fromCode("VALIDATION_FAILED", "Anthropic input items must be messages or completed tool-call results.", { context: {
+				provider: "anthropic",
+				model: modelId
+			} }).at({ at: "anthropic.map.input.unsupportedItem" }));
+		}
+		const anthropicTools = [];
+		const tools = ("tools" in o ? o.tools : []) ?? [];
+		const modelSupportsStructuredOutput = getAnthropicModelCapabilities(String(modelId)).supportsStructuredOutput;
+		for (const tool of tools) {
+			if (isAnthropicNativeToolDefinition(tool)) {
+				anthropicTools.push(mapAnthropicNativeToolToRequest(tool));
+				const beta = mapHostedToolBeta(tool.type);
+				if (beta) betas.add(beta);
+				continue;
+			}
+			const callableTool = tool;
+			if (!callableTool || !isCallableToolDefinition(callableTool)) continue;
+			const inputSchema = callableTool[TOOL_JSON_SCHEMA];
+			if (!isRecord(inputSchema) || inputSchema.type !== "object") return err(BetterAgentError.fromCode("VALIDATION_FAILED", "Anthropic custom tools require an object JSON schema.", { context: {
+				provider: "anthropic",
+				model: modelId,
+				toolName: callableTool.name
+			} }).at({ at: "anthropic.map.tools.schema" }));
+			anthropicTools.push(omitNullish({
+				name: String(callableTool.name ?? ""),
+				description: typeof callableTool.description === "string" ? callableTool.description : void 0,
+				input_schema: inputSchema,
+				strict: modelSupportsStructuredOutput && typeof callableTool.strict === "boolean" ? callableTool.strict : void 0
+			}));
+			if (modelSupportsStructuredOutput) betas.add("structured-outputs-2025-11-13");
+		}
+		const structuredOutput = "structured_output" in o ? o.structured_output : void 0;
+		const structuredOutputMode = o.structuredOutputMode ?? "auto";
+		const useStructuredOutput = structuredOutputMode === "outputFormat" || structuredOutputMode === "auto" && modelSupportsStructuredOutput;
+		let usesJsonResponseTool = false;
+		let outputConfig = o.effort != null ? { effort: o.effort } : void 0;
+		if (structuredOutput) {
+			if (!isRecord(structuredOutput.schema) || structuredOutput.schema.type !== "object") return err(BetterAgentError.fromCode("VALIDATION_FAILED", "Anthropic structured output schema must be a JSON object schema.", { context: {
+				provider: "anthropic",
+				model: modelId
+			} }).at({ at: "anthropic.map.structuredOutput.schema" }));
+			if (!useStructuredOutput) {
+				usesJsonResponseTool = true;
+				anthropicTools.push({
+					name: "json",
+					description: "Respond with a JSON object.",
+					input_schema: structuredOutput.schema
+				});
+			} else outputConfig = {
+				...outputConfig ?? {},
+				format: {
+					type: "json_schema",
+					schema: structuredOutput.schema
+				}
+			};
+		}
+		let toolChoice;
+		if (usesJsonResponseTool) toolChoice = {
+			type: "tool",
+			name: "json",
+			disable_parallel_tool_use: true
+		};
+		else if ("toolChoice" in o && o.toolChoice) switch (o.toolChoice.type) {
+			case "auto":
+				toolChoice = o.disableParallelToolUse ? {
+					type: "auto",
+					disable_parallel_tool_use: true
+				} : { type: "auto" };
+				break;
+			case "required":
+				toolChoice = {
+					type: "any",
+					...o.disableParallelToolUse ? { disable_parallel_tool_use: true } : {}
+				};
+				break;
+			case "tool":
+				toolChoice = {
+					type: "tool",
+					name: o.toolChoice.name,
+					...o.disableParallelToolUse ? { disable_parallel_tool_use: true } : {}
+				};
+				break;
+			case "none": break;
+		}
+		else if (o.disableParallelToolUse) toolChoice = {
+			type: "auto",
+			disable_parallel_tool_use: true
+		};
+		if (o.mcpServers?.length) betas.add("mcp-client-2025-04-04");
+		if (o.contextManagement) {
+			betas.add("context-management-2025-06-27");
+			if (o.contextManagement.edits.some((edit) => isRecord(edit) && edit.type === "compact_20260112")) betas.add("compact-2026-01-12");
+		}
+		if (o.container?.skills?.length) {
+			betas.add("code-execution-2025-08-25");
+			betas.add("skills-2025-10-02");
+			betas.add("files-api-2025-04-14");
+		}
+		if (o.effort) betas.add("effort-2025-11-24");
+		if (o.speed === "fast") betas.add("fast-mode-2026-02-01");
+		if (stream && (o.toolStreaming ?? true)) betas.add(FINE_GRAINED_TOOL_STREAMING_BETA);
+		return ok({
+			request: {
+				...extractPassthroughOptions(o, ANTHROPIC_RESPONSE_KNOWN_KEYS),
+				model: modelId,
+				max_tokens: o.max_tokens ?? DEFAULT_MAX_TOKENS,
+				messages,
+				...omitNullish({
+					system: systemParts.length ? systemParts : void 0,
+					cache_control: o.cacheControl,
+					metadata: o.metadata?.userId ? { user_id: o.metadata.userId } : void 0,
+					output_config: outputConfig,
+					stop_sequences: o.stop_sequences,
+					temperature: o.temperature,
+					stream: false,
+					speed: o.speed,
+					thinking: o.thinking == null ? void 0 : o.thinking.type === "enabled" ? {
+						type: "enabled",
+						budget_tokens: o.thinking.budgetTokens
+					} : o.thinking,
+					tool_choice: o.toolChoice?.type === "none" && !usesJsonResponseTool ? void 0 : toolChoice,
+					tools: o.toolChoice?.type === "none" && !usesJsonResponseTool ? void 0 : anthropicTools.length ? anthropicTools : void 0,
+					top_k: o.top_k,
+					top_p: o.top_p,
+					mcp_servers: o.mcpServers?.map((server) => ({
+						type: server.type,
+						name: server.name,
+						url: server.url,
+						authorization_token: server.authorizationToken,
+						tool_configuration: server.toolConfiguration ? {
+							enabled: server.toolConfiguration.enabled,
+							allowed_tools: server.toolConfiguration.allowedTools
+						} : void 0
+					})),
+					container: o.container ? {
+						...o.container.id != null ? { id: o.container.id } : {},
+						...o.container.skills?.length ? { skills: o.container.skills.map((skill) => ({
+							type: skill.type,
+							skill_id: skill.skillId,
+							...skill.version != null ? { version: skill.version } : {}
+						})) } : {}
+					} : void 0,
+					context_management: o.contextManagement ? { edits: o.contextManagement.edits.map(mapContextManagementEdit) } : void 0
+				})
+			},
+			betas: [...betas],
+			usesJsonResponseTool
+		});
+	} catch (e) {
+		return err(BetterAgentError.wrap({
+			err: e,
+			message: "Failed to map Anthropic Messages request",
+			opts: {
+				code: "INTERNAL",
+				context: {
+					provider: "anthropic",
+					model: args.modelId
+				}
+			}
+		}).at({ at: "anthropic.messages.mapToRequest" }));
+	}
+}
+const mapProviderToolResultName = (part, serverToolCalls, mcpToolCalls) => {
+	if (part.type === "server_tool_use" && typeof part.name === "string") return normalizeProviderToolName(part.name);
+	if (part.type === "mcp_tool_use") return typeof part.name === "string" ? part.name : "mcp";
+	if (part.type === "mcp_tool_result") return mcpToolCalls[part.tool_use_id ?? ""] ?? "mcp";
+	const resolvedServerName = serverToolCalls[part.tool_use_id ?? ""];
+	if (resolvedServerName) return normalizeProviderToolName(resolvedServerName);
+	switch (part.type) {
+		case "web_fetch_tool_result": return "web_fetch";
+		case "web_search_tool_result": return "web_search";
+		case "code_execution_tool_result":
+		case "bash_code_execution_tool_result":
+		case "text_editor_code_execution_tool_result": return "code_execution";
+		case "tool_search_tool_result": return "tool_search_tool_regex";
+		default: return part.type;
+	}
+};
+function mapFromAnthropicMessagesResponse(args) {
+	const assistantParts = [];
+	const outputItems = [];
+	const serverToolCalls = {};
+	const mcpToolCalls = {};
+	let isJsonResponseFromTool = false;
+	for (const part of args.response.content) switch (part.type) {
+		case "text":
+			assistantParts.push({
+				type: "text",
+				text: part.text,
+				...part.citations?.length ? { providerMetadata: getAnthropicTextProviderMetadata(part.citations) } : {}
+			});
+			break;
+		case "compaction":
+			assistantParts.push({
+				type: "text",
+				text: part.content
+			});
+			break;
+		case "tool_use":
+			if (args.usesJsonResponseTool && part.name === "json") {
+				isJsonResponseFromTool = true;
+				assistantParts.push({
+					type: "text",
+					text: JSON.stringify(part.input)
+				});
+			} else outputItems.push({
+				type: "tool-call",
+				name: part.name,
+				arguments: JSON.stringify(part.input ?? {}),
+				callId: part.id
+			});
+			break;
+		case "server_tool_use":
+			serverToolCalls[part.id] = part.name;
+			outputItems.push({
+				type: "provider-tool-result",
+				name: normalizeProviderToolName(part.name),
+				callId: part.id,
+				result: part
+			});
+			break;
+		case "mcp_tool_use":
+			mcpToolCalls[part.id] = part.name;
+			outputItems.push({
+				type: "provider-tool-result",
+				name: part.name,
+				callId: part.id,
+				result: part
+			});
+			break;
+		case "mcp_tool_result":
+		case "web_fetch_tool_result":
+		case "web_search_tool_result":
+		case "code_execution_tool_result":
+		case "bash_code_execution_tool_result":
+		case "text_editor_code_execution_tool_result":
+		case "tool_search_tool_result":
+			outputItems.push({
+				type: "provider-tool-result",
+				name: mapProviderToolResultName(part, serverToolCalls, mcpToolCalls),
+				callId: part.tool_use_id,
+				result: part,
+				isError: "is_error" in part && typeof part.is_error === "boolean" ? part.is_error : void 0
+			});
+			break;
+		case "thinking":
+		case "redacted_thinking": break;
+	}
+	if (assistantParts.length) outputItems.unshift({
+		type: "message",
+		role: "assistant",
+		content: assistantParts
+	});
+	return {
+		output: outputItems,
+		finishReason: mapAnthropicStopReason(args.response.stop_reason, isJsonResponseFromTool),
+		usage: mapAnthropicUsage(args.response.usage),
+		response: { body: args.response }
+	};
+}
+const createAnthropicStreamState = (messageId, usesJsonResponseTool = false) => ({
+	messageId,
+	outputItems: [],
+	assistantParts: [],
+	blocks: {},
+	serverToolCalls: {},
+	mcpToolCalls: {},
+	finishReasonRaw: void 0,
+	usage: {},
+	usesJsonResponseTool
+});
+const createToolStartEvent = (parentMessageId, toolCallId, toolCallName) => ({
+	type: Events.TOOL_CALL_START,
+	parentMessageId,
+	toolCallId,
+	toolCallName,
+	timestamp: Date.now()
+});
+const createToolArgsEvent = (parentMessageId, toolCallId, toolCallName, delta) => ({
+	type: Events.TOOL_CALL_ARGS,
+	parentMessageId,
+	toolCallId,
+	toolCallName,
+	delta,
+	timestamp: Date.now()
+});
+const createToolEndEvent = (parentMessageId, toolCallId, toolCallName) => ({
+	type: Events.TOOL_CALL_END,
+	parentMessageId,
+	toolCallId,
+	toolCallName,
+	timestamp: Date.now()
+});
+const createToolResultEvent = (parentMessageId, toolCallId, toolCallName, result, isError) => ({
+	type: Events.TOOL_CALL_RESULT,
+	parentMessageId,
+	toolCallId,
+	toolCallName,
+	result,
+	isError,
+	timestamp: Date.now()
+});
+const finalizeStreamResponse = (state) => {
+	const output = [...state.outputItems];
+	if (state.assistantParts.length) output.unshift({
+		type: "message",
+		role: "assistant",
+		content: state.assistantParts
+	});
+	const hasToolCalls = output.some((item) => item.type === "tool-call" && "arguments" in item);
+	return {
+		output,
+		finishReason: state.finishReasonRaw == null && hasToolCalls ? "tool-calls" : mapAnthropicStopReason(state.finishReasonRaw, state.usesJsonResponseTool),
+		usage: mapAnthropicUsage(state.usage)
+	};
+};
+function mapFromAnthropicStreamEvent(event, state) {
+	switch (event.type) {
+		case "ping": return ok(null);
+		case "message_start":
+			state.usage = {
+				...state.usage,
+				...event.message.usage
+			};
+			state.finishReasonRaw = event.message.stop_reason;
+			return ok(null);
+		case "message_delta":
+			if (event.delta.stop_reason != null) state.finishReasonRaw = event.delta.stop_reason;
+			state.usage = {
+				...state.usage,
+				...event.usage ?? {}
+			};
+			return ok(null);
+		case "content_block_start": {
+			const { index, content_block: part } = event;
+			switch (part.type) {
+				case "text":
+				case "compaction": {
+					const textMessageId = `${state.messageId}:text:${index}`;
+					state.blocks[index] = {
+						kind: "text",
+						messageId: textMessageId,
+						text: part.type === "compaction" ? part.content : "",
+						...part.type === "text" && part.citations?.length ? { citations: [...part.citations] } : {}
+					};
+					return ok({
+						kind: "event",
+						event: {
+							type: Events.TEXT_MESSAGE_START,
+							messageId: textMessageId,
+							role: "assistant",
+							timestamp: Date.now()
+						}
+					});
+				}
+				case "thinking":
+				case "redacted_thinking": {
+					const reasoningMessageId = `${state.messageId}:reasoning:${index}`;
+					state.blocks[index] = {
+						kind: "reasoning",
+						messageId: reasoningMessageId
+					};
+					return ok({
+						kind: "event",
+						event: {
+							type: Events.REASONING_MESSAGE_START,
+							messageId: reasoningMessageId,
+							role: "assistant",
+							visibility: "full",
+							timestamp: Date.now()
+						}
+					});
+				}
+				case "tool_use": {
+					const outputAsText = state.usesJsonResponseTool && part.name === "json";
+					const initialInput = JSON.stringify(part.input ?? {});
+					state.blocks[index] = {
+						kind: "tool",
+						callId: part.id,
+						toolName: part.name,
+						rawToolName: part.name,
+						rawType: "tool_use",
+						input: initialInput === "{}" ? "" : initialInput,
+						outputAsText,
+						providerExecuted: false
+					};
+					if (outputAsText) {
+						const textMessageId = `${state.messageId}:text:${index}`;
+						state.blocks[index] = {
+							...state.blocks[index],
+							kind: "tool"
+						};
+						return ok({
+							kind: "event",
+							event: {
+								type: Events.TEXT_MESSAGE_START,
+								messageId: textMessageId,
+								role: "assistant",
+								timestamp: Date.now()
+							}
+						});
+					}
+					return ok({
+						kind: "event",
+						event: createToolStartEvent(state.messageId, part.id, part.name)
+					});
+				}
+				case "server_tool_use":
+					state.serverToolCalls[part.id] = part.name;
+					state.blocks[index] = {
+						kind: "tool",
+						callId: part.id,
+						toolName: normalizeProviderToolName(part.name),
+						rawToolName: part.name,
+						rawType: "server_tool_use",
+						input: JSON.stringify(part.input ?? {}) === "{}" ? "" : JSON.stringify(part.input ?? {}),
+						outputAsText: false,
+						providerExecuted: true
+					};
+					return ok({
+						kind: "event",
+						event: createToolStartEvent(state.messageId, part.id, normalizeProviderToolName(part.name))
+					});
+				case "mcp_tool_use":
+					state.mcpToolCalls[part.id] = part.name;
+					state.blocks[index] = {
+						kind: "tool",
+						callId: part.id,
+						toolName: part.name,
+						rawToolName: part.name,
+						rawType: "mcp_tool_use",
+						input: JSON.stringify(part.input ?? {}) === "{}" ? "" : JSON.stringify(part.input ?? {}),
+						outputAsText: false,
+						providerExecuted: true,
+						extra: part.server_name != null ? { server_name: part.server_name } : void 0
+					};
+					return ok({
+						kind: "event",
+						event: createToolStartEvent(state.messageId, part.id, part.name)
+					});
+				case "mcp_tool_result":
+				case "web_fetch_tool_result":
+				case "web_search_tool_result":
+				case "code_execution_tool_result":
+				case "bash_code_execution_tool_result":
+				case "text_editor_code_execution_tool_result":
+				case "tool_search_tool_result": {
+					const toolName = mapProviderToolResultName(part, state.serverToolCalls, state.mcpToolCalls);
+					state.outputItems.push({
+						type: "provider-tool-result",
+						name: toolName,
+						callId: part.tool_use_id,
+						result: part,
+						isError: "is_error" in part && typeof part.is_error === "boolean" ? part.is_error : void 0
+					});
+					return ok({
+						kind: "event",
+						event: createToolResultEvent(state.messageId, part.tool_use_id, toolName, part, "is_error" in part && typeof part.is_error === "boolean" ? part.is_error : void 0)
+					});
+				}
+			}
+			return ok(null);
+		}
+		case "content_block_delta": {
+			const block = state.blocks[event.index];
+			if (!block) return ok(null);
+			switch (event.delta.type) {
+				case "text_delta":
+					if (block.kind !== "text") return ok(null);
+					block.text += event.delta.text;
+					return ok({
+						kind: "event",
+						event: {
+							type: Events.TEXT_MESSAGE_CONTENT,
+							messageId: block.messageId,
+							delta: event.delta.text,
+							timestamp: Date.now()
+						}
+					});
+				case "compaction_delta":
+					if (block.kind !== "text") return ok(null);
+					if (event.delta.content) {
+						block.text += event.delta.content;
+						return ok({
+							kind: "event",
+							event: {
+								type: Events.TEXT_MESSAGE_CONTENT,
+								messageId: block.messageId,
+								delta: event.delta.content,
+								timestamp: Date.now()
+							}
+						});
+					}
+					return ok(null);
+				case "thinking_delta":
+					if (block.kind !== "reasoning") return ok(null);
+					return ok({
+						kind: "event",
+						event: {
+							type: Events.REASONING_MESSAGE_CONTENT,
+							messageId: block.messageId,
+							visibility: "full",
+							delta: event.delta.thinking,
+							timestamp: Date.now()
+						}
+					});
+				case "signature_delta": return ok(null);
+				case "input_json_delta":
+					if (block.kind !== "tool") return ok(null);
+					block.input += event.delta.partial_json;
+					if (block.outputAsText) return ok({
+						kind: "event",
+						event: {
+							type: Events.TEXT_MESSAGE_CONTENT,
+							messageId: `${state.messageId}:text:${event.index}`,
+							delta: event.delta.partial_json,
+							timestamp: Date.now()
+						}
+					});
+					return ok({
+						kind: "event",
+						event: createToolArgsEvent(state.messageId, block.callId, block.toolName, event.delta.partial_json)
+					});
+				case "citations_delta":
+					if (block.kind !== "text") return ok(null);
+					block.citations = [...block.citations ?? [], event.delta.citation];
+					return ok(null);
+			}
+			return ok(null);
+		}
+		case "content_block_stop": {
+			const block = state.blocks[event.index];
+			if (!block) return ok(null);
+			delete state.blocks[event.index];
+			if (block.kind === "text") {
+				if (block.text.length > 0) state.assistantParts.push({
+					type: "text",
+					text: block.text,
+					...block.citations?.length ? { providerMetadata: getAnthropicTextProviderMetadata(block.citations) } : {}
+				});
+				return ok({
+					kind: "event",
+					event: {
+						type: Events.TEXT_MESSAGE_END,
+						messageId: block.messageId,
+						timestamp: Date.now()
+					}
+				});
+			}
+			if (block.kind === "reasoning") return ok({
+				kind: "event",
+				event: {
+					type: Events.REASONING_MESSAGE_END,
+					messageId: block.messageId,
+					visibility: "full",
+					timestamp: Date.now()
+				}
+			});
+			if (block.outputAsText) {
+				const finalText = block.input.trim() ? block.input : "{}";
+				state.assistantParts.push({
+					type: "text",
+					text: finalText
+				});
+				state.usesJsonResponseTool = true;
+				return ok({
+					kind: "event",
+					event: {
+						type: Events.TEXT_MESSAGE_END,
+						messageId: `${state.messageId}:text:${event.index}`,
+						timestamp: Date.now()
+					}
+				});
+			}
+			if (block.rawType === "tool_use") state.outputItems.push({
+				type: "tool-call",
+				name: block.toolName,
+				arguments: block.input.trim() ? block.input : "{}",
+				callId: block.callId
+			});
+			else state.outputItems.push({
+				type: "provider-tool-result",
+				name: block.toolName,
+				callId: block.callId,
+				result: omitNullish({
+					type: block.rawType,
+					id: block.callId,
+					name: block.rawToolName,
+					input: parseMaybeJson(block.input),
+					...block.extra ?? {}
+				})
+			});
+			return ok({
+				kind: "event",
+				event: createToolEndEvent(state.messageId, block.callId, block.toolName)
+			});
+		}
+		case "message_stop": return ok({
+			kind: "final",
+			response: finalizeStreamResponse(state)
+		});
+		case "error": return err(BetterAgentError.fromCode("UPSTREAM_FAILED", event.error.message ?? "Anthropic streaming error", { context: {
+			provider: "anthropic",
+			upstreamCode: event.error.type ?? "STREAM_ERROR",
+			raw: event
+		} }).at({ at: "anthropic.messages.stream.event" }));
+	}
+}
+
+//#endregion
+//#region src/anthropic/responses/model.ts
+const ANTHROPIC_RESPONSE_CAPS = {
+	inputModalities: {
+		text: true,
+		image: true,
+		file: true
+	},
+	inputShape: "chat",
+	replayMode: "multi_turn",
+	supportsInstruction: true,
+	outputModalities: { text: { options: {} } },
+	tools: true,
+	structured_output: true,
+	additionalSupportedRoles: ["developer"]
+};
+const createDeferred = () => {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+};
+const createAnthropicResponsesModel = (modelId, client) => {
+	const doGenerate = async (options, ctx) => {
+		const mappedRequest = mapToAnthropicMessagesRequest({
+			modelId,
+			options,
+			stream: false
+		});
+		if (mappedRequest.isErr()) return err(mappedRequest.error.at({ at: "anthropic.generate.mapRequest" }));
+		const raw = await client.messages.create(mappedRequest.value.request, {
+			signal: ctx.signal ?? null,
+			beta: mappedRequest.value.betas
+		});
+		if (raw.isErr()) return err(raw.error.at({ at: "anthropic.generate.http" }));
+		return ok({ response: {
+			...mapFromAnthropicMessagesResponse({
+				response: raw.value,
+				usesJsonResponseTool: mappedRequest.value.usesJsonResponseTool
+			}),
+			request: { body: mappedRequest.value.request }
+		} });
+	};
+	const doGenerateStream = async (options, ctx) => {
+		const mappedRequest = mapToAnthropicMessagesRequest({
+			modelId,
+			options,
+			stream: true
+		});
+		if (mappedRequest.isErr()) return err(mappedRequest.error.at({ at: "anthropic.generateStream.mapRequest" }));
+		const streamResult = await client.messages.stream({
+			...mappedRequest.value.request,
+			stream: true
+		}, {
+			signal: ctx.signal ?? null,
+			beta: mappedRequest.value.betas
+		});
+		if (streamResult.isErr()) return err(streamResult.error.at({ at: "anthropic.generateStream.http" }));
+		const { promise: final, resolve: resolveFinal, reject: rejectFinal } = createDeferred();
+		return ok({
+			events: (async function* () {
+				const state = createAnthropicStreamState(ctx.generateMessageId(), mappedRequest.value.usesJsonResponseTool);
+				let sawFinal = false;
+				try {
+					for await (const raw of streamResult.value) {
+						if (raw.isErr()) {
+							rejectFinal(raw.error);
+							yield err(raw.error);
+							return;
+						}
+						const mapped = mapFromAnthropicStreamEvent(raw.value, state);
+						if (mapped.isErr()) {
+							const error = mapped.error.at({ at: "anthropic.generateStream.mapEvent" });
+							rejectFinal(error);
+							yield err(error);
+							return;
+						}
+						if (!mapped.value) continue;
+						if (mapped.value.kind === "final") {
+							sawFinal = true;
+							resolveFinal({
+								...mapped.value.response,
+								request: { body: mappedRequest.value.request }
+							});
+							continue;
+						}
+						yield ok(mapped.value.event);
+					}
+				} finally {
+					if (!sawFinal) rejectFinal(BetterAgentError.fromCode("UPSTREAM_FAILED", "Anthropic stream ended without a final response event.", { context: {
+						provider: "anthropic",
+						model: String(modelId)
+					} }).at({ at: "anthropic.generateStream.final" }));
+				}
+			})(),
+			final
+		});
+	};
+	return {
+		providerId: "anthropic",
+		modelId,
+		caps: ANTHROPIC_RESPONSE_CAPS,
+		doGenerate,
+		doGenerateStream
+	};
+};
+
+//#endregion
+//#region src/anthropic/provider.ts
+const createAnthropic = (config) => {
+	const httpClient = createAnthropicClient(config);
+	return {
+		id: "anthropic",
+		tools: createAnthropicNativeToolBuilders(),
+		model(modelId) {
+			return createAnthropicResponsesModel(modelId, httpClient);
+		},
+		text(modelId) {
+			return createAnthropicResponsesModel(modelId, httpClient);
+		}
+	};
+};
+
+//#endregion
+export { createAnthropic };
+//# sourceMappingURL=index.mjs.map