vern-llm 0.1.0

package/dist/index.js

@@ -0,0 +1,701 @@
+import { randomUUID } from "crypto";
+
+//#region src/types.ts
+var LLMError = class extends Error {
+	constructor(message, type, status, issues) {
+		super(message);
+		this.type = type;
+		this.status = status;
+		this.issues = issues;
+		this.name = "LLMError";
+	}
+};
+function isLLMError(err) {
+	return err instanceof LLMError;
+}
+/**
+* Trivial default so the package works out of the box with no external deps
+* Not shared across processes, swap in Redis/Upstash/etc for production
+*/
+var InMemoryCacheAdapter = class {
+	store = new Map();
+	async get(key) {
+		const entry = this.store.get(key);
+		if (!entry) return null;
+		if (Date.now() > entry.expiresAt) {
+			this.store.delete(key);
+			return null;
+		}
+		return entry.value;
+	}
+	async set(key, value, ttl) {
+		this.store.set(key, {
+			value,
+			expiresAt: Date.now() + ttl * 1e3
+		});
+	}
+};
+
+//#endregion
+//#region src/circuitBreaker.ts
+/**
+* Per retry VernLLM-instance circuit breaker. Tracks consecutive failures across
+* calls. Once the threshold is hit, short-circuits new calls with an
+* LLMError('circuit_open') instead of hitting the provider, until the
+* cooldown elapses and a single trial call is allowed through
+*/
+var CircuitBreaker = class {
+	state = "closed";
+	consecutiveFailures = 0;
+	openedAt = 0;
+	threshold;
+	cooldownMs;
+	constructor(options = {}) {
+		this.threshold = options.threshold ?? 5;
+		this.cooldownMs = options.cooldownMs ?? 3e4;
+	}
+	/** Throws if the circuit is open and the cooldown hasnt elapsed */
+	assertClosed() {
+		if (this.state !== "open") return;
+		const elapsed = Date.now() - this.openedAt;
+		if (elapsed >= this.cooldownMs) {
+			this.state = "half-open";
+			return;
+		}
+		throw new LLMError(`Circuit open — provider has failed ${this.consecutiveFailures} times in a row. Retry in ${Math.ceil((this.cooldownMs - elapsed) / 1e3)}s.`, "circuit_open");
+	}
+	recordSuccess() {
+		this.consecutiveFailures = 0;
+		this.state = "closed";
+	}
+	recordFailure() {
+		this.consecutiveFailures += 1;
+		if (this.state === "half-open") {
+			this.state = "open";
+			this.openedAt = Date.now();
+			return;
+		}
+		if (this.consecutiveFailures >= this.threshold) {
+			this.state = "open";
+			this.openedAt = Date.now();
+		}
+	}
+	getState() {
+		return this.state;
+	}
+};
+
+//#endregion
+//#region src/logger.ts
+/**
+* Default logger. `debug` is gated by the `debug` option on VernLLM
+* warn/error always fire since they indicate real problems (retries, cache failures)
+*/
+var ConsoleLogger = class {
+	constructor(debugEnabled) {
+		this.debugEnabled = debugEnabled;
+	}
+	debug(message) {
+		if (this.debugEnabled) console.debug(message);
+	}
+	warn(message) {
+		console.warn(message);
+	}
+	error(message, meta) {
+		console.error(message, meta ?? "");
+	}
+};
+
+//#endregion
+//#region src/internal/vernLLM.utilts.ts
+function defaultParseJson(content) {
+	try {
+		return JSON.parse(content);
+	} catch {
+		return void 0;
+	}
+}
+/**
+* Looks inside an unknown error value and pulls out an http status code
+* if one is present. Checks the status field first then the status code
+* field since different client libraries use different names for this.
+* Returns undefined when the error is not an object or carries no status
+*/
+function extractStatus(err) {
+	if (!err || typeof err !== "object") return void 0;
+	const error = err;
+	if (typeof error.status === "number") return error.status;
+	if (typeof error.statusCode === "number") return error.statusCode;
+	return void 0;
+}
+/**
+* Runs an async function and cancels it if it takes longer than the given
+* timeout. Creates an internal abort controller that fires after the
+* timeout elapses, and combines it with any external signal the caller
+* passed in so either one can cancel the underlying call. The internal
+* timer is always cleared afterward, whether the function succeeds,
+* fails, or is aborted, so nothing is left running in the background
+*/
+async function withTimeout(fn, timeoutMs, externalSignal) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => {
+		controller.abort();
+	}, timeoutMs);
+	const signal = externalSignal ? AbortSignal.any([externalSignal, controller.signal]) : controller.signal;
+	try {
+		return await fn(signal);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Exponential backoff with jitter, capped at maxDelayMs.
+* Jitter avoids thundering-herd retries when many callers back off in lockstep,
+* the cap prevents unbounded delays when maxRetries is high
+*/
+function getBackoffDelay(baseDelayMs, attempt, maxDelayMs = 1e4) {
+	const exp = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+	return exp / 2 + Math.random() * (exp / 2);
+}
+/**
+* Pauses execution for the given delay before a retry attempt. If an
+* abort signal is provided and it fires while waiting, the pending
+* timer is cancelled immediately and the wait rejects right away with
+* an aborted error instead of continuing to sit idle until the delay
+* would have finished on its own
+*/
+async function waitForRetry(delay, signal) {
+	await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(new LLMError("Operation aborted", "aborted"));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, delay);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+
+//#endregion
+//#region src/vernLLM.ts
+/**
+* A resilient wrapper around an LLM chat completions client, this is VernLLM!
+*
+* Adds retry with exponential backoff and jitter, per-attempt timeouts,
+* an optional circuit breaker, JSON parsing with optional schema
+* validation, usage tracking, and an optional response cache, all
+* configurable, all opt-in beyond sensible defaults
+*/
+var VernLLM = class {
+	client;
+	model;
+	maxRetries;
+	timeoutMs;
+	baseDelayMs;
+	defaultMaxTokens;
+	cache;
+	nonRetryableStatus;
+	parseJson;
+	onUsage;
+	logger;
+	breaker;
+	/**
+	* @param options: Client, model, and all tunables (retries, timeout,
+	* backoff, cache, circuit breaker, logger, etc). See VernLLMOptions in `types.ts`
+	* for individual defaults
+	*/
+	constructor(options) {
+		this.client = options.client;
+		this.model = options.model;
+		const retryConfig = this.resolveRetryConfig(options);
+		this.maxRetries = retryConfig.maxRetries;
+		this.timeoutMs = retryConfig.timeoutMs;
+		this.baseDelayMs = retryConfig.baseDelayMs;
+		this.defaultMaxTokens = retryConfig.defaultMaxTokens;
+		this.cache = options.cache ?? new InMemoryCacheAdapter();
+		this.nonRetryableStatus = options.nonRetryableStatus ?? [
+			400,
+			401,
+			403
+		];
+		this.parseJson = options.parseJson ?? defaultParseJson;
+		this.onUsage = options.onUsage;
+		this.logger = this.resolveLogger(options);
+		this.breaker = this.resolveCircuitBreaker(options);
+	}
+	/**
+	* Resolves retry/timeout/token defaults from the given options,
+	* falling back to the librarys built-in defaults for anything unset
+	*/
+	resolveRetryConfig(options) {
+		return {
+			maxRetries: options.maxRetries ?? 1,
+			timeoutMs: options.timeoutMs ?? 25e3,
+			baseDelayMs: options.baseDelayMs ?? 500,
+			defaultMaxTokens: options.defaultMaxTokens ?? 1e3
+		};
+	}
+	/**
+	* Returns the caller supplied logger, or a console-based logger whose
+	* debug output is gated by the `debug` option (defaulting to on
+	* outside production)
+	*/
+	resolveLogger(options) {
+		return options.logger ?? new ConsoleLogger(options.debug ?? process.env.NODE_ENV !== "production");
+	}
+	/**
+	* Builds a circuit breaker if `circuitBreaker` is truthy on the
+	* options. Passing `true` uses default thresholds, passing an options
+	* object tunes them. Returns undefined when the breaker is disabled
+	*/
+	resolveCircuitBreaker(options) {
+		if (!options.circuitBreaker) return void 0;
+		return new CircuitBreaker(options.circuitBreaker === true ? void 0 : options.circuitBreaker);
+	}
+	/**
+	* Makes a single logical LLM call, transparently retrying on failure
+	* according to the configured retry policy
+	*
+	* Fails fast if the circuit breaker is open or the signal is already
+	* aborted, before any request is dispatched. On exhausting all
+	* retries, records a circuit breaker failure and rejects with a
+	* normalized LLMError
+	*
+	* @param params : System/user content plus per call overrides
+	* (model, temperature, jsonMode, schema, signal, etc)
+	* @returns The parsed and optionally schema-validated response, or
+	* the raw string content when jsonMode is disabled
+	*/
+	async call(params) {
+		this.breaker?.assertClosed();
+		if (params.signal?.aborted) throw new LLMError("LLM request aborted", "aborted");
+		const requestId = params.requestId ?? randomUUID();
+		try {
+			const result = await this.retryWithBackoff(() => this.executeCall(params, requestId), requestId, params.signal);
+			return result;
+		} catch (error) {
+			this.breaker?.recordFailure();
+			throw this.normalizeError(error, params.signal);
+		}
+	}
+	/**
+	* Runs `fn`, retrying with backoff according to `shouldRetry` policy
+	* Purely mechanical: knows nothing about LLM specifics beyond the retry
+	* predicate, so its testable independent of request/response shaping
+	*/
+	async retryWithBackoff(fn, requestId, signal) {
+		let lastError;
+		for (let attempt = 0; attempt <= this.maxRetries; attempt++) try {
+			if (attempt > 0) await this.recoverDelay(requestId, attempt, signal);
+			return await fn();
+		} catch (error) {
+			lastError = error;
+			if (!this.shouldRetry(error, signal)) break;
+		}
+		throw lastError;
+	}
+	/**
+	* Converts any thrown value into a well-typed LLMError for the public
+	* API surface. Preserves an existing LLMError as is, reports aborted
+	* signals as such, classifies errors carrying an http status as
+	* type api, and otherwise falls back to a generic unknown error.
+	*/
+	normalizeError(error, signal) {
+		if (signal?.aborted) return new LLMError("LLM request aborted", "aborted");
+		if (error instanceof LLMError) return error;
+		const status = extractStatus(error);
+		if (status !== void 0) return new LLMError("LLM request failed", "api", status);
+		return new LLMError("LLM request failed", "unknown");
+	}
+	/**
+	* Performs a single attempt: builds the request, dispatches it with a
+	* timeout, and shapes the response. Throws on an empty response so
+	* the retry loop treats it like any other transient failure. Records
+	* usage and a circuit breaker success before returning
+	*/
+	async executeCall(params, requestId) {
+		const { useJson, model, request } = this.buildRequestPayload(params);
+		const response = await withTimeout((attemptSignal) => this.client.chat.completions.create(request, { signal: attemptSignal }), this.timeoutMs, params.signal);
+		const content = response.choices?.[0]?.message?.content?.trim();
+		if (!content) throw new LLMError("Empty LLM response", "api");
+		this.logger.debug(`[vern:${requestId}] output:\n${content.slice(0, 800)}`);
+		this.recordUsage(response, requestId, model);
+		this.breaker?.recordSuccess();
+		if (!useJson) return content;
+		return this.parseAndValidate(content, params.schema);
+	}
+	/**
+	* Applies per call defaults and shapes the params into the request
+	* object expected by the underlying client, including the resolved
+	* response format. Also returns whether JSON parsing should be
+	* applied to the response and which model was ultimately used
+	*/
+	buildRequestPayload(params) {
+		const { systemPrompt, userContent, temperature = .2, jsonMode = true, maxTokens = this.defaultMaxTokens, model = this.model, reasoningEffort, jsonSchema } = params;
+		const useJson = jsonMode || Boolean(jsonSchema);
+		const responseFormat = this.buildResponseFormat(jsonSchema, useJson);
+		const request = {
+			model,
+			temperature,
+			max_tokens: maxTokens,
+			...responseFormat ? { response_format: responseFormat } : {},
+			...reasoningEffort ? { reasoning_effort: reasoningEffort } : {},
+			messages: [{
+				role: "system",
+				content: systemPrompt
+			}, {
+				role: "user",
+				content: userContent
+			}]
+		};
+		return {
+			useJson,
+			model,
+			request
+		};
+	}
+	/**
+	* Chooses the response format to send to the provider. A provider
+	* native json schema takes priority when supplied, constraining
+	* generation directly, otherwise falls back to the looser json
+	* object mode when JSON output is requested, or no format at all
+	* for plain text responses
+	*/
+	buildResponseFormat(jsonSchema, useJson) {
+		if (jsonSchema) return {
+			type: "json_schema",
+			json_schema: {
+				name: jsonSchema.name,
+				schema: jsonSchema.schema,
+				strict: jsonSchema.strict ?? true,
+				description: jsonSchema.description
+			}
+		};
+		return useJson ? { type: "json_object" } : void 0;
+	}
+	/**
+	* Reports token usage to the caller supplied onUsage callback, when
+	* both a callback was configured and the provider actually returned
+	* usage data on this response. A no op otherwise.
+	*/
+	recordUsage(response, requestId, model) {
+		if (!response.usage || !this.onUsage) return;
+		this.onUsage({
+			promptTokens: response.usage.prompt_tokens ?? 0,
+			completionTokens: response.usage.completion_tokens ?? 0,
+			totalTokens: response.usage.total_tokens ?? 0,
+			requestId,
+			model
+		});
+	}
+	/**
+	* Parses the raw response content as JSON and, when a schema is
+	* supplied, validates the parsed value against it. Throws a parse
+	* type LLMError on malformed JSON and a validation type LLMError,
+	* carrying the schemas issues, on a failed validation
+	*/
+	parseAndValidate(content, schema) {
+		const parsed = this.parseJson(content);
+		if (parsed == null) throw new LLMError("Invalid JSON response", "parse");
+		if (!schema) return parsed;
+		const result = schema.safeParse(parsed);
+		if (!result.success) throw new LLMError("Schema validation failed", "validation", void 0, result.error);
+		return result.data;
+	}
+	/**
+	* Waits out the backoff delay for a given retry attempt, logging the
+	* attempt for observability before the wait begins. Rejects early if
+	* the signal aborts during the wait
+	*/
+	async recoverDelay(requestId, attempt, signal) {
+		const delay = getBackoffDelay(this.baseDelayMs, attempt);
+		this.logger.warn(`[vern:${requestId}] recovery attempt ${attempt}/${this.maxRetries}, waiting ${delay}ms`);
+		await waitForRetry(delay, signal);
+	}
+	/**
+	* Decides whether a failed attempt is worth retrying. Never retries
+	* once the signal has aborted, never retries a parse or validation
+	* failure since those stem from the response content rather than a
+	* transient fault, and never retries a status code the caller has
+	* marked as non retryable. Retries everything else
+	*/
+	shouldRetry(error, signal) {
+		if (signal?.aborted) return false;
+		if (error instanceof LLMError && (error.type === "parse" || error.type === "validation")) return false;
+		const status = extractStatus(error);
+		if (status !== void 0 && this.nonRetryableStatus.includes(status)) return false;
+		return true;
+	}
+	/**
+	* Thin cache wrapper around caller supplied logic. `params.fn` is expected
+	* to be a call that itself invokes `this.call(...)` (see `cachedLLMCall`
+	* below for a convenience wrapper that wires this up automatically), 
+	* `cachedCall` does not itself apply retry/timeout policy.
+	*/
+	async cachedCall(params) {
+		const cached = await this.cache.get(params.cacheKey);
+		if (cached != null) return cached;
+		try {
+			await params.reserveUsage?.();
+			const result = await params.fn();
+			try {
+				await this.cache.set(params.cacheKey, result, params.ttl);
+			} catch (error) {
+				this.logger.error("[VernLLM] cache write failed", { message: error instanceof Error ? error.message : "unknown" });
+			}
+			return result;
+		} catch (error) {
+			try {
+				await params.refundUsage?.();
+			} catch (refundError) {
+				this.logger.error("[VernLLM] refundUsage failed", { message: refundError instanceof Error ? refundError.message : "unknown" });
+			}
+			throw error;
+		}
+	}
+	/**
+	* Convenience wrapper composing `call` + `cachedCall`, so cached LLM calls
+	* automatically get retry/timeout/circuit-breaker behavior without callers
+	* having to remember to wire `fn: () => this.call(...)` themselves
+	*/
+	async cachedLLMCall(params) {
+		const { call: callParams,...cacheParams } = params;
+		return this.cachedCall({
+			...cacheParams,
+			fn: () => this.call(callParams)
+		});
+	}
+	/**
+	* Returns the current circuit breaker state, or undefined when no
+	* circuit breaker was configured on this instance
+	*/
+	getCircuitState() {
+		return this.breaker?.getState();
+	}
+};
+
+//#endregion
+//#region src/adapters/anthropic.ts
+/**
+* Wraps an Anthropic SDK client so it satisfies the same `LLMClient`
+* interface VernLLM uses for OpenAI/Groq. Anthropics Messages API has no
+* `response_format: json_object` equivalent, so when the caller requests
+* JSON mode, this adapter appends an instruction to the system prompt
+* asking the model to respond with JSON only
+*/
+function fromAnthropic(anthropicClient) {
+	return { chat: { completions: { async create(params, options) {
+		const systemMessage = params.messages.find((m) => m.role === "system");
+		const userMessages = params.messages.filter((m) => m.role === "user");
+		let jsonInstruction;
+		if (params.response_format?.type === "json_schema") {
+			const { name, schema } = params.response_format.json_schema;
+			jsonInstruction = `Respond with valid JSON only, no prose or markdown fences. The JSON must conform to this schema (name: "${name}"):\n${JSON.stringify(schema)}`;
+		} else if (params.response_format?.type === "json_object") jsonInstruction = "Respond with valid JSON only, no prose or markdown fences.";
+		const system = [systemMessage?.content, jsonInstruction].filter(Boolean).join("\n\n");
+		const response = await anthropicClient.messages.create({
+			model: params.model,
+			max_tokens: params.max_tokens,
+			temperature: params.temperature,
+			system: system || void 0,
+			messages: userMessages.map((m) => ({
+				role: "user",
+				content: m.content
+			}))
+		}, options);
+		const text = response.content.find((block) => block.type === "text")?.text ?? "";
+		return {
+			choices: [{ message: { content: text } }],
+			usage: {
+				prompt_tokens: response.usage?.input_tokens,
+				completion_tokens: response.usage?.output_tokens,
+				total_tokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0)
+			}
+		};
+	} } } };
+}
+
+//#endregion
+//#region src/adapters/gemini.ts
+/**
+* Wraps a Gemini client so it satisfies the `LLMClient` interface VernLLM
+* uses for OpenAI/Groq. Geminis shape differs on nearly every axis: a
+* `contents` array instead of `messages`, a separate `systemInstruction`
+* field instead of a `system` role message, `generationConfig` instead of
+* top-level `temperature`/`max_tokens`, and native JSON Schema support via
+* `responseMimeType: 'application/json'` + `responseSchema` (so `jsonSchema`
+* is provider-enforced here, unlike the Anthropic adapters prompt-embedding
+* fallback). `reasoning_effort` has no equivalent. Geminis thinking models
+* use a token budget, not an effort tier, so its dropped, same as Anthropic.
+*/
+function fromGemini(geminiClient) {
+	return { chat: { completions: { async create(params, options) {
+		const systemMessage = params.messages.find((m) => m.role === "system");
+		const userMessages = params.messages.filter((m) => m.role === "user");
+		const wantsJson = Boolean(params.response_format);
+		const generationConfig = {
+			temperature: params.temperature,
+			maxOutputTokens: params.max_tokens
+		};
+		if (wantsJson) generationConfig.responseMimeType = "application/json";
+		if (params.response_format?.type === "json_schema") generationConfig.responseSchema = params.response_format.json_schema.schema;
+		const response = await geminiClient.generateContent({
+			model: params.model,
+			contents: userMessages.map((m) => ({
+				role: "user",
+				parts: [{ text: m.content }]
+			})),
+			systemInstruction: systemMessage ? { parts: [{ text: systemMessage.content }] } : void 0,
+			generationConfig
+		}, options);
+		const text = response.candidates?.[0]?.content?.parts?.map((p) => p.text ?? "").join("") ?? "";
+		return {
+			choices: [{ message: { content: text } }],
+			usage: {
+				prompt_tokens: response.usageMetadata?.promptTokenCount,
+				completion_tokens: response.usageMetadata?.candidatesTokenCount,
+				total_tokens: response.usageMetadata?.totalTokenCount
+			}
+		};
+	} } } };
+}
+
+//#endregion
+//#region src/adapters/bedrock.ts
+/**
+* Wraps a Bedrock Converse-API client so it satisfies the `LLMClient`
+* interface VernLLM uses for OpenAI/Groq. The Converse API is unified
+* across Bedrocks model families (Anthropic, Titan, Llama, Mistral, etc.),
+* so unlike raw per-model Bedrock invocation, this one adapter works
+* regardless of which underlying model `modelId` points at, as long as
+* that model supports Converse (most current-generation ones do)
+*
+* Theres no uniform native JSON Schema enforcement across families here
+* (some support it via forced tool-use, which varies per model), so
+* `jsonSchema`/`jsonMode` are emulated via a system-prompt instruction, same
+* approach as the Anthropic adapter. `reasoning_effort` has no Converse
+* equivalent and is dropped
+*/
+function fromBedrock(bedrockClient) {
+	return { chat: { completions: { async create(params, options) {
+		const systemMessage = params.messages.find((m) => m.role === "system");
+		const userMessages = params.messages.filter((m) => m.role === "user");
+		let jsonInstruction;
+		if (params.response_format?.type === "json_schema") {
+			const { name, schema } = params.response_format.json_schema;
+			jsonInstruction = `Respond with valid JSON only, no prose or markdown fences. The JSON must conform to this schema (name: "${name}"):\n${JSON.stringify(schema)}`;
+		} else if (params.response_format?.type === "json_object") jsonInstruction = "Respond with valid JSON only, no prose or markdown fences.";
+		const systemParts = [systemMessage?.content, jsonInstruction].filter((s) => Boolean(s));
+		const response = await bedrockClient.converse({
+			modelId: params.model,
+			messages: userMessages.map((m) => ({
+				role: "user",
+				content: [{ text: m.content }]
+			})),
+			system: systemParts.length ? systemParts.map((text$1) => ({ text: text$1 })) : void 0,
+			inferenceConfig: {
+				temperature: params.temperature,
+				maxTokens: params.max_tokens
+			}
+		}, options);
+		const text = response.output?.message?.content?.map((c) => c.text ?? "").join("") ?? "";
+		return {
+			choices: [{ message: { content: text } }],
+			usage: {
+				prompt_tokens: response.usage?.inputTokens,
+				completion_tokens: response.usage?.outputTokens,
+				total_tokens: response.usage?.totalTokens
+			}
+		};
+	} } } };
+}
+
+//#endregion
+//#region src/adapters/fetch.ts
+/**
+* A fetch-based escape hatch for providers with no SDK, or where pulling one
+* in isnt worth it. You supply the URL, headers, and two small mapping
+* functions; this handles the HTTP call and slots the result into the same
+* `LLMClient` shape every other adapter produces, so retries, timeouts,
+* the circuit breaker, and JSON/schema handling all still work unmodified
+*
+* Non-2xx responses throw an error with `.status` set to the HTTP status
+* code, so VernLLMs `nonRetryableStatus` handling (e.g. failing fast on
+* 401/403) applies here too
+*/
+function fromFetch(config) {
+	return { chat: { completions: { async create(params, options) {
+		const url = typeof config.url === "function" ? config.url(params) : config.url;
+		const headers = typeof config.headers === "function" ? await config.headers() : config.headers;
+		const res = await fetch(url, {
+			method: config.method ?? "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...headers
+			},
+			body: JSON.stringify(config.mapRequest(params)),
+			signal: options.signal
+		});
+		if (!res.ok) {
+			const body = await res.text().catch(() => "");
+			const err = new Error(`Fetch adapter request failed (${res.status}): ${body.slice(0, 500)}`);
+			err.status = res.status;
+			throw err;
+		}
+		const json = await res.json();
+		const { content, usage } = config.mapResponse(json);
+		return {
+			choices: [{ message: { content } }],
+			usage: usage ? {
+				prompt_tokens: usage.promptTokens,
+				completion_tokens: usage.completionTokens,
+				total_tokens: usage.totalTokens
+			} : void 0
+		};
+	} } } };
+}
+
+//#endregion
+//#region src/adapters/openaiCompatible.ts
+/**
+* Passthrough adapter for any SDK/client whose `chat.completions.create`
+* already matches the OpenAI wire format 1:1 : this covers most hosted
+* inference providers, since "OpenAI-compatible" is a de facto standard for
+* chat completion APIs. No transformation happens here, this exists purely
+* so call sites read clearly (`fromMistral(client)` vs handing a Mistral
+* client to something typed for OpenAI) and so a real transformation could
+* be added later, per-provider, without a breaking change.
+*
+* Not every SDKs own TypeScript types line up exactly with `LLMClient`
+* (extra fields, stricter unions, etc.), so this takes `unknown` and casts:
+* the actual compatibility contract is the JSON each provider sends and
+* receives over the wire, not the SDKs TS types.
+*/
+function fromOpenAICompatible(client) {
+	return client;
+}
+/** Groqs SDK matches the OpenAI wire format */
+const fromGroq = fromOpenAICompatible;
+/** Mistrals `chat.completions`-shaped client (or their OpenAI-compat endpoint) */
+const fromMistral = fromOpenAICompatible;
+/** DeepSeeks API is OpenAI-compatible */
+const fromDeepSeek = fromOpenAICompatible;
+/** Cerebras inference API is OpenAI-compatible */
+const fromCerebras = fromOpenAICompatible;
+/** Together AIs API is OpenAI-compatible */
+const fromTogether = fromOpenAICompatible;
+/** Fireworks AIs API is OpenAI-compatible */
+const fromFireworks = fromOpenAICompatible;
+/**
+* Ollama exposes an OpenAI-compatible endpoint at `/v1/chat/completions`
+* (as opposed to its native `/api/chat` format, which differs). Point an
+* OpenAI SDK instances `baseURL` at your Ollama server and pass it here:
+* this does not talk to Ollamas native API directly.
+*/
+const fromOllama = fromOpenAICompatible;
+
+//#endregion
+export { CircuitBreaker, ConsoleLogger, InMemoryCacheAdapter, LLMError, VernLLM, fromAnthropic, fromBedrock, fromCerebras, fromDeepSeek, fromFetch, fromFireworks, fromGemini, fromGroq, fromMistral, fromOllama, fromOpenAICompatible, fromTogether, isLLMError };
+//# sourceMappingURL=index.js.map