@byfriends/kosong 0.1.0

package/dist/providers/anthropic.mjs

@@ -0,0 +1,720 @@
+import { a as APITimeoutError, o as ChatProviderError, s as normalizeAPIStatusError, t as APIConnectionError$1 } from "../errors-WFxxzL1B.mjs";
+import { n as requireProviderApiKey, r as resolveAuthBackedClient, t as mergeRequestHeaders } from "../request-auth-DCWSyCKI.mjs";
+import { t as getAnthropicModelCapability } from "../capability-registry-CMBuEYcf.mjs";
+import Anthropic, { APIConnectionError, APIConnectionTimeoutError, APIError, AnthropicError } from "@anthropic-ai/sdk";
+//#region src/providers/anthropic.ts
+/**
+* Normalize an Anthropic `stop_reason` string to the unified
+* {@link FinishReason} enum.
+*
+* Source: `message.stop_reason` (non-stream) or the last `message_delta`
+* event's `delta.stop_reason` (stream).
+*/
+function normalizeAnthropicStopReason(raw) {
+	if (raw === null || raw === void 0) return {
+		finishReason: null,
+		rawFinishReason: null
+	};
+	switch (raw) {
+		case "end_turn":
+		case "stop_sequence": return {
+			finishReason: "completed",
+			rawFinishReason: raw
+		};
+		case "max_tokens": return {
+			finishReason: "truncated",
+			rawFinishReason: raw
+		};
+		case "tool_use": return {
+			finishReason: "tool_calls",
+			rawFinishReason: raw
+		};
+		case "pause_turn": return {
+			finishReason: "paused",
+			rawFinishReason: raw
+		};
+		case "refusal": return {
+			finishReason: "filtered",
+			rawFinishReason: raw
+		};
+		default: return {
+			finishReason: "other",
+			rawFinishReason: raw
+		};
+	}
+}
+const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+const FAMILY_VERSION_RE = /(?:opus|sonnet|haiku)[.-](\d+)[.-](\d{1,2})(?!\d)/;
+const OPUS_VERSION_RE = /opus[.-](\d+)[.-](\d{1,2})(?!\d)/;
+const ADAPTIVE_MIN_VERSION = {
+	major: 4,
+	minor: 6
+};
+/**
+* Per-version default output ceilings sourced from Anthropic's Messages
+* API model cards (platform.claude.com/docs/en/about-claude/models/overview).
+* Values are the documented synchronous Messages-API maximum — we send
+* the full ceiling because Claude 4 + interleaved-thinking shares this
+* budget with encrypted reasoning, so anything below the documented cap
+* can silently truncate mid-`tool_use`.
+*
+* Keys are `<family>-<major>[-<minor>]`. Lookups try the most specific
+* key first, then fall back to the family/major-only entry, so an
+* unrecognized minor version (e.g. a future `opus-4-10`) gets the
+* family's baseline rather than the generic fallback.
+*/
+const CEILING_BY_FAMILY_VERSION = {
+	"opus-4-7": 128e3,
+	"opus-4-6": 128e3,
+	"opus-4-5": 64e3,
+	"opus-4-1": 32e3,
+	"opus-4-0": 32e3,
+	"opus-4": 32e3,
+	"sonnet-4-6": 64e3,
+	"sonnet-4-5": 64e3,
+	"sonnet-4-0": 64e3,
+	"sonnet-4": 64e3,
+	"haiku-4-5": 64e3,
+	"haiku-4": 64e3,
+	"opus-3-5": 8192,
+	"sonnet-3-5": 8192,
+	"sonnet-3-7": 8192,
+	"haiku-3-5": 8192,
+	"opus-3": 4096,
+	"sonnet-3": 4096,
+	"haiku-3": 4096
+};
+const FALLBACK_MAX_TOKENS = 32e3;
+const FAMILY_FIRST_RE = /(opus|sonnet|haiku)[-._](\d{1,2})(?!\d)(?:[-._](\d{1,2})(?!\d))?/;
+const VERSION_FIRST_RE = /(\d{1,2})[-._](\d{1,2})[-._](opus|sonnet|haiku)/;
+const BARE_FAMILY_RE = /(\d{1,2})[-._](opus|sonnet|haiku)/;
+/**
+* Extract Claude family + version from a model id.
+*
+* Designed to survive the naming variants we see across vendors:
+* vendor prefixes (`anthropic.`, `aws/`, `openrouter/`,
+* `online-`), suffixes (date stamps like `-20251001`, build tags
+* like `-construct`, `-v1:0`), and `.` vs `-` separators between
+* the family and version components.
+*
+* Returns `null` when the id contains no Claude marker or no
+* recognizable family/version, in which case the resolver should fall
+* back to the override or {@link FALLBACK_MAX_TOKENS}.
+*/
+function parseClaudeVersion(model) {
+	const normalized = model.toLowerCase();
+	if (!normalized.includes("claude")) return null;
+	const familyFirst = FAMILY_FIRST_RE.exec(normalized);
+	if (familyFirst !== null) return {
+		family: familyFirst[1],
+		major: Number.parseInt(familyFirst[2], 10),
+		minor: familyFirst[3] !== void 0 ? Number.parseInt(familyFirst[3], 10) : null
+	};
+	const versionFirst = VERSION_FIRST_RE.exec(normalized);
+	if (versionFirst !== null) return {
+		major: Number.parseInt(versionFirst[1], 10),
+		minor: Number.parseInt(versionFirst[2], 10),
+		family: versionFirst[3]
+	};
+	const bare = BARE_FAMILY_RE.exec(normalized);
+	if (bare !== null) return {
+		major: Number.parseInt(bare[1], 10),
+		minor: null,
+		family: bare[2]
+	};
+	return null;
+}
+function lookupClaudeCeiling(version) {
+	const { family, major, minor } = version;
+	if (minor !== null) {
+		const exact = CEILING_BY_FAMILY_VERSION[`${family}-${major}-${minor}`];
+		if (exact !== void 0) return exact;
+	}
+	return CEILING_BY_FAMILY_VERSION[`${family}-${major}`];
+}
+/**
+* Resolve the default `max_tokens` for an Anthropic request.
+*
+* Precedence:
+*   1. Caller-provided `override` (e.g. `models.<alias>.maxOutputSize`
+*      from the harness config) — honored when present so users can
+*      intentionally lower the budget (handy for forcing truncation
+*      in tests) or raise it on a model we don't yet know about.
+*   2. When the model id parses to a known Claude family + version,
+*      the override is clamped to the documented Messages-API ceiling
+*      so we never send a value the server would reject.
+*   3. With no override and no recognized version, fall back to
+*      {@link FALLBACK_MAX_TOKENS}.
+*/
+function resolveDefaultMaxTokens(model, override) {
+	const parsed = parseClaudeVersion(model);
+	const ceiling = parsed === null ? void 0 : lookupClaudeCeiling(parsed);
+	if (ceiling === void 0) return override ?? FALLBACK_MAX_TOKENS;
+	return override === void 0 ? ceiling : Math.min(override, ceiling);
+}
+function parseVersion(match) {
+	const majorRaw = match[1];
+	const minorRaw = match[2];
+	if (majorRaw === void 0 || minorRaw === void 0) throw new Error("Model version regex did not capture major and minor versions.");
+	return {
+		major: Number.parseInt(majorRaw, 10),
+		minor: Number.parseInt(minorRaw, 10)
+	};
+}
+function versionAtLeast(version, minimum) {
+	return version.major > minimum.major || version.major === minimum.major && version.minor >= minimum.minor;
+}
+function supportsAdaptiveThinking(model) {
+	const normalized = model.toLowerCase();
+	const match = FAMILY_VERSION_RE.exec(normalized);
+	if (match === null) return false;
+	return versionAtLeast(parseVersion(match), ADAPTIVE_MIN_VERSION);
+}
+function isOpus47(model) {
+	const match = OPUS_VERSION_RE.exec(model.toLowerCase());
+	if (match === null) return false;
+	const version = parseVersion(match);
+	return version.major === 4 && version.minor === 7;
+}
+function supportsEffortParam(model) {
+	if (supportsAdaptiveThinking(model)) return true;
+	const normalized = model.toLowerCase();
+	return normalized.includes("opus-4-5") || normalized.includes("opus-4.5");
+}
+function clampEffort(effort, model) {
+	if (effort === "off") return effort;
+	if (effort === "xhigh" && !isOpus47(model)) return "high";
+	if (effort === "max" && !supportsAdaptiveThinking(model)) return "high";
+	return effort;
+}
+function budgetTokensForEffort(effort) {
+	switch (effort) {
+		case "low": return 1024;
+		case "medium": return 4096;
+		case "high": return 32e3;
+		case "off":
+		case "xhigh":
+		case "max": throw new Error(`Unsupported budget-based thinking effort: ${effort}`);
+	}
+	throw new Error(`Unknown thinking effort: ${String(effort)}`);
+}
+const CACHE_CONTROL = { type: "ephemeral" };
+/**
+* Content block types that support cache_control injection.
+*/
+const CACHEABLE_TYPES = new Set([
+	"text",
+	"image",
+	"document",
+	"search_result",
+	"tool_use",
+	"tool_result",
+	"server_tool_use",
+	"web_search_tool_result"
+]);
+function injectCacheControlOnLastBlock(messages) {
+	const lastMessage = messages.at(-1);
+	if (lastMessage === void 0) return;
+	const content = lastMessage.content;
+	if (!Array.isArray(content) || content.length === 0) return;
+	const lastBlock = content.at(-1);
+	if (lastBlock === void 0) return;
+	if (CACHEABLE_TYPES.has(lastBlock.type)) lastBlock.cache_control = CACHE_CONTROL;
+}
+/**
+* Check whether a MessageParam is a user message whose content consists
+* entirely of `tool_result` blocks.
+*
+* Used to detect adjacent tool-result-only messages that must be merged
+* before hitting the Anthropic wire. Per the Messages API parallel-tool-use
+* spec, all `tool_result` blocks answering parallel `tool_use` calls must
+* live in a single user message — splitting them across consecutive user
+* messages fails on strict Anthropic-compatible backends (HTTP 400) and
+* silently degrades parallel tool use on api.anthropic.com.
+*/
+function isToolResultOnly(message) {
+	if (message.role !== "user") return false;
+	const content = message.content;
+	if (!Array.isArray(content) || content.length === 0) return false;
+	return content.every((block) => block.type === "tool_result");
+}
+const SUPPORTED_B64_MEDIA_TYPES = new Set([
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+]);
+function imageUrlPartToAnthropic(url) {
+	if (url.startsWith("data:")) {
+		const parts = url.slice(5).split(";base64,", 2);
+		if (parts.length !== 2 || parts[0] === void 0 || parts[1] === void 0) throw new ChatProviderError(`Invalid data URL for image: ${url}`);
+		const mediaType = parts[0];
+		const data = parts[1];
+		if (!SUPPORTED_B64_MEDIA_TYPES.has(mediaType)) throw new ChatProviderError(`Unsupported media type for base64 image: ${mediaType}, url: ${url}`);
+		return {
+			type: "image",
+			source: {
+				type: "base64",
+				data,
+				media_type: mediaType
+			}
+		};
+	}
+	return {
+		type: "image",
+		source: {
+			type: "url",
+			url
+		}
+	};
+}
+function convertTool(tool) {
+	return {
+		name: tool.name,
+		description: tool.description,
+		input_schema: tool.parameters
+	};
+}
+function toolResultToBlock(toolCallId, content) {
+	const blocks = [];
+	for (const part of content) if (part.type === "text") {
+		if (part.text) blocks.push({
+			type: "text",
+			text: part.text
+		});
+	} else if (part.type === "image_url") blocks.push(imageUrlPartToAnthropic(part.imageUrl.url));
+	return {
+		type: "tool_result",
+		tool_use_id: toolCallId,
+		content: blocks
+	};
+}
+function convertMessage(message) {
+	const role = message.role;
+	if (role === "system") return {
+		role: "user",
+		content: [{
+			type: "text",
+			text: `<system>${message.content.filter((p) => p.type === "text").map((p) => p.text).join("\n")}</system>`
+		}]
+	};
+	if (role === "tool") {
+		if (message.toolCallId === void 0) throw new ChatProviderError("Tool message missing `toolCallId`.");
+		return {
+			role: "user",
+			content: [toolResultToBlock(message.toolCallId, message.content)]
+		};
+	}
+	const blocks = [];
+	for (const part of message.content) if (part.type === "text") blocks.push({
+		type: "text",
+		text: part.text
+	});
+	else if (part.type === "image_url") blocks.push(imageUrlPartToAnthropic(part.imageUrl.url));
+	else if (part.type === "think") {
+		if (part.encrypted === void 0) continue;
+		blocks.push({
+			type: "thinking",
+			thinking: part.think,
+			signature: part.encrypted
+		});
+	}
+	if (message.toolCalls.length > 0) for (const tc of message.toolCalls) {
+		let toolInput = {};
+		if (tc.arguments) try {
+			const parsed = JSON.parse(tc.arguments);
+			if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) toolInput = parsed;
+			else throw new ChatProviderError("Tool call arguments must be a JSON object.");
+		} catch (error) {
+			if (error instanceof ChatProviderError) throw error;
+			throw new ChatProviderError("Tool call arguments must be valid JSON.");
+		}
+		blocks.push({
+			type: "tool_use",
+			id: tc.id,
+			name: tc.name,
+			input: toolInput
+		});
+	}
+	return {
+		role,
+		content: blocks
+	};
+}
+function convertAnthropicError(error) {
+	if (error instanceof APIConnectionTimeoutError) return new APITimeoutError(error.message);
+	if (error instanceof APIConnectionError) return new APIConnectionError$1(error.message);
+	if (error instanceof APIError && typeof error.status === "number") {
+		const reqId = error.requestID ?? null;
+		return normalizeAPIStatusError(error.status, error.message, reqId);
+	}
+	if (error instanceof AnthropicError) return new ChatProviderError(`Anthropic error: ${error.message}`);
+	if (error instanceof Error) return new ChatProviderError(`Error: ${error.message}`);
+	return new ChatProviderError(`Error: ${String(error)}`);
+}
+var AnthropicStreamedMessage = class {
+	_id = null;
+	_usage = {
+		inputOther: 0,
+		output: 0,
+		inputCacheRead: 0,
+		inputCacheCreation: 0
+	};
+	_finishReason = null;
+	_rawFinishReason = null;
+	_iter;
+	constructor(response, isStream) {
+		if (isStream) this._iter = this._convertStreamResponse(response);
+		else this._iter = this._convertNonStreamResponse(response);
+	}
+	get id() {
+		return this._id;
+	}
+	get usage() {
+		return this._usage;
+	}
+	get finishReason() {
+		return this._finishReason;
+	}
+	get rawFinishReason() {
+		return this._rawFinishReason;
+	}
+	async *[Symbol.asyncIterator]() {
+		yield* this._iter;
+	}
+	_captureStopReason(raw) {
+		const normalized = normalizeAnthropicStopReason(raw);
+		this._finishReason = normalized.finishReason;
+		this._rawFinishReason = normalized.rawFinishReason;
+	}
+	_extractUsage(usage) {
+		this._usage = {
+			inputOther: usage.input_tokens ?? 0,
+			output: usage.output_tokens ?? 0,
+			inputCacheRead: usage.cache_read_input_tokens ?? 0,
+			inputCacheCreation: usage.cache_creation_input_tokens ?? 0
+		};
+	}
+	async *_convertNonStreamResponse(response) {
+		this._id = response.id;
+		this._extractUsage(response.usage);
+		this._captureStopReason(response.stop_reason);
+		for (const block of response.content) switch (block.type) {
+			case "text":
+				if (block.text !== void 0) yield {
+					type: "text",
+					text: block.text
+				};
+				break;
+			case "thinking":
+				yield block.signature !== void 0 ? {
+					type: "think",
+					think: block.thinking ?? "",
+					encrypted: block.signature
+				} : {
+					type: "think",
+					think: block.thinking ?? ""
+				};
+				break;
+			case "redacted_thinking":
+				yield block.data !== void 0 ? {
+					type: "think",
+					think: "",
+					encrypted: block.data
+				} : {
+					type: "think",
+					think: ""
+				};
+				break;
+			case "tool_use":
+				yield {
+					type: "function",
+					id: block.id ?? crypto.randomUUID(),
+					name: block.name ?? "",
+					arguments: block.input !== void 0 ? JSON.stringify(block.input) : null
+				};
+				break;
+		}
+	}
+	async *_convertStreamResponse(response) {
+		const toolUseBlockIndexes = /* @__PURE__ */ new Set();
+		try {
+			for await (const event of response) {
+				const evt = event;
+				const eventType = evt["type"];
+				if (eventType === "message_start") {
+					const startEvt = evt;
+					this._id = startEvt.message.id;
+					this._extractUsage(startEvt.message.usage);
+				} else if (eventType === "content_block_start") {
+					const blockEvt = evt;
+					const block = blockEvt.content_block;
+					const blockIndex = blockEvt.index;
+					switch (block.type) {
+						case "text":
+							yield {
+								type: "text",
+								text: block.text
+							};
+							break;
+						case "thinking":
+							yield {
+								type: "think",
+								think: block.thinking
+							};
+							break;
+						case "redacted_thinking":
+							yield {
+								type: "think",
+								think: "",
+								encrypted: block.data
+							};
+							break;
+						case "tool_use":
+							toolUseBlockIndexes.add(blockIndex);
+							yield {
+								type: "function",
+								id: block.id,
+								name: block.name,
+								arguments: "",
+								_streamIndex: blockIndex
+							};
+							break;
+					}
+				} else if (eventType === "content_block_delta") {
+					const deltaEvt = evt;
+					const delta = deltaEvt.delta;
+					const blockIndex = deltaEvt.index;
+					switch (delta.type) {
+						case "text_delta":
+							yield {
+								type: "text",
+								text: delta.text
+							};
+							break;
+						case "thinking_delta":
+							yield {
+								type: "think",
+								think: delta.thinking
+							};
+							break;
+						case "input_json_delta":
+							yield {
+								type: "tool_call_part",
+								argumentsPart: delta.partial_json,
+								index: blockIndex
+							};
+							break;
+						case "signature_delta":
+							yield {
+								type: "think",
+								think: "",
+								encrypted: delta.signature
+							};
+							break;
+					}
+				} else if (eventType === "content_block_stop") {} else if (eventType === "message_delta") {
+					const deltaUsage = evt.usage;
+					if (deltaUsage !== void 0) {
+						if (typeof deltaUsage["output_tokens"] === "number") this._usage.output = deltaUsage["output_tokens"];
+						if (typeof deltaUsage["cache_read_input_tokens"] === "number") this._usage.inputCacheRead = deltaUsage["cache_read_input_tokens"];
+						if (typeof deltaUsage["cache_creation_input_tokens"] === "number") this._usage.inputCacheCreation = deltaUsage["cache_creation_input_tokens"];
+						if (typeof deltaUsage["input_tokens"] === "number") this._usage.inputOther = deltaUsage["input_tokens"];
+					}
+					const messageDeltaPayload = evt.delta;
+					if (messageDeltaPayload !== void 0 && "stop_reason" in messageDeltaPayload) this._captureStopReason(messageDeltaPayload["stop_reason"]);
+				}
+			}
+		} catch (error) {
+			throw convertAnthropicError(error);
+		}
+	}
+};
+var AnthropicChatProvider = class {
+	name = "anthropic";
+	_model;
+	_stream;
+	_client;
+	_generationKwargs;
+	_metadata;
+	_apiKey;
+	_baseUrl;
+	_defaultHeaders;
+	_clientFactory;
+	constructor(options) {
+		this._model = options.model;
+		this._stream = options.stream ?? true;
+		this._metadata = options.metadata;
+		const apiKey = options.apiKey ?? process.env["ANTHROPIC_API_KEY"];
+		this._apiKey = apiKey === void 0 || apiKey.length === 0 ? void 0 : apiKey;
+		this._baseUrl = options.baseUrl;
+		this._defaultHeaders = options.defaultHeaders;
+		this._clientFactory = options.clientFactory;
+		this._client = this._apiKey === void 0 ? void 0 : this._buildClient(this._apiKey);
+		this._generationKwargs = {
+			max_tokens: resolveDefaultMaxTokens(options.model, options.defaultMaxTokens),
+			betaFeatures: options.betaFeatures ?? [INTERLEAVED_THINKING_BETA]
+		};
+	}
+	get modelName() {
+		return this._model;
+	}
+	get thinkingEffort() {
+		const thinkingConfig = this._generationKwargs.thinking;
+		if (thinkingConfig === void 0 || thinkingConfig === null) return null;
+		if (thinkingConfig.type === "disabled") return "off";
+		if (thinkingConfig.type === "adaptive") {
+			const effort = this._generationKwargs.output_config?.effort;
+			if (effort === void 0 || effort === null) return "high";
+			switch (effort) {
+				case "low":
+				case "medium":
+				case "high":
+				case "xhigh":
+				case "max": return effort;
+			}
+		}
+		const budget = thinkingConfig.budget_tokens ?? 0;
+		if (budget <= 1024) return "low";
+		if (budget <= 4096) return "medium";
+		return "high";
+	}
+	get modelParameters() {
+		return {
+			model: this._model,
+			...this._generationKwargs
+		};
+	}
+	getCapability(model) {
+		return getAnthropicModelCapability(model ?? this._model);
+	}
+	async generate(systemPrompt, tools, history, options) {
+		const system = systemPrompt ? [{
+			type: "text",
+			text: systemPrompt,
+			cache_control: CACHE_CONTROL
+		}] : void 0;
+		const messages = [];
+		for (const msg of history) {
+			const converted = convertMessage(msg);
+			const last = messages.at(-1);
+			if (last !== void 0 && isToolResultOnly(last) && isToolResultOnly(converted)) last.content = [...last.content, ...converted.content];
+			else messages.push(converted);
+		}
+		injectCacheControlOnLastBlock(messages);
+		const kwargs = {};
+		if (this._generationKwargs.max_tokens !== void 0) kwargs["max_tokens"] = this._generationKwargs.max_tokens;
+		if (this._generationKwargs.temperature !== void 0) kwargs["temperature"] = this._generationKwargs.temperature;
+		if (this._generationKwargs.top_k !== void 0) kwargs["top_k"] = this._generationKwargs.top_k;
+		if (this._generationKwargs.top_p !== void 0) kwargs["top_p"] = this._generationKwargs.top_p;
+		if (this._generationKwargs.thinking !== void 0) kwargs["thinking"] = this._generationKwargs.thinking;
+		if (this._generationKwargs.output_config !== void 0) kwargs["output_config"] = this._generationKwargs.output_config;
+		const betas = this._generationKwargs.betaFeatures ?? [];
+		const extraHeaders = {};
+		if (betas.length > 0) extraHeaders["anthropic-beta"] = betas.join(",");
+		const anthropicTools = tools.map((t) => convertTool(t));
+		if (anthropicTools.length > 0) {
+			const lastTool = anthropicTools.at(-1);
+			if (lastTool !== void 0) lastTool.cache_control = CACHE_CONTROL;
+		}
+		const createParams = {
+			model: this._model,
+			messages,
+			...kwargs
+		};
+		if (system !== void 0) createParams["system"] = system;
+		if (anthropicTools.length > 0) createParams["tools"] = anthropicTools;
+		if (this._metadata !== void 0) createParams["metadata"] = this._metadata;
+		const requestOptions = {};
+		const headers = mergeRequestHeaders(extraHeaders, options?.auth?.headers);
+		if (headers !== void 0) requestOptions["headers"] = headers;
+		if (options?.signal) requestOptions["signal"] = options.signal;
+		const finalRequestOptions = Object.keys(requestOptions).length > 0 ? requestOptions : void 0;
+		const client = this._createClient(options?.auth);
+		if (this._stream) try {
+			return new AnthropicStreamedMessage(await client.messages.create({
+				...createParams,
+				stream: true
+			}, finalRequestOptions), true);
+		} catch (error) {
+			throw convertAnthropicError(error);
+		}
+		try {
+			return new AnthropicStreamedMessage(await client.messages.create({
+				...createParams,
+				stream: false
+			}, finalRequestOptions), false);
+		} catch (error) {
+			throw convertAnthropicError(error);
+		}
+	}
+	_createClient(auth) {
+		return resolveAuthBackedClient({
+			cachedClient: this._client,
+			clientFactory: this._clientFactory
+		}, auth, (a) => this._buildClient(requireProviderApiKey("AnthropicChatProvider", a, this._apiKey)));
+	}
+	_buildClient(apiKey) {
+		return new Anthropic({
+			apiKey,
+			baseURL: this._baseUrl,
+			defaultHeaders: this._defaultHeaders
+		});
+	}
+	withThinking(effort) {
+		if (effort === "off") {
+			let newBetas = [...this._generationKwargs.betaFeatures ?? []];
+			if (supportsAdaptiveThinking(this._model)) newBetas = newBetas.filter((b) => b !== INTERLEAVED_THINKING_BETA);
+			const clone = this._withGenerationKwargs({
+				thinking: { type: "disabled" },
+				betaFeatures: newBetas
+			});
+			delete clone._generationKwargs.output_config;
+			return clone;
+		}
+		const effectiveEffort = clampEffort(effort, this._model);
+		if (effectiveEffort === "off") throw new Error("Non-off thinking effort unexpectedly clamped to off.");
+		let newBetas = [...this._generationKwargs.betaFeatures ?? []];
+		if (supportsAdaptiveThinking(this._model)) {
+			newBetas = newBetas.filter((b) => b !== INTERLEAVED_THINKING_BETA);
+			return this._withGenerationKwargs({
+				thinking: {
+					type: "adaptive",
+					display: "summarized"
+				},
+				output_config: { effort: effectiveEffort },
+				betaFeatures: newBetas
+			});
+		}
+		const kwargs = {
+			thinking: {
+				type: "enabled",
+				budget_tokens: budgetTokensForEffort(effectiveEffort)
+			},
+			betaFeatures: newBetas
+		};
+		if (supportsEffortParam(this._model)) kwargs.output_config = { effort: effectiveEffort };
+		else kwargs.output_config = void 0;
+		const clone = this._withGenerationKwargs(kwargs);
+		if (!supportsEffortParam(this._model)) delete clone._generationKwargs.output_config;
+		return clone;
+	}
+	withGenerationKwargs(kwargs) {
+		return this._withGenerationKwargs(kwargs);
+	}
+	_withGenerationKwargs(kwargs) {
+		const clone = this._clone();
+		clone._generationKwargs = {
+			...clone._generationKwargs,
+			...kwargs
+		};
+		return clone;
+	}
+	_clone() {
+		const clone = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+		clone._generationKwargs = { ...this._generationKwargs };
+		return clone;
+	}
+};
+//#endregion
+export { AnthropicChatProvider, convertAnthropicError, resolveDefaultMaxTokens };