@24klynx/llm 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1357 @@
+import { LlmAuthError, LlmContextOverflowError, LlmError, LlmRateLimitError } from "@lynx/core";
+//#region src/stream.ts
+/**
+* Stream\<T\> — pull‑based AsyncIterator backed by an internal queue.
+*
+* Producers call `enqueue()` / `done()` / `error()`.
+* Consumers use `for await … of`.
+*
+* This is deliberately a class (not EventEmitter) so the consumer
+* controls back‑pressure — when nobody is iterating, values stay in
+* the queue until `maxQueueSize` is reached.
+*/
+/** Drop the oldest item when the queue exceeds this size. */
+const DEFAULT_MAX_QUEUE = 256;
+/**
+* A cold, single‑consumer async iterator.
+*
+* ```ts
+* const stream = new Stream<string>();
+* producer(stream);
+* for await (const chunk of stream) {
+*   console.log(chunk);
+* }
+* ```
+*/
+var Stream = class {
+	_queue = [];
+	_resolvers = [];
+	_done = false;
+	_error = null;
+	_maxQueue;
+	constructor(maxQueueSize = DEFAULT_MAX_QUEUE) {
+		this._maxQueue = maxQueueSize;
+	}
+	/** Push a value into the stream. */
+	enqueue(value) {
+		if (this._done || this._error) return;
+		if (this._resolvers.length > 0) this._resolvers.shift()({
+			value,
+			done: false
+		});
+		else {
+			this._queue.push(value);
+			if (this._queue.length > this._maxQueue) this._queue.shift();
+		}
+	}
+	/** Signal that the stream has finished normally. */
+	done() {
+		if (this._done) return;
+		this._done = true;
+		for (const resolve of this._resolvers) resolve({
+			value: void 0,
+			done: true
+		});
+		this._resolvers = [];
+	}
+	/** Propagate an error to the consumer. */
+	error(err) {
+		if (this._done || this._error) return;
+		this._error = err;
+		this._done = true;
+		for (const resolve of this._resolvers) resolve({
+			value: void 0,
+			done: true
+		});
+		this._resolvers = [];
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	next() {
+		if (this._error) return Promise.reject(this._error);
+		if (this._done && this._queue.length === 0) return Promise.resolve({
+			value: void 0,
+			done: true
+		});
+		if (this._queue.length > 0) {
+			const value = this._queue.shift();
+			return Promise.resolve({
+				value,
+				done: false
+			});
+		}
+		return new Promise((resolve) => {
+			this._resolvers.push(resolve);
+		});
+	}
+};
+//#endregion
+//#region src/retry.ts
+/**
+* withRetry — exponential backoff with jitter and Retry‑After respect.
+*
+* Used by every LLM provider for transient errors (429, 529, ECONNRESET, etc.).
+*
+* Algorithm:
+*   delay = min(baseMs * 2^(attempt-1), maxMs)
+*   jitter = delay * uniform(0.75, 1.25)
+*   final  = min(jitter, maxMs)
+*/
+const BASE_DELAY_MS = 500;
+const MAX_DELAY_MS = 32e3;
+const MAX_RETRIES = 10;
+/** Uniform random in [lo, hi]. */
+function jitter(lo, hi) {
+	return lo + Math.random() * (hi - lo);
+}
+/** Extract Retry‑After seconds from HTTP headers if present. */
+function parseRetryAfter(err) {
+	const headers = err.headers;
+	if (!headers) return null;
+	const raw = headers["retry-after"];
+	if (!raw) return null;
+	const secs = Number.parseInt(raw, 10);
+	if (!Number.isNaN(secs)) return secs;
+	const parsed = Date.parse(raw);
+	if (!Number.isNaN(parsed)) return Math.max(0, Math.ceil((parsed - Date.now()) / 1e3));
+	return null;
+}
+/**
+* Execute `fn` with exponential backoff.
+*
+* Only retries on transient errors. Non‑retryable errors are re‑thrown
+* immediately.
+*
+* ```ts
+* const result = await withRetry(() => fetchFromApi(), {
+*   baseMs: 500,
+*   maxMs: 32_000,
+* });
+* ```
+*/
+async function withRetry(fn, opts = {}) {
+	const baseMs = opts.baseMs ?? BASE_DELAY_MS;
+	const maxMs = opts.maxMs ?? MAX_DELAY_MS;
+	const maxRetries = opts.maxRetries ?? MAX_RETRIES;
+	const isRetryable = opts.isRetryable ?? ((err) => {
+		if (err instanceof LlmRateLimitError) return true;
+		if (err instanceof LlmError && err.retryable) return true;
+		const code = err.code;
+		if (code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT") return true;
+		return false;
+	});
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err));
+		if (attempt === maxRetries || !isRetryable(error)) throw error;
+		if (error.status === 529 && opts.isForeground === false) throw error;
+		const retryAfter = parseRetryAfter(error);
+		const delay = retryAfter ? retryAfter * 1e3 : Math.min(baseMs * Math.pow(2, attempt), maxMs);
+		const jittered = Math.min(delay * jitter(.75, 1.25), maxMs);
+		await new Promise((resolve) => setTimeout(resolve, jittered));
+	}
+	throw new LlmError("withRetry exhausted all attempts", {
+		category: "llm",
+		recoverable: false,
+		retryable: false,
+		diagnosticHint: "llm_retry_exhausted"
+	});
+}
+//#endregion
+//#region src/capabilities.ts
+/**
+* Lookup table keyed by "provider/modelId".
+*
+* New models can be added here without code changes —
+* capabilities are pure data, not behaviour.
+*/
+const CAPABILITIES = {
+	"deepseek/deepseek-chat": {
+		contextWindow: 128e3,
+		maxOutput: 8192,
+		supportsReasoning: false,
+		supportsStreaming: true,
+		supportsToolUse: true,
+		supportsVision: false,
+		promptCacheEnabled: true
+	},
+	"deepseek/deepseek-reasoner": {
+		contextWindow: 128e3,
+		maxOutput: 8192,
+		supportsReasoning: true,
+		supportsStreaming: true,
+		supportsToolUse: false,
+		supportsVision: false,
+		promptCacheEnabled: true
+	},
+	"openai/gpt-4o": {
+		contextWindow: 128e3,
+		maxOutput: 16384,
+		supportsReasoning: false,
+		supportsStreaming: true,
+		supportsToolUse: true,
+		supportsVision: true,
+		promptCacheEnabled: false
+	},
+	"openai/gpt-4o-mini": {
+		contextWindow: 128e3,
+		maxOutput: 16384,
+		supportsReasoning: false,
+		supportsStreaming: true,
+		supportsToolUse: true,
+		supportsVision: true,
+		promptCacheEnabled: false
+	},
+	"openai/o3-mini": {
+		contextWindow: 2e5,
+		maxOutput: 1e5,
+		supportsReasoning: true,
+		supportsStreaming: true,
+		supportsToolUse: false,
+		supportsVision: false,
+		promptCacheEnabled: false
+	},
+	"anthropic/claude-opus-4-8": {
+		contextWindow: 2e5,
+		maxOutput: 32e3,
+		supportsReasoning: true,
+		supportsStreaming: true,
+		supportsToolUse: true,
+		supportsVision: true,
+		promptCacheEnabled: true
+	},
+	"anthropic/claude-sonnet-4-6": {
+		contextWindow: 2e5,
+		maxOutput: 16384,
+		supportsReasoning: true,
+		supportsStreaming: true,
+		supportsToolUse: true,
+		supportsVision: true,
+		promptCacheEnabled: true
+	},
+	"anthropic/claude-haiku-4-5": {
+		contextWindow: 2e5,
+		maxOutput: 8192,
+		supportsReasoning: false,
+		supportsStreaming: true,
+		supportsToolUse: true,
+		supportsVision: true,
+		promptCacheEnabled: true
+	}
+};
+/**
+* Return the capability blob for `provider/modelId`.
+* Returns `undefined` for unknown models — callers should fall back
+* or throw a {@link import('@lynx/core').ConfigError}.
+*/
+function getCapability(providerId, modelId) {
+	return CAPABILITIES[`${providerId}/${modelId}`];
+}
+/**
+* Return every known capability entry.
+* Used by the model picker UI in the TUI layer.
+*/
+function listCapabilities() {
+	return Object.entries(CAPABILITIES).map(([key, cap]) => ({
+		key,
+		...cap
+	}));
+}
+//#endregion
+//#region src/fallback.ts
+/**
+* Model/Provider fallback logic.
+*
+* When a provider returns a transient error (rate‑limit, overload) the
+* fallback engine tries the next candidate in the configured chain.
+* Permanent errors (auth) skip the provider entirely and move to the next.
+*
+* The primary use‑case is keeping the agent loop running when the
+* preferred model is temporarily unavailable.
+*/
+/** Error thrown when every candidate in the chain has been exhausted. */
+var FallbackExhaustedError = class extends Error {
+	attempts;
+	constructor(attempts) {
+		const summary = attempts.map((a) => `  ${a.provider}/${a.model}: ${a.error}`).join("\n");
+		super(`All fallback candidates exhausted:\n${summary}`);
+		this.name = "FallbackExhaustedError";
+		this.attempts = attempts;
+	}
+};
+/**
+* Determine whether an error is transient (worth retrying with a
+* different provider) or permanent (skip this provider).
+*/
+function isTransient(err) {
+	if (err instanceof LlmRateLimitError) return true;
+	if (err instanceof LlmAuthError) return false;
+	if (err instanceof Error && "code" in err) {
+		const code = err.code;
+		if (code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOTFOUND") return true;
+	}
+	return true;
+}
+/**
+* Run `fn` with automatic fallback across a chain of model candidates.
+*
+* `fn` is called with (provider, model) and should return a result.
+* If `fn` throws, the error is classified — transient errors move to the
+* next candidate, permanent errors skip the provider, and fatal errors
+* (like user abort) are re‑thrown immediately.
+*/
+async function runWithFallback(candidates, fn, opts) {
+	if (candidates.length === 0) throw new FallbackExhaustedError([]);
+	const attempts = [];
+	for (const candidate of candidates) {
+		if (opts?.signal?.aborted) throw new DOMException("Aborted", "AbortError");
+		try {
+			return {
+				result: await fn(candidate),
+				provider: candidate.provider,
+				model: candidate.model,
+				attempts
+			};
+		} catch (err) {
+			if (err instanceof DOMException && err.name === "AbortError") throw err;
+			const message = err instanceof Error ? err.message : String(err);
+			const status = err.status;
+			const code = err.code;
+			attempts.push({
+				provider: candidate.provider,
+				model: candidate.model,
+				error: message,
+				code,
+				status
+			});
+			if (!isTransient(err)) continue;
+			continue;
+		}
+	}
+	throw new FallbackExhaustedError(attempts);
+}
+/**
+* Build a fallback chain from a primary model and a list of fallback refs.
+*
+* Fallback refs use the format `"provider/model"` (e.g. `"openai/gpt-4o-mini"`).
+* If the provider prefix is omitted the primary's provider is used.
+*/
+function buildCandidateChain(primaryProvider, primaryModel, fallbackRefs) {
+	const chain = [{
+		provider: primaryProvider,
+		model: primaryModel
+	}];
+	for (const ref of fallbackRefs) {
+		const slashIdx = ref.indexOf("/");
+		if (slashIdx > 0) chain.push({
+			provider: ref.slice(0, slashIdx),
+			model: ref.slice(slashIdx + 1)
+		});
+		else chain.push({
+			provider: primaryProvider,
+			model: ref
+		});
+	}
+	return chain;
+}
+//#endregion
+//#region src/tool-format.ts
+/**
+* Convert Lynx tool descriptors to OpenAI-compatible format.
+*
+* Wraps each tool with `type: "function"` and maps `inputSchema` → `parameters`.
+* Tools already in OpenAI format pass through unchanged.
+*/
+function normalizeOpenAiTools(tools) {
+	return tools.map((tool) => {
+		const raw = tool;
+		if (typeof raw === "object" && raw !== null && raw.type === "function") return tool;
+		return {
+			type: "function",
+			function: {
+				name: String(raw.name ?? "unknown"),
+				description: String(raw.description ?? ""),
+				parameters: raw.inputSchema ?? {}
+			}
+		};
+	});
+}
+/**
+* Convert Lynx ChatMessage[] to OpenAI wire-format messages.
+*
+* Key transformations:
+* - `tool_result` content blocks → `role: "tool"` messages with string content
+* - `tool_use` blocks in assistant messages → `tool_calls` array
+* - `reasoning` blocks are stripped (not sent back to the API)
+*/
+function normalizeOpenAiMessages(messages) {
+	const out = [];
+	for (const msg of messages) {
+		if (typeof msg.content === "string") {
+			out.push({
+				role: msg.role,
+				content: msg.content
+			});
+			continue;
+		}
+		const blocks = msg.content;
+		const toolResults = blocks.filter((b) => b.type === "tool_result");
+		const nonToolBlocks = blocks.filter((b) => b.type !== "tool_result");
+		for (const tr of toolResults) out.push({
+			role: "tool",
+			tool_call_id: tr.toolUseId ?? "unknown",
+			content: tr.content ?? ""
+		});
+		if (nonToolBlocks.length > 0) {
+			const normalized = normalizeContentBlocks(nonToolBlocks, msg.role);
+			if (msg.role === "assistant") {
+				const textBlocks = normalized.filter((b) => b.type === "text");
+				const toolUses = blocks.filter((b) => b.type === "tool_use");
+				const assistantMsg = {
+					role: "assistant",
+					content: textBlocks.length > 0 ? textBlocks : null
+				};
+				if (toolUses.length > 0) assistantMsg.tool_calls = toolUses.map((tu) => ({
+					id: tu.id ?? "unknown",
+					type: "function",
+					function: {
+						name: tu.name ?? "unknown",
+						arguments: JSON.stringify(tu.input ?? {})
+					}
+				}));
+				out.push(assistantMsg);
+			} else {
+				const textBlocks = normalized.filter((b) => b.type === "text");
+				if (textBlocks.length > 0) out.push({
+					role: msg.role,
+					content: textBlocks.length === 1 && msg.role !== "system" ? textBlocks[0].text ?? "" : textBlocks
+				});
+			}
+		}
+	}
+	return out;
+}
+/** Keep only text blocks, strip reasoning/tool_use/tool_result from content. */
+function normalizeContentBlocks(blocks, _role) {
+	return blocks.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => ({
+		type: "text",
+		text: b.text
+	}));
+}
+//#endregion
+//#region src/providers/deepseek.ts
+/**
+* DeepSeek provider — SSE streaming via the /v1/chat/completions endpoint.
+*
+* DeepSeek is API‑compatible with OpenAI so the wire format is the same.
+* The key difference: DeepSeek has implicit prefix caching on every request
+* (no cache_control blocks needed).
+*/
+const DEFAULT_BASE_URL$2 = "https://api.deepseek.com";
+const MODELS$2 = [{
+	id: "deepseek-chat",
+	label: "DeepSeek Chat (V3)",
+	contextWindow: 128e3,
+	maxOutput: 8192
+}, {
+	id: "deepseek-reasoner",
+	label: "DeepSeek Reasoner (R1)",
+	contextWindow: 128e3,
+	maxOutput: 8192
+}];
+/** Flush active tool call buffer, yielding tool_use_end or error events. */
+function flushActiveToolCall$1(call) {
+	try {
+		const input = JSON.parse(call.buffer);
+		return [{
+			type: "tool_use_end",
+			callId: call.id,
+			input
+		}];
+	} catch {
+		return [{
+			type: "error",
+			code: "TOOL_PARSE_ERROR",
+			message: `Failed to parse tool input for ${call.name}`
+		}];
+	}
+}
+/** Process tool_calls delta array, returning events and updated active call state. */
+function processToolCallDeltas$1(toolCalls, activeCall) {
+	const events = [];
+	let currentCall = activeCall;
+	for (const tc of toolCalls) {
+		const tcId = tc.id;
+		const fn = tc.function;
+		if (tcId && fn?.name) {
+			if (currentCall) try {
+				const input = JSON.parse(currentCall.buffer);
+				events.push({
+					type: "tool_use_end",
+					callId: currentCall.id,
+					input
+				});
+			} catch {}
+			currentCall = {
+				id: tcId,
+				name: fn.name,
+				buffer: ""
+			};
+			events.push({
+				type: "tool_use_start",
+				callId: tcId,
+				name: fn.name
+			});
+		}
+		if (fn?.arguments && currentCall) {
+			currentCall.buffer += fn.arguments;
+			events.push({
+				type: "tool_use_delta",
+				callId: currentCall.id,
+				text: fn.arguments
+			});
+		}
+	}
+	return {
+		events,
+		activeCall: currentCall
+	};
+}
+/** Process a single SSE line, returning events to yield and updated state. */
+function processSseLine$1(line, state) {
+	const trimmed = line.trim();
+	if (!trimmed || !trimmed.startsWith("data:")) return {
+		events: [],
+		state,
+		done: false
+	};
+	const data = trimmed.slice(5).trim();
+	if (data === "[DONE]") {
+		const events = [];
+		if (state.activeToolCall) events.push(...flushActiveToolCall$1(state.activeToolCall));
+		events.push({ type: "done" });
+		return {
+			events,
+			state: {
+				...state,
+				activeToolCall: null
+			},
+			done: true
+		};
+	}
+	let chunk;
+	try {
+		chunk = JSON.parse(data);
+	} catch {
+		return {
+			events: [],
+			state,
+			done: false
+		};
+	}
+	const choice = chunk.choices?.[0];
+	if (!choice?.delta) return {
+		events: [],
+		state,
+		done: false
+	};
+	const delta = choice.delta;
+	const events = [];
+	let { textIndex, reasoningIndex, activeToolCall } = state;
+	if (delta.reasoning_content && typeof delta.reasoning_content === "string") events.push({
+		type: "reasoning_delta",
+		index: reasoningIndex++,
+		text: delta.reasoning_content
+	});
+	if (delta.content && typeof delta.content === "string") events.push({
+		type: "text_delta",
+		index: textIndex++,
+		text: delta.content
+	});
+	if (delta.tool_calls) {
+		const tcResult = processToolCallDeltas$1(delta.tool_calls, activeToolCall);
+		events.push(...tcResult.events);
+		activeToolCall = tcResult.activeCall;
+	}
+	return {
+		events,
+		state: {
+			textIndex,
+			reasoningIndex,
+			activeToolCall
+		},
+		done: false
+	};
+}
+/**
+* Create a DeepSeek provider instance.
+*
+* Each call to `stream()` opens a fresh HTTP connection.
+* The provider itself is stateless — the API key is the only configuration.
+*/
+function createDeepSeekProvider(config) {
+	const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL$2;
+	config.timeoutMs;
+	return {
+		id: "deepseek",
+		listModels() {
+			return MODELS$2;
+		},
+		getCapability(modelId) {
+			const cap = getCapability("deepseek", modelId);
+			if (!cap) throw new LlmError(`Unknown DeepSeek model: ${modelId}`, {
+				category: "llm",
+				recoverable: false,
+				retryable: false,
+				diagnosticHint: "llm_unknown_model"
+			});
+			return cap;
+		},
+		async *stream(...[modelId, messages, systemPrompt, tools, signal]) {
+			const body = {
+				model: modelId,
+				messages: [...systemPrompt ? [{
+					role: "system",
+					content: systemPrompt
+				}] : [], ...normalizeOpenAiMessages(messages)],
+				stream: true,
+				...tools.length > 0 ? { tools: normalizeOpenAiTools(tools) } : {}
+			};
+			async function makeRequest() {
+				const controller = new AbortController();
+				const onAbort = () => controller.abort();
+				signal.addEventListener("abort", onAbort, { once: true });
+				try {
+					const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							Authorization: `Bearer ${config.apiKey}`
+						},
+						body: JSON.stringify(body),
+						signal: controller.signal
+					});
+					if (!response.ok) await handleHttpError$2(response);
+					return response;
+				} finally {
+					signal.removeEventListener("abort", onAbort);
+				}
+			}
+			const response = await withRetry(makeRequest, {
+				baseMs: 500,
+				maxMs: 32e3
+			});
+			if (!response.body) throw new LlmError("DeepSeek returned empty response body", {
+				category: "llm",
+				recoverable: true,
+				retryable: true
+			});
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+			let textIndex = 0;
+			let reasoningIndex = 0;
+			let activeToolCall = null;
+			try {
+				while (true) {
+					if (signal.aborted) break;
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					const lines = buffer.split("\n");
+					buffer = lines.pop() ?? "";
+					for (const line of lines) {
+						const result = processSseLine$1(line, {
+							activeToolCall,
+							textIndex,
+							reasoningIndex
+						});
+						for (const event of result.events) yield event;
+						if (result.done) return;
+						activeToolCall = result.state.activeToolCall;
+						textIndex = result.state.textIndex;
+						reasoningIndex = result.state.reasoningIndex;
+					}
+				}
+				if (activeToolCall) for (const event of flushActiveToolCall$1(activeToolCall)) yield event;
+				yield { type: "done" };
+			} finally {
+				reader.releaseLock();
+			}
+		}
+	};
+}
+async function handleHttpError$2(response) {
+	let body;
+	try {
+		body = await response.text();
+	} catch {
+		body = "";
+	}
+	const status = response.status;
+	if (status === 401 || status === 403) throw new LlmAuthError(`DeepSeek auth failed (${status}): ${body}`);
+	if (status === 429) throw new LlmRateLimitError(`DeepSeek rate limited (429): ${body}`);
+	if (status === 529) {
+		const err = new LlmRateLimitError(`DeepSeek overloaded (529): ${body}`);
+		err.status = 529;
+		throw err;
+	}
+	if (status === 400 && body.includes("context")) throw new LlmContextOverflowError(`DeepSeek context overflow: ${body}`);
+	throw new LlmError(`DeepSeek HTTP ${status}: ${body}`, {
+		category: "llm",
+		recoverable: status >= 500,
+		retryable: status >= 500 || status === 429
+	});
+}
+//#endregion
+//#region src/providers/openai.ts
+/**
+* OpenAI provider — SSE streaming via the /v1/chat/completions endpoint.
+*
+* The API shape is identical to DeepSeek (both follow the OpenAI spec),
+* but the provider metadata and defaults differ.
+*/
+const DEFAULT_BASE_URL$1 = "https://api.openai.com";
+const MODELS$1 = [
+	{
+		id: "gpt-4o",
+		label: "GPT-4o",
+		contextWindow: 128e3,
+		maxOutput: 16384
+	},
+	{
+		id: "gpt-4o-mini",
+		label: "GPT-4o Mini",
+		contextWindow: 128e3,
+		maxOutput: 16384
+	},
+	{
+		id: "o3-mini",
+		label: "o3-mini",
+		contextWindow: 2e5,
+		maxOutput: 1e5
+	}
+];
+/** Flush active tool call buffer, yielding tool_use_end or error events. */
+function flushActiveToolCall(call) {
+	try {
+		const input = JSON.parse(call.buffer);
+		return [{
+			type: "tool_use_end",
+			callId: call.id,
+			input
+		}];
+	} catch {
+		return [{
+			type: "error",
+			code: "TOOL_PARSE_ERROR",
+			message: `Failed to parse tool input for ${call.name}`
+		}];
+	}
+}
+/** Process tool_calls delta array, returning events and updated active call state. */
+function processToolCallDeltas(toolCalls, activeCall) {
+	const events = [];
+	let currentCall = activeCall;
+	for (const tc of toolCalls) {
+		const tcId = tc.id;
+		const fn = tc.function;
+		if (tcId && fn?.name) {
+			if (currentCall) try {
+				const input = JSON.parse(currentCall.buffer);
+				events.push({
+					type: "tool_use_end",
+					callId: currentCall.id,
+					input
+				});
+			} catch {}
+			currentCall = {
+				id: tcId,
+				name: fn.name,
+				buffer: ""
+			};
+			events.push({
+				type: "tool_use_start",
+				callId: tcId,
+				name: fn.name
+			});
+		}
+		if (fn?.arguments && currentCall) {
+			currentCall.buffer += fn.arguments;
+			events.push({
+				type: "tool_use_delta",
+				callId: currentCall.id,
+				text: fn.arguments
+			});
+		}
+	}
+	return {
+		events,
+		activeCall: currentCall
+	};
+}
+/** Process a single SSE line, returning events to yield and updated state. */
+function processSseLine(line, state) {
+	const trimmed = line.trim();
+	if (!trimmed || !trimmed.startsWith("data:")) return {
+		events: [],
+		state,
+		done: false
+	};
+	const data = trimmed.slice(5).trim();
+	if (data === "[DONE]") {
+		const events = [];
+		if (state.activeToolCall) events.push(...flushActiveToolCall(state.activeToolCall));
+		events.push({ type: "done" });
+		return {
+			events,
+			state: {
+				...state,
+				activeToolCall: null
+			},
+			done: true
+		};
+	}
+	let chunk;
+	try {
+		chunk = JSON.parse(data);
+	} catch {
+		return {
+			events: [],
+			state,
+			done: false
+		};
+	}
+	const choice = chunk.choices?.[0];
+	if (!choice?.delta) return {
+		events: [],
+		state,
+		done: false
+	};
+	const delta = choice.delta;
+	const events = [];
+	let { textIndex, reasoningIndex, activeToolCall } = state;
+	if (delta.reasoning_content && typeof delta.reasoning_content === "string") events.push({
+		type: "reasoning_delta",
+		index: reasoningIndex++,
+		text: delta.reasoning_content
+	});
+	if (delta.content && typeof delta.content === "string") events.push({
+		type: "text_delta",
+		index: textIndex++,
+		text: delta.content
+	});
+	if (delta.tool_calls) {
+		const tcResult = processToolCallDeltas(delta.tool_calls, activeToolCall);
+		events.push(...tcResult.events);
+		activeToolCall = tcResult.activeCall;
+	}
+	return {
+		events,
+		state: {
+			textIndex,
+			reasoningIndex,
+			activeToolCall
+		},
+		done: false
+	};
+}
+/**
+* Create an OpenAI provider instance.
+*
+* Same SSE parsing logic as DeepSeek — both follow the same wire protocol.
+* The only differences are the base URL, models, and capability metadata.
+*/
+function createOpenAiProvider(config) {
+	const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL$1;
+	return {
+		id: "openai",
+		listModels() {
+			return MODELS$1;
+		},
+		getCapability(modelId) {
+			const cap = getCapability("openai", modelId);
+			if (!cap) throw new LlmError(`Unknown OpenAI model: ${modelId}`, {
+				category: "llm",
+				recoverable: false,
+				retryable: false,
+				diagnosticHint: "llm_unknown_model"
+			});
+			return cap;
+		},
+		async *stream(...[modelId, messages, systemPrompt, tools, signal]) {
+			const body = {
+				model: modelId,
+				messages: [...systemPrompt ? [{
+					role: "system",
+					content: systemPrompt
+				}] : [], ...normalizeOpenAiMessages(messages)],
+				stream: true,
+				...tools.length > 0 ? { tools: normalizeOpenAiTools(tools) } : {}
+			};
+			async function makeRequest() {
+				const controller = new AbortController();
+				const onAbort = () => controller.abort();
+				signal.addEventListener("abort", onAbort, { once: true });
+				try {
+					const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							Authorization: `Bearer ${config.apiKey}`
+						},
+						body: JSON.stringify(body),
+						signal: controller.signal
+					});
+					if (!response.ok) await handleHttpError$1(response);
+					return response;
+				} finally {
+					signal.removeEventListener("abort", onAbort);
+				}
+			}
+			const response = await withRetry(makeRequest, {
+				baseMs: 500,
+				maxMs: 32e3
+			});
+			if (!response.body) throw new LlmError("OpenAI returned empty response body", {
+				category: "llm",
+				recoverable: true,
+				retryable: true
+			});
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+			let textIndex = 0;
+			let reasoningIndex = 0;
+			let activeToolCall = null;
+			try {
+				while (true) {
+					if (signal.aborted) break;
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					const lines = buffer.split("\n");
+					buffer = lines.pop() ?? "";
+					for (const line of lines) {
+						const result = processSseLine(line, {
+							activeToolCall,
+							textIndex,
+							reasoningIndex
+						});
+						for (const event of result.events) yield event;
+						if (result.done) return;
+						activeToolCall = result.state.activeToolCall;
+						textIndex = result.state.textIndex;
+						reasoningIndex = result.state.reasoningIndex;
+					}
+				}
+				if (activeToolCall) for (const event of flushActiveToolCall(activeToolCall)) yield event;
+				yield { type: "done" };
+			} finally {
+				reader.releaseLock();
+			}
+		}
+	};
+}
+async function handleHttpError$1(response) {
+	let body;
+	try {
+		body = await response.text();
+	} catch {
+		body = "";
+	}
+	const status = response.status;
+	if (status === 401 || status === 403) throw new LlmAuthError(`OpenAI auth failed (${status}): ${body}`);
+	if (status === 429) throw new LlmRateLimitError(`OpenAI rate limited (429): ${body}`);
+	if (status === 529) throw new LlmRateLimitError(`OpenAI overloaded (529): ${body}`, 529);
+	if (status === 400 && body.includes("context")) throw new LlmContextOverflowError(`OpenAI context overflow: ${body}`);
+	throw new LlmError(`OpenAI HTTP ${status}: ${body}`, {
+		category: "llm",
+		recoverable: status >= 500,
+		retryable: status >= 500 || status === 429
+	});
+}
+//#endregion
+//#region src/providers/anthropic.ts
+/**
+* Anthropic provider — SSE streaming via the /v1/messages endpoint.
+*
+* Translates Lynx's OpenAI‑compatible internal format to Anthropic's
+* native message/tool format, then maps Anthropic SSE events back to
+* Lynx StreamEvent types. This is the reverse of what Claude Code's
+* Codex adapter does (Anthropic → OpenAI translation).
+*/
+const DEFAULT_BASE_URL = "https://api.anthropic.com";
+const ANTHROPIC_VERSION = "2023-06-01";
+const MODELS = [
+	{
+		id: "claude-opus-4-8",
+		label: "Claude Opus 4.8",
+		contextWindow: 2e5,
+		maxOutput: 32e3
+	},
+	{
+		id: "claude-sonnet-4-6",
+		label: "Claude Sonnet 4.6",
+		contextWindow: 2e5,
+		maxOutput: 16384
+	},
+	{
+		id: "claude-haiku-4-5",
+		label: "Claude Haiku 4.5",
+		contextWindow: 2e5,
+		maxOutput: 8192
+	}
+];
+/**
+* Convert Lynx OpenAI‑compatible ChatMessage[] to Anthropic Message[].
+* System‑role messages are extracted into a separate string array
+* (Anthropic treats system as a top‑level parameter, not a message).
+*/
+function translateMessages(chatMessages) {
+	const messages = [];
+	const systemLines = [];
+	for (const msg of chatMessages) {
+		if (msg.role === "system") {
+			if (typeof msg.content === "string") systemLines.push(msg.content);
+			else if (Array.isArray(msg.content)) {
+				for (const block of msg.content) if (block.type === "text" && block.text) systemLines.push(block.text);
+			}
+			continue;
+		}
+		if (msg.role === "user") messages.push({
+			role: "user",
+			content: translateUserContent(msg)
+		});
+		else if (msg.role === "assistant") messages.push({
+			role: "assistant",
+			content: translateAssistantContent(msg)
+		});
+		else if (msg.role === "tool") messages.push({
+			role: "user",
+			content: [{
+				type: "tool_result",
+				tool_use_id: msg.tool_call_id ?? "unknown",
+				content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+			}]
+		});
+	}
+	return {
+		messages,
+		systemLines
+	};
+}
+/** Convert a Lynx user message to Anthropic content. */
+function translateUserContent(msg) {
+	if (typeof msg.content === "string") return msg.content;
+	if (!msg.content || msg.content.length === 0) return "";
+	const blocks = [];
+	for (const block of msg.content) if (block.type === "text" && block.text) blocks.push({
+		type: "text",
+		text: block.text
+	});
+	else if (block.type === "tool_result") blocks.push({
+		type: "tool_result",
+		tool_use_id: block.toolUseId ?? "unknown",
+		content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+		is_error: block.isError
+	});
+	return blocks.length > 0 ? blocks : "";
+}
+/** Convert a Lynx assistant message to Anthropic content. */
+function translateAssistantContent(msg) {
+	const blocks = [];
+	if (Array.isArray(msg.content)) {
+		for (const block of msg.content) if (block.type === "text" && block.text) blocks.push({
+			type: "text",
+			text: block.text
+		});
+		else if (block.type === "tool_use" && block.id && block.name) blocks.push({
+			type: "tool_use",
+			id: block.id,
+			name: block.name,
+			input: block.input ?? {}
+		});
+	} else if (typeof msg.content === "string" && msg.content) blocks.push({
+		type: "text",
+		text: msg.content
+	});
+	if (msg.tool_calls) for (const tc of msg.tool_calls) {
+		let input = {};
+		try {
+			input = JSON.parse(tc.function.arguments);
+		} catch {
+			input = {};
+		}
+		blocks.push({
+			type: "tool_use",
+			id: tc.id,
+			name: tc.function.name,
+			input
+		});
+	}
+	return blocks.length > 0 ? blocks : "";
+}
+/** Convert Lynx/OpenAI‑format tool descriptors to Anthropic format. */
+function translateTools(tools) {
+	return tools.map((tool) => {
+		const raw = tool;
+		return {
+			name: raw.name ?? "unknown",
+			description: raw.description ?? "",
+			input_schema: raw.inputSchema ?? raw.function?.parameters ?? {}
+		};
+	});
+}
+/**
+* Parse a single Anthropic SSE event line and return mapped Lynx events.
+* Anthropic SSE format: `event: <type>\ndata: <json>\n\n`
+*/
+function processAnthropicEvent(eventType, data, state) {
+	const events = [];
+	let nextState = state;
+	if (eventType === "message_start") return {
+		events,
+		state: nextState
+	};
+	if (eventType === "ping") return {
+		events,
+		state: nextState
+	};
+	if (eventType === "content_block_start") {
+		const parsed = JSON.parse(data);
+		const block = parsed.content_block;
+		if (block.type === "tool_use" && block.id && block.name) {
+			nextState = {
+				...state,
+				activeToolCall: {
+					id: block.id,
+					name: block.name,
+					buffer: ""
+				},
+				activeToolCallIndex: parsed.index,
+				toolUseIndices: new Set(state.toolUseIndices).add(parsed.index)
+			};
+			events.push({
+				type: "tool_use_start",
+				callId: block.id,
+				name: block.name
+			});
+		}
+		return {
+			events,
+			state: nextState
+		};
+	}
+	if (eventType === "content_block_delta") {
+		const delta = JSON.parse(data).delta;
+		if (delta.type === "text_delta" && delta.text) events.push({
+			type: "text_delta",
+			index: state.textIndex++,
+			text: delta.text
+		});
+		else if (delta.type === "input_json_delta" && delta.partial_json && state.activeToolCall) {
+			nextState = {
+				...state,
+				activeToolCall: {
+					...state.activeToolCall,
+					buffer: state.activeToolCall.buffer + delta.partial_json
+				}
+			};
+			events.push({
+				type: "tool_use_delta",
+				callId: state.activeToolCall.id,
+				text: delta.partial_json
+			});
+		} else if (delta.type === "thinking_delta" && delta.thinking) events.push({
+			type: "reasoning_delta",
+			index: 0,
+			text: delta.thinking
+		});
+		return {
+			events,
+			state: nextState
+		};
+	}
+	if (eventType === "content_block_stop") {
+		const parsed = JSON.parse(data);
+		if (state.activeToolCall && parsed.index === state.activeToolCallIndex && state.activeToolCall.buffer) try {
+			const input = JSON.parse(state.activeToolCall.buffer);
+			events.push({
+				type: "tool_use_end",
+				callId: state.activeToolCall.id,
+				input
+			});
+			nextState = {
+				...state,
+				toolUseCount: state.toolUseCount + 1,
+				activeToolCall: null
+			};
+		} catch {
+			events.push({
+				type: "error",
+				code: "TOOL_PARSE_ERROR",
+				message: `解析 ${state.activeToolCall.name} 的工具输入失败`
+			});
+		}
+		return {
+			events,
+			state: nextState
+		};
+	}
+	if (eventType === "message_delta") return {
+		events,
+		state: nextState
+	};
+	if (eventType === "message_stop") {
+		events.push({ type: "done" });
+		return {
+			events,
+			state: nextState
+		};
+	}
+	return {
+		events,
+		state: nextState
+	};
+}
+/**
+* Create an Anthropic provider instance.
+*
+* Each call to `stream()` opens a fresh HTTP connection.
+* The provider itself is stateless — the API key is the only configuration.
+*/
+function createAnthropicProvider(config) {
+	const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+	config.timeoutMs;
+	const apiKey = config.apiKey;
+	return {
+		id: "anthropic",
+		listModels() {
+			return MODELS;
+		},
+		getCapability(modelId) {
+			const cap = getCapability("anthropic", modelId);
+			if (!cap) throw new LlmError(`未知 Anthropic 模型: ${modelId}`, {
+				category: "llm",
+				recoverable: false,
+				retryable: false,
+				diagnosticHint: "llm_unknown_model"
+			});
+			return cap;
+		},
+		async *stream(...[modelId, messages, systemPrompt, tools, signal]) {
+			const translated = translateMessages(messages);
+			const allSystemLines = systemPrompt ? [systemPrompt, ...translated.systemLines] : translated.systemLines;
+			const systemParam = allSystemLines.length > 0 ? allSystemLines.join("\n\n") : void 0;
+			const body = {
+				model: modelId,
+				max_tokens: 8192,
+				messages: translated.messages,
+				...systemParam ? { system: systemParam } : {},
+				...tools.length > 0 ? { tools: translateTools(tools) } : {},
+				stream: true
+			};
+			async function makeRequest() {
+				const controller = new AbortController();
+				const onAbort = () => controller.abort();
+				signal.addEventListener("abort", onAbort, { once: true });
+				try {
+					const response = await fetch(`${baseUrl}/v1/messages`, {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							"x-api-key": apiKey,
+							"anthropic-version": ANTHROPIC_VERSION
+						},
+						body: JSON.stringify(body),
+						signal: AbortSignal.any ? AbortSignal.any([signal, controller.signal]) : controller.signal
+					});
+					if (!response.ok) await handleHttpError(response);
+					return response;
+				} finally {
+					signal.removeEventListener("abort", onAbort);
+				}
+			}
+			const response = await withRetry(makeRequest, {
+				baseMs: 500,
+				maxMs: 32e3
+			});
+			if (!response.body) throw new LlmError("Anthropic 返回了空响应体", {
+				category: "llm",
+				recoverable: true,
+				retryable: true
+			});
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+			let eventType = "";
+			let state = {
+				activeToolCall: null,
+				activeToolCallIndex: -1,
+				textIndex: 0,
+				toolUseCount: 0,
+				toolUseIndices: /* @__PURE__ */ new Set()
+			};
+			try {
+				while (true) {
+					if (signal.aborted) break;
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					const lines = buffer.split("\n");
+					buffer = lines.pop() ?? "";
+					for (const line of lines) {
+						const trimmed = line.trim();
+						if (trimmed.startsWith("event: ")) eventType = trimmed.slice(7).trim();
+						else if (trimmed.startsWith("data: ") && eventType) {
+							const data = trimmed.slice(6).trim();
+							const result = processAnthropicEvent(eventType, data, state);
+							for (const event of result.events) yield event;
+							state = result.state;
+						}
+					}
+				}
+				if (state.activeToolCall && state.activeToolCall.buffer) try {
+					const input = JSON.parse(state.activeToolCall.buffer);
+					yield {
+						type: "tool_use_end",
+						callId: state.activeToolCall.id,
+						input
+					};
+				} catch {}
+				yield { type: "done" };
+			} finally {
+				reader.releaseLock();
+			}
+		}
+	};
+}
+async function handleHttpError(response) {
+	let body;
+	try {
+		body = await response.text();
+	} catch {
+		body = "";
+	}
+	const status = response.status;
+	if (status === 401 || status === 403) throw new LlmAuthError(`Anthropic 认证失败 (${status}): ${body}`);
+	if (status === 429) throw new LlmRateLimitError(`Anthropic 速率限制 (429): ${body}`);
+	if (status === 529) {
+		const err = new LlmRateLimitError(`Anthropic 过载 (529): ${body}`);
+		err.status = 529;
+		throw err;
+	}
+	if (status === 400 && body.includes("context")) throw new LlmContextOverflowError(`Anthropic 上下文溢出: ${body}`);
+	throw new LlmError(`Anthropic HTTP ${status}: ${body}`, {
+		category: "llm",
+		recoverable: status >= 500,
+		retryable: status >= 500 || status === 429
+	});
+}
+//#endregion
+export { FallbackExhaustedError, Stream, buildCandidateChain, createAnthropicProvider, createDeepSeekProvider, createOpenAiProvider, getCapability, listCapabilities, runWithFallback, withRetry };
+
+//# sourceMappingURL=index.mjs.map