@effect-uai/anthropic 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -1,649 +1,5 @@
-import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { Array, Context, Effect, Layer, Match, Option, Order, Redacted, Result, Schema, Stream, pipe } from "effect";
-import { HttpClient, HttpClientRequest } from "effect/unstable/http";
-import * as AiError from "@effect-uai/core/AiError";
-import { LanguageModel } from "@effect-uai/core/LanguageModel";
-import { matchType } from "@effect-uai/core/Match";
-import * as SSE from "@effect-uai/core/SSE";
-import { JsonParseError } from "@effect-uai/core/JSONL";
-//#region src/codec.ts
-var codec_exports = /* @__PURE__ */ __exportAll({
-	WireContentBlock: () => WireContentBlock,
-	accumulatorToTurn: () => accumulatorToTurn,
-	appendInputJsonDelta: () => appendInputJsonDelta,
-	appendSignatureDelta: () => appendSignatureDelta,
-	appendTextDelta: () => appendTextDelta,
-	appendThinkingDelta: () => appendThinkingDelta,
-	buildRequestBody: () => buildRequestBody,
-	emptyAccumulator: () => emptyAccumulator,
-	mergeUsage: () => mergeUsage,
-	setStopReason: () => setStopReason,
-	startBlock: () => startBlock
-});
-const WireTextBlock = Schema.Struct({
-	type: Schema.Literal("text"),
-	text: Schema.String
-});
-const WireToolUseBlock = Schema.Struct({
-	type: Schema.Literal("tool_use"),
-	id: Schema.String,
-	name: Schema.String,
-	input: Schema.Unknown
-});
-const WireThinkingBlock = Schema.Struct({
-	type: Schema.Literal("thinking"),
-	thinking: Schema.String,
-	signature: Schema.optional(Schema.String)
-});
-const WireRedactedThinkingBlock = Schema.Struct({
-	type: Schema.Literal("redacted_thinking"),
-	data: Schema.String
-});
-const WireContentBlock = Schema.Union([
-	WireTextBlock,
-	WireToolUseBlock,
-	WireThinkingBlock,
-	WireRedactedThinkingBlock
-]);
-Schema.Struct({
-	input_tokens: Schema.optional(Schema.Number),
-	output_tokens: Schema.optional(Schema.Number),
-	cache_creation_input_tokens: Schema.optional(Schema.NullOr(Schema.Number)),
-	cache_read_input_tokens: Schema.optional(Schema.NullOr(Schema.Number))
-});
-const blockText = Match.type().pipe(matchType("input_text", (b) => b.text), matchType("input_image", () => ""), matchType("output_text", (b) => b.text), matchType("refusal", (b) => b.text), Match.exhaustive);
-const messageText = (message) => message.content.map(blockText).join("");
-const userContentBlock = (block) => Match.value(block).pipe(matchType("input_text", (b) => b.text.length === 0 ? Result.failVoid : Result.succeed({
-	type: "text",
-	text: b.text
-})), matchType("input_image", (b) => Result.succeed({
-	type: "image",
-	source: b.source._tag === "url" ? {
-		type: "url",
-		url: b.source.url
-	} : {
-		type: "base64",
-		media_type: b.source.media_type,
-		data: b.source.data
-	}
-})), matchType("output_text", () => Result.failVoid), matchType("refusal", () => Result.failVoid), Match.exhaustive);
-const parseJson = (s) => Result.try({
-	try: () => JSON.parse(s),
-	catch: (cause) => new JsonParseError({
-		line: s,
-		cause
-	})
-});
-const roleBucket = (item) => Match.value(item).pipe(matchType("message", (m) => m.role), matchType("function_call", () => "assistant"), matchType("function_call_output", () => "user"), matchType("reasoning", () => "assistant"), Match.exhaustive);
-const itemToUserBlocks = (item) => Match.value(item).pipe(matchType("message", (m) => m.role === "user" ? pipe(m.content, Array.filterMap(userContentBlock)) : []), matchType("function_call", () => []), matchType("function_call_output", (o) => [{
-	type: "tool_result",
-	tool_use_id: o.call_id,
-	content: o.output
-}]), matchType("reasoning", () => []), Match.exhaustive);
-const itemToAssistantBlocks = (item) => Match.value(item).pipe(matchType("message", (m) => {
-	const text = messageText(m);
-	return Result.succeed(m.role === "assistant" && text.length > 0 ? [{
-		type: "text",
-		text
-	}] : []);
-}), matchType("function_call", (f) => pipe(parseJson(f.arguments), Result.map((input) => [{
-	type: "tool_use",
-	id: f.call_id,
-	name: f.name,
-	input
-}]))), matchType("function_call_output", () => Result.succeed([])), matchType("reasoning", (r) => {
-	const blocks = r.summary !== void 0 ? [{
-		type: "thinking",
-		thinking: r.summary,
-		...r.signature !== void 0 && { signature: r.signature }
-	}] : r.signature !== void 0 ? [{
-		type: "redacted_thinking",
-		data: r.signature
-	}] : [];
-	return Result.succeed(blocks);
-}), Match.exhaustive);
-const flushAcc = (acc) => Option.match(acc.currentRole, {
-	onNone: () => acc.messages,
-	onSome: (role) => role === "user" && acc.userBuf.length > 0 ? [...acc.messages, {
-		role: "user",
-		content: acc.userBuf
-	}] : role === "assistant" && acc.assistantBuf.length > 0 ? [...acc.messages, {
-		role: "assistant",
-		content: acc.assistantBuf
-	}] : acc.messages
-});
-const appendUser = (acc, blocks) => blocks.length === 0 ? acc : Option.isSome(acc.currentRole) && acc.currentRole.value === "user" ? {
-	...acc,
-	userBuf: [...acc.userBuf, ...blocks]
-} : {
-	messages: flushAcc(acc),
-	currentRole: Option.some("user"),
-	userBuf: blocks,
-	assistantBuf: []
-};
-const appendAssistant = (acc, blocks) => blocks.length === 0 ? acc : Option.isSome(acc.currentRole) && acc.currentRole.value === "assistant" ? {
-	...acc,
-	assistantBuf: [...acc.assistantBuf, ...blocks]
-} : {
-	messages: flushAcc(acc),
-	currentRole: Option.some("assistant"),
-	userBuf: [],
-	assistantBuf: blocks
-};
-const groupStep = (acc, item) => {
-	const bucket = roleBucket(item);
-	if (bucket === "system") return Result.succeed(acc);
-	if (bucket === "user") return Result.succeed(appendUser(acc, itemToUserBlocks(item)));
-	return pipe(itemToAssistantBlocks(item), Result.map((blocks) => appendAssistant(acc, blocks)));
-};
-/**
-* Group consecutive same-role items into Anthropic-shaped messages.
-* Anthropic requires strict user/assistant alternation; consecutive items
-* from the same role are folded into one message's `content`. Fails if any
-* `function_call.arguments` is not valid JSON, since Anthropic's wire shape
-* requires an object input.
-*/
-const groupedMessages = (history) => {
-	const initial = Result.succeed({
-		messages: [],
-		currentRole: Option.none(),
-		userBuf: [],
-		assistantBuf: []
-	});
-	return pipe(Array.reduce(history, initial, (acc, item) => Result.flatMap(acc, (a) => groupStep(a, item))), Result.map(flushAcc));
-};
-const isSystemMessage = (item) => item.type === "message" && item.role === "system";
-const systemFromHistory = (history) => {
-	const texts = pipe(history, Array.filterMap((item) => isSystemMessage(item) ? Result.succeed(messageText(item)) : Result.failVoid), Array.filter((s) => s.length > 0));
-	return texts.length === 0 ? Option.none() : Option.some(texts.join("\n"));
-};
-const buildRequestBody = (params) => pipe(groupedMessages(params.history), Result.map((messages) => ({
-	model: params.model,
-	messages,
-	max_tokens: params.maxTokens,
-	...Option.match(systemFromHistory(params.history), {
-		onNone: () => ({}),
-		onSome: (system) => ({ system })
-	}),
-	...Option.match(params.temperature, {
-		onNone: () => ({}),
-		onSome: (temperature) => ({ temperature })
-	}),
-	...Option.match(params.topP, {
-		onNone: () => ({}),
-		onSome: (top_p) => ({ top_p })
-	}),
-	...Option.match(params.topK, {
-		onNone: () => ({}),
-		onSome: (top_k) => ({ top_k })
-	}),
-	...Option.match(params.stopSequences, {
-		onNone: () => ({}),
-		onSome: (stop_sequences) => ({ stop_sequences })
-	}),
-	...Option.match(params.thinking, {
-		onNone: () => ({}),
-		onSome: (thinking) => ({ thinking })
-	}),
-	...Option.match(params.tools, {
-		onNone: () => ({}),
-		onSome: (tools) => ({ tools })
-	}),
-	...Option.match(params.toolChoice, {
-		onNone: () => ({}),
-		onSome: (tool_choice) => ({ tool_choice })
-	}),
-	...Option.match(params.userId, {
-		onNone: () => ({}),
-		onSome: (user_id) => ({ metadata: { user_id } })
-	}),
-	...Option.match(params.outputConfig, {
-		onNone: () => ({}),
-		onSome: (output_config) => ({ output_config })
-	}),
-	stream: true
-})));
-const emptyBlock = (type) => ({
-	type,
-	text: "",
-	inputJson: "",
-	thinking: "",
-	signature: "",
-	id: Option.none(),
-	name: Option.none(),
-	redactedData: Option.none()
-});
-const emptyAccumulator = {
-	blocks: {},
-	stopReason: Option.none(),
-	usage: {}
-};
-const replaceBlock = (acc, index, block) => ({
-	...acc,
-	blocks: {
-		...acc.blocks,
-		[index]: block
-	}
-});
-const updateBlock = (acc, index, patch) => replaceBlock(acc, index, patch(acc.blocks[index] ?? emptyBlock("text")));
-const startBlock = (acc, index, block) => Match.value(block).pipe(matchType("text", () => replaceBlock(acc, index, emptyBlock("text"))), matchType("tool_use", (b) => replaceBlock(acc, index, {
-	...emptyBlock("tool_use"),
-	id: Option.some(b.id),
-	name: Option.some(b.name),
-	inputJson: typeof b.input === "string" ? b.input : ""
-})), matchType("thinking", () => replaceBlock(acc, index, emptyBlock("thinking"))), matchType("redacted_thinking", (b) => replaceBlock(acc, index, {
-	...emptyBlock("redacted_thinking"),
-	redactedData: Option.some(b.data)
-})), Match.exhaustive);
-const appendTextDelta = (acc, index, text) => updateBlock(acc, index, (b) => ({
-	...b,
-	text: b.text + text
-}));
-const appendInputJsonDelta = (acc, index, partial) => updateBlock(acc, index, (b) => ({
-	...b,
-	inputJson: b.inputJson + partial
-}));
-const appendThinkingDelta = (acc, index, thinking) => updateBlock(acc, index, (b) => ({
-	...b,
-	thinking: b.thinking + thinking
-}));
-const appendSignatureDelta = (acc, index, signature) => updateBlock(acc, index, (b) => ({
-	...b,
-	signature: b.signature + signature
-}));
-const setStopReason = (acc, reason) => ({
-	...acc,
-	stopReason: Option.some(reason)
-});
-const cachedFromWire = (wire) => Option.fromNullishOr(wire.cache_read_input_tokens);
-const mergeUsage = (acc, wire) => {
-	const cached = cachedFromWire(wire);
-	const usage = {
-		...acc.usage,
-		...wire.input_tokens !== void 0 && { input_tokens: wire.input_tokens },
-		...wire.output_tokens !== void 0 && { output_tokens: wire.output_tokens },
-		...wire.input_tokens !== void 0 && wire.output_tokens !== void 0 && { total_tokens: wire.input_tokens + wire.output_tokens },
-		...Option.match(cached, {
-			onNone: () => ({}),
-			onSome: (cached_tokens) => ({ input_tokens_details: { cached_tokens } })
-		})
-	};
-	return {
-		...acc,
-		usage
-	};
-};
-const stopReasonFromAnthropic = (reason) => Option.match(reason, {
-	onNone: () => "stop",
-	onSome: (r) => Match.value(r).pipe(Match.when("tool_use", () => "tool_calls"), Match.when("max_tokens", () => "max_tokens"), Match.orElse(() => "stop"))
-});
-const blocksByIndex = (acc) => pipe(Object.keys(acc.blocks), Array.map((k) => Number(k)), Array.sort(Order.Number), Array.map((i) => acc.blocks[i]));
-const blockToItems = (block) => Match.value(block.type).pipe(Match.when("text", () => block.text.length === 0 ? [] : [{
-	type: "message",
-	role: "assistant",
-	content: [{
-		type: "output_text",
-		text: block.text
-	}]
-}]), Match.when("tool_use", () => [{
-	type: "function_call",
-	call_id: Option.getOrElse(block.id, () => ""),
-	name: Option.getOrElse(block.name, () => ""),
-	arguments: block.inputJson
-}]), Match.when("thinking", () => [{
-	type: "reasoning",
-	...block.thinking.length > 0 && { summary: block.thinking },
-	...block.signature.length > 0 && { signature: block.signature }
-}]), Match.when("redacted_thinking", () => [{
-	type: "reasoning",
-	...Option.match(block.redactedData, {
-		onNone: () => ({}),
-		onSome: (signature) => ({ signature })
-	})
-}]), Match.exhaustive);
-const mergeStep = (acc, item) => {
-	const last = Array.last(acc.out);
-	if (Option.isSome(last) && last.value.type === "message" && last.value.role === "assistant" && item.type === "message" && item.role === "assistant") {
-		const merged = {
-			...last.value,
-			content: [...last.value.content, ...item.content]
-		};
-		return { out: [...acc.out.slice(0, -1), merged] };
-	}
-	return { out: [...acc.out, item] };
-};
-const mergeAdjacentAssistantText = (items) => Array.reduce(items, { out: [] }, mergeStep).out;
-const accumulatorToTurn = (acc) => ({
-	items: pipe(blocksByIndex(acc), Array.flatMap(blockToItems), mergeAdjacentAssistantText),
-	usage: acc.usage,
-	stop_reason: stopReasonFromAnthropic(acc.stopReason)
-});
-//#endregion
-//#region src/streamEvents.ts
-var streamEvents_exports = /* @__PURE__ */ __exportAll({
-	KnownProviderEvent: () => KnownProviderEvent,
-	ProviderEvent: () => ProviderEvent,
-	applyEvent: () => applyEvent,
-	isErrorEvent: () => isErrorEvent,
-	isInputJsonDeltaEvent: () => isInputJsonDeltaEvent,
-	isMessageStop: () => isMessageStop,
-	isTextDeltaEvent: () => isTextDeltaEvent,
-	isThinkingDeltaEvent: () => isThinkingDeltaEvent,
-	isToolUseStartEvent: () => isToolUseStartEvent
-});
-const WireMessageStartUsage = Schema.Struct({
-	input_tokens: Schema.optional(Schema.Number),
-	output_tokens: Schema.optional(Schema.Number),
-	cache_creation_input_tokens: Schema.optional(Schema.NullOr(Schema.Number)),
-	cache_read_input_tokens: Schema.optional(Schema.NullOr(Schema.Number))
-});
-const MessageStart = Schema.Struct({
-	type: Schema.Literal("message_start"),
-	message: Schema.Struct({
-		id: Schema.optional(Schema.String),
-		usage: Schema.optional(WireMessageStartUsage)
-	})
-});
-const ContentBlockStart = Schema.Struct({
-	type: Schema.Literal("content_block_start"),
-	index: Schema.Number,
-	content_block: WireContentBlock
-});
-const TextDelta = Schema.Struct({
-	type: Schema.Literal("text_delta"),
-	text: Schema.String
-});
-const InputJsonDelta = Schema.Struct({
-	type: Schema.Literal("input_json_delta"),
-	partial_json: Schema.String
-});
-const ThinkingDelta = Schema.Struct({
-	type: Schema.Literal("thinking_delta"),
-	thinking: Schema.String
-});
-const SignatureDelta = Schema.Struct({
-	type: Schema.Literal("signature_delta"),
-	signature: Schema.String
-});
-const Delta = Schema.Union([
-	TextDelta,
-	InputJsonDelta,
-	ThinkingDelta,
-	SignatureDelta
-]);
-const ContentBlockDelta = Schema.Struct({
-	type: Schema.Literal("content_block_delta"),
-	index: Schema.Number,
-	delta: Delta
-});
-const ContentBlockStop = Schema.Struct({
-	type: Schema.Literal("content_block_stop"),
-	index: Schema.Number
-});
-const MessageDelta = Schema.Struct({
-	type: Schema.Literal("message_delta"),
-	delta: Schema.Struct({
-		stop_reason: Schema.optional(Schema.NullOr(Schema.String)),
-		stop_sequence: Schema.optional(Schema.NullOr(Schema.String))
-	}),
-	usage: Schema.optional(WireMessageStartUsage)
-});
-const MessageStop = Schema.Struct({ type: Schema.Literal("message_stop") });
-const Ping = Schema.Struct({ type: Schema.Literal("ping") });
-const ErrorEvent = Schema.Struct({
-	type: Schema.Literal("error"),
-	error: Schema.optional(Schema.Struct({
-		type: Schema.optional(Schema.String),
-		message: Schema.optional(Schema.String)
-	}))
-});
-/**
-* Catch-all variant for wire events that fail to decode against any known
-* schema, plus events that fail to JSON-parse. The decoder never produces
-* this directly - it's synthesized by `sseEventToProviderEvent` when
-* `decodeKnown` fails.
-*/
-const Unknown = Schema.Struct({
-	type: Schema.Literal("_unknown"),
-	raw: Schema.Unknown
-});
-/**
-* Internal: union of variants we actually know how to decode from the wire.
-* Used as the decode target; failures are caught and re-emitted as `Unknown`.
-*/
-const KnownProviderEvent = Schema.Union([
-	MessageStart,
-	ContentBlockStart,
-	ContentBlockDelta,
-	ContentBlockStop,
-	MessageDelta,
-	MessageStop,
-	Ping,
-	ErrorEvent
-]);
-/**
-* Public: every event the native stream can emit. Discriminated on `type`.
-* The `_unknown` branch closes the cardinality so downstream `Match.exhaustive`
-* cannot silently miss a wire event we didn't model.
-*/
-const ProviderEvent = Schema.Union([
-	MessageStart,
-	ContentBlockStart,
-	ContentBlockDelta,
-	ContentBlockStop,
-	MessageDelta,
-	MessageStop,
-	Ping,
-	ErrorEvent,
-	Unknown
-]);
-const mergeOptionalUsage = (acc, wire) => wire === void 0 ? acc : mergeUsage(acc, wire);
-const applyEvent = (acc, event) => Match.value(event).pipe(matchType("message_start", (e) => mergeOptionalUsage(acc, e.message.usage)), matchType("content_block_start", (e) => startBlock(acc, e.index, e.content_block)), matchType("content_block_delta", (e) => Match.value(e.delta).pipe(matchType("text_delta", (d) => appendTextDelta(acc, e.index, d.text)), matchType("input_json_delta", (d) => appendInputJsonDelta(acc, e.index, d.partial_json)), matchType("thinking_delta", (d) => appendThinkingDelta(acc, e.index, d.thinking)), matchType("signature_delta", (d) => appendSignatureDelta(acc, e.index, d.signature)), Match.exhaustive)), matchType("content_block_stop", () => acc), matchType("message_delta", (e) => {
-	const withUsage = mergeOptionalUsage(acc, e.usage);
-	const reason = e.delta.stop_reason;
-	return reason === void 0 || reason === null ? withUsage : setStopReason(withUsage, reason);
-}), matchType("message_stop", () => acc), matchType("ping", () => acc), matchType("error", () => acc), matchType("_unknown", () => acc), Match.exhaustive);
-const isTextDeltaEvent = (event) => event.type === "content_block_delta" && event.delta.type === "text_delta";
-const isThinkingDeltaEvent = (event) => event.type === "content_block_delta" && event.delta.type === "thinking_delta";
-const isInputJsonDeltaEvent = (event) => event.type === "content_block_delta" && event.delta.type === "input_json_delta";
-const isToolUseStartEvent = (event) => event.type === "content_block_start" && event.content_block.type === "tool_use";
-const isMessageStop = (event) => event.type === "message_stop";
-const isErrorEvent = (event) => event.type === "error";
-//#endregion
-//#region src/Anthropic.ts
-/**
-* Provider-typed service tag. Yield this when you want Anthropic-specific
-* options (`topK`, `stopSequences`, `thinking`); yield the generic
-* `LanguageModel` tag for provider-portable code. Both are registered by
-* `layer`.
-*/
-var Anthropic = class extends Context.Service()("@betalyra/effect-uai/providers/anthropic/Anthropic") {};
-const ANTHROPIC_VERSION = "2023-06-01";
-const STRUCTURED_OUTPUTS_BETA = "structured-outputs-2025-11-13";
-const FALLBACK_MAX_TOKENS = 4096;
-const outputConfig = (request) => pipe(Option.fromUndefinedOr(request.structured), Option.map((format) => ({ format: {
-	type: "json_schema",
-	schema: format.schema["~standard"].jsonSchema.input({ target: "draft-2020-12" })
-} })));
-const resolvedMaxTokens = (cfg, request) => request.maxOutputTokens ?? cfg.defaultMaxTokens ?? FALLBACK_MAX_TOKENS;
-const toolDescriptors = (request) => request.tools !== void 0 && request.tools.length > 0 ? Option.some(request.tools.map((t) => ({
-	name: t.name,
-	description: t.description,
-	input_schema: t.inputSchema
-}))) : Option.none();
-const toolChoiceWire = (request) => pipe(Option.fromUndefinedOr(request.toolChoice), Option.map((choice) => choice === "auto" ? { type: "auto" } : choice === "required" ? { type: "any" } : choice === "none" ? { type: "none" } : {
-	type: "tool",
-	name: choice.name
-}));
-const decodeKnown = Schema.decodeUnknownEffect(KnownProviderEvent);
-const makeUnknown = (raw) => ({
-	type: "_unknown",
-	raw
-});
-/**
-* Parse one SSE event's `data` payload into a typed `ProviderEvent`. Never
-* fails: JSON-parse and schema-decode failures both produce a synthesized
-* `_unknown` event so consumers of `streamNative` never silently miss a
-* wire event we didn't model.
-*/
-const sseEventToProviderEvent = (ev) => Effect.try({
-	try: () => JSON.parse(ev.data),
-	catch: () => ev.data
-}).pipe(Effect.flatMap((parsed) => decodeKnown(parsed).pipe(Effect.orElseSucceed(() => makeUnknown(parsed)))), Effect.orElseSucceed(() => makeUnknown(ev.data)));
-const deltasFromEvent = (next, event) => Match.value(event).pipe(matchType("content_block_start", (e) => e.content_block.type === "tool_use" ? [{
-	type: "tool_call_start",
-	call_id: e.content_block.id,
-	name: e.content_block.name
-}] : []), matchType("content_block_delta", (e) => Match.value(e.delta).pipe(matchType("text_delta", (d) => [{
-	type: "text_delta",
-	text: d.text
-}]), matchType("thinking_delta", (d) => [{
-	type: "reasoning_delta",
-	text: d.thinking,
-	kind: "trace"
-}]), matchType("input_json_delta", (d) => {
-	const block = next.blocks[e.index];
-	if (block === void 0) return [];
-	const callId = Option.getOrElse(block.id, () => "");
-	return callId.length === 0 ? [] : [{
-		type: "tool_call_args_delta",
-		call_id: callId,
-		delta: d.partial_json
-	}];
-}), matchType("signature_delta", () => []), Match.exhaustive)), matchType("message_start", (e) => e.message.usage === void 0 ? [] : [{
-	type: "usage_update",
-	usage: next.usage
-}]), matchType("message_delta", (e) => e.usage === void 0 ? [] : [{
-	type: "usage_update",
-	usage: next.usage
-}]), matchType("message_stop", () => [{
-	type: "turn_complete",
-	turn: accumulatorToTurn(next)
-}]), matchType("content_block_stop", () => []), matchType("ping", () => []), matchType("error", () => []), matchType("_unknown", () => []), Match.exhaustive);
-const httpStatusError = (status, body) => {
-	const provider = "anthropic";
-	const raw = body;
-	if (status === 429) return new AiError.RateLimited({
-		provider,
-		raw
-	});
-	if (status === 408 || status === 504) return new AiError.Timeout({
-		provider,
-		raw
-	});
-	if (status === 401) return new AiError.AuthFailed({
-		provider,
-		subtype: "auth",
-		raw
-	});
-	if (status === 403) return new AiError.AuthFailed({
-		provider,
-		subtype: "permission",
-		raw
-	});
-	if (status === 402) return new AiError.AuthFailed({
-		provider,
-		subtype: "billing",
-		raw
-	});
-	if (status === 413) return new AiError.ContextLengthExceeded({
-		provider,
-		raw
-	});
-	if (status === 529) return new AiError.Unavailable({
-		provider,
-		status,
-		raw
-	});
-	if (status >= 500) return new AiError.Unavailable({
-		provider,
-		status,
-		raw
-	});
-	return new AiError.InvalidRequest({
-		provider,
-		raw
-	});
-};
-const buildNativeStream = (cfg) => {
-	const url = `${cfg.baseUrl ?? "https://api.anthropic.com"}/v1/messages`;
-	return (request) => Stream.unwrap(Effect.gen(function* () {
-		const structured = outputConfig(request);
-		const bodyResult = buildRequestBody({
-			model: request.model,
-			history: request.history,
-			maxTokens: resolvedMaxTokens(cfg, request),
-			temperature: Option.fromUndefinedOr(request.temperature),
-			topP: Option.fromUndefinedOr(request.topP),
-			topK: Option.fromUndefinedOr(request.topK),
-			stopSequences: Option.fromUndefinedOr(request.stopSequences),
-			thinking: Option.fromUndefinedOr(request.thinking),
-			tools: toolDescriptors(request),
-			toolChoice: toolChoiceWire(request),
-			userId: Option.fromUndefinedOr(request.user),
-			outputConfig: structured
-		});
-		const body = yield* Result.match(bodyResult, {
-			onFailure: (cause) => Effect.fail(new AiError.InvalidRequest({
-				provider: "anthropic",
-				param: "input.function_call.arguments",
-				raw: cause
-			})),
-			onSuccess: (b) => Effect.succeed(b)
-		});
-		const client = yield* HttpClient.HttpClient;
-		const baseRequest = HttpClientRequest.post(url).pipe(HttpClientRequest.setHeader("x-api-key", Redacted.value(cfg.apiKey)), HttpClientRequest.setHeader("anthropic-version", ANTHROPIC_VERSION), HttpClientRequest.bodyJsonUnsafe(body), HttpClientRequest.accept("text/event-stream"));
-		const httpRequest = Option.isSome(structured) ? baseRequest.pipe(HttpClientRequest.setHeader("anthropic-beta", STRUCTURED_OUTPUTS_BETA)) : baseRequest;
-		const response = yield* client.execute(httpRequest).pipe(Effect.mapError((cause) => new AiError.Unavailable({
-			provider: "anthropic",
-			raw: cause
-		})));
-		if (response.status >= 400) {
-			const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""));
-			return Stream.fail(httpStatusError(response.status, text));
-		}
-		return response.stream.pipe(Stream.mapError((cause) => new AiError.Unavailable({
-			provider: "anthropic",
-			raw: cause
-		})), SSE.fromBytes, Stream.mapEffect(sseEventToProviderEvent), Stream.flatMap((event) => event.type === "error" ? Stream.fail(new AiError.Unavailable({
-			provider: "anthropic",
-			raw: event
-		})) : Stream.succeed(event)));
-	}));
-};
-/**
-* Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.
-* Threads a fresh `Accumulator` per stream so tool-call lookup and
-* `accumulatorToTurn` assembly work correctly across the run.
-*/
-const toCanonical = (s) => s.pipe(Stream.mapAccum(() => emptyAccumulator, (acc, event) => {
-	const next = applyEvent(acc, event);
-	return [next, deltasFromEvent(next, event)];
-}));
-/**
-* Build an `AnthropicService` value. For Layer-based setup, prefer `layer`.
-*/
-const make = (cfg) => Effect.map(HttpClient.HttpClient.asEffect(), (client) => {
-	const streamNative = (request) => buildNativeStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client));
-	return {
-		streamNative,
-		streamTurn: (request) => toCanonical(streamNative(request)),
-		toCanonical
-	};
-});
-/**
-* Layer that registers both the provider-specific `Anthropic` tag and the
-* generic `LanguageModel` tag, sharing one underlying implementation.
-*
-* The generic tag accepts `CommonRequest`; the typed tag accepts the full
-* `AnthropicRequest` surface.
-*/
-const layer = (cfg) => {
-	const typed = Layer.effect(Anthropic, make(cfg));
-	const generic = Layer.effect(LanguageModel, Effect.map(make(cfg), (s) => ({ streamTurn: (request) => s.streamTurn(request) })));
-	return Layer.merge(typed, generic);
-};
-//#endregion
-export { Anthropic, codec_exports as codec, layer, make, streamEvents_exports as streamEvents, toCanonical };
-
-//# sourceMappingURL=index.mjs.map
+import { t as codec_exports } from "./codec.mjs";
+import { t as streamEvents_exports } from "./streamEvents.mjs";
+import { t as Anthropic_exports } from "./Anthropic.mjs";
+import "./models.mjs";
+export { Anthropic_exports as Anthropic, codec_exports as codec, streamEvents_exports as streamEvents };

package/dist/models.d.mts

@@ -0,0 +1,25 @@
+//#region src/models.d.ts
+/**
+ * Known Anthropic model identifiers usable via the Messages API (as of
+ * April 2026). The `(string & {})` tail keeps autocomplete on the literals
+ * while still accepting any string, so newly-released models work without
+ * an SDK update.
+ *
+ * Reference: https://platform.claude.com/docs/en/docs/about-claude/models
+ *
+ * Latest tier:
+ * - `claude-opus-4-7` - most capable; agentic coding focus. Adaptive
+ *   thinking only (no extended thinking).
+ * - `claude-sonnet-4-6` - speed + intelligence balance. Extended +
+ *   adaptive thinking.
+ * - `claude-haiku-4-5-20251001` (alias `claude-haiku-4-5`) - fastest;
+ *   extended thinking.
+ *
+ * Deprecated and retiring 2026-06-15:
+ * `claude-sonnet-4-20250514` (`claude-sonnet-4-0`),
+ * `claude-opus-4-20250514` (`claude-opus-4-0`).
+ */
+type AnthropicModel = "claude-opus-4-7" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-6" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-opus-4-1" | "claude-opus-4-1-20250805" | (string & {});
+//#endregion
+export { AnthropicModel };
+//# sourceMappingURL=models.d.mts.map

package/dist/models.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;AAoBA;;;;;;;;;;;;;;;;;;;KAAY,cAAA"}

package/dist/models.mjs

@@ -0,0 +1 @@
+export {};