@tangle-network/agent-eval 0.129.0 → 0.130.1

package/dist/llm-client--GR4JbZE.js

@@ -0,0 +1,687 @@
+import { n as CaptureIntegrityError, t as AgentEvalError } from "./errors-8YnH8WlF.js";
+import { c as costForTokenPricing } from "./cost-ledger-DIgQUFZZ.js";
+import { a as providerFromBaseUrl, i as defaultProviderRedactor } from "./raw-provider-sink-BQd7mzyT.js";
+//#region src/llm-client.ts
+/**
+* LLM client with graceful degrade.
+*
+* OpenAI-compatible `/v1/chat/completions` client with:
+*   - Exponential-backoff retry on 429 + 5xx gateway errors (502/503/504).
+*   - Retry on transient network errors (fetch failed, AbortError, ECONNRESET).
+*   - One retry at temperature 1 when a model explicitly requires it.
+*   - Graceful json_schema → json_object degrade on 400 with schema-reject body.
+*   - Fenced-JSON stripping (```json ... ```) for models that wrap structured output.
+*   - Configurable base URL + api key / bearer, works with LiteLLM proxies, OpenAI
+*     directly, cli-bridge subscriptions, and any router that speaks the spec.
+*
+* Usage:
+*   const { value, result } = await callLlmJson<MyType>(
+*     { model: 'gpt-4o', messages: [...], jsonSchema: { name: 'x', schema: {...} } },
+*     { baseUrl: 'https://router.tangle.tools/v1', apiKey: process.env.KEY },
+*   )
+*
+* `createChatClient` wraps this implementation for provider-neutral package
+* entry points. Direct callers can use `callLlm` or `callLlmJson`.
+*/
+/** Conservative priced bound for the exact text request sent to a provider.
+* Returns undefined when output or multimodal input is not bounded, causing a
+* capped CostLedger to reject the call before execution. Pass
+* `customTokenPricing` when package pricing does not cover the model or endpoint. */
+function maximumChargeForLlmRequest(request, options = {}) {
+	if (request.maxTokens === void 0) return void 0;
+	if (!Number.isInteger(request.maxTokens) || request.maxTokens <= 0) throw new RangeError(`maximumChargeForLlmRequest: maxTokens must be a positive integer`);
+	if (request.messages.some((message) => Array.isArray(message.content) && message.content.some((part) => part.type === "image_url"))) return;
+	const attempts = resolveMaximumAttempts(options.maximumAttempts);
+	const forceJsonObject = options.jsonSchemaTransport === "json-object";
+	const requestBytes = new TextEncoder().encode(JSON.stringify(buildBody(request, forceJsonObject, options.thinking))).byteLength;
+	const batches = request.jsonSchema && !forceJsonObject ? 2 : 1;
+	const usage = {
+		inputTokens: requestBytes * attempts * batches,
+		outputTokens: request.maxTokens * attempts * batches
+	};
+	return options.customTokenPricing ? {
+		customTokenPricing: options.customTokenPricing,
+		...usage
+	} : {
+		model: request.model,
+		...usage
+	};
+}
+/** Convert a provider result into the canonical paid-call receipt input. */
+function costReceiptFromLlm(result, customTokenPricing) {
+	const cachedTokens = result.usage.cachedPromptTokens ?? 0;
+	const inputTokens = Math.max(0, result.usage.promptTokens - cachedTokens);
+	const configuredCostUsd = result.costUsd === null && customTokenPricing && result.usage.captured !== false ? costForTokenPricing(customTokenPricing, {
+		inputTokens,
+		...cachedTokens > 0 ? { cachedTokens } : {},
+		outputTokens: result.usage.completionTokens
+	}) : void 0;
+	return {
+		model: result.model,
+		inputTokens,
+		outputTokens: result.usage.completionTokens,
+		reasoningTokens: result.usage.reasoningTokens,
+		cachedTokens: cachedTokens > 0 ? cachedTokens : void 0,
+		actualCostUsd: result.costUsd ?? configuredCostUsd,
+		usageUnknown: result.usage.captured === false
+	};
+}
+/** Structured-response failures retain their completed provider receipt. */
+function costReceiptFromLlmError(error, customTokenPricing) {
+	return error instanceof LlmResponseError ? costReceiptFromLlm(error.result, customTokenPricing) : void 0;
+}
+var LlmCallError = class extends AgentEvalError {
+	status;
+	body;
+	model;
+	constructor(message, status, body, model) {
+		super("judge", message);
+		this.status = status;
+		this.body = body;
+		this.model = model;
+	}
+};
+/** A provider response completed and incurred measurable usage, but its content
+*  could not satisfy the caller's response contract. The response envelope is
+*  retained so accounting can commit the receipt before the error propagates. */
+var LlmResponseError = class extends AgentEvalError {
+	result;
+	constructor(message, result, options) {
+		super("judge", message, options);
+		this.result = result;
+	}
+};
+const DEFAULT_BASE_URL = "https://router.tangle.tools/v1";
+const DEFAULT_TIMEOUT_MS = Number(process.env.TANGLE_LLM_TIMEOUT_MS) || 3e5;
+const DEFAULT_MAXIMUM_ATTEMPTS = process.env.TANGLE_LLM_MAXIMUM_ATTEMPTS === void 0 ? 3 : Number(process.env.TANGLE_LLM_MAXIMUM_ATTEMPTS);
+function resolveMaximumAttempts(configured) {
+	const attempts = configured ?? DEFAULT_MAXIMUM_ATTEMPTS;
+	if (!Number.isInteger(attempts) || attempts <= 0) throw new RangeError("LLM maximum attempts must be a positive integer");
+	return attempts;
+}
+function providerTokenCount(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+const RETRYABLE_STATUS = /* @__PURE__ */ new Set([
+	429,
+	502,
+	503,
+	504
+]);
+/**
+* Transient transport/network error signatures, matched against an error's
+* name, message, and `code`. Covers fetch/undici network failures, aborts
+* and timeouts, and — critically — HTTP/2 transport faults a keep-alive
+* connection raises mid-response: `terminated`, `NGHTTP2_INTERNAL_ERROR`,
+* `UND_ERR_*`, `other side closed`. Those last ones carry no clean HTTP
+* status; unrecognised, they escape the retry loop and surface as an
+* uncaught rejection.
+*/
+const TRANSIENT_ERROR_PATTERNS = [
+	/AbortError/i,
+	/TimeoutError/i,
+	/this operation was aborted/i,
+	/fetch failed/i,
+	/ECONNRESET/i,
+	/ETIMEDOUT/i,
+	/EAI_AGAIN/i,
+	/socket hang up/i,
+	/stream.*ended.*unexpectedly/i,
+	/terminated/i,
+	/other side closed/i,
+	/NGHTTP2/i,
+	/UND_ERR/i
+];
+/**
+* True when an error is a transient transport/network fault worth retrying,
+* as opposed to a deterministic failure (4xx schema reject, JSON parse) that
+* a retry cannot fix. Inspects `LlmCallError.status`, then the error's
+* name/message/code, then recurses into `error.cause` — undici nests the
+* real socket fault one or more levels under `.cause`.
+*
+* This is the retry classifier for the package: `callLlm` and
+* `withJudgeRetry` both route through it, so connection failures are treated
+* consistently across transports.
+*/
+function isTransientLlmError(err) {
+	return classifyTransient(err, 0);
+}
+function classifyTransient(err, depth) {
+	if (err instanceof LlmCallError) return RETRYABLE_STATUS.has(err.status);
+	if (!(err instanceof Error)) return false;
+	const status = err.status;
+	if (typeof status === "number" && RETRYABLE_STATUS.has(status)) return true;
+	const code = err.code;
+	const haystack = `${err.name}\n${err.message}\n${typeof code === "string" ? code : ""}`;
+	if (TRANSIENT_ERROR_PATTERNS.some((p) => p.test(haystack))) return true;
+	const cause = err.cause;
+	if (depth < 4 && cause instanceof Error && cause !== err) return classifyTransient(cause, depth + 1);
+	return false;
+}
+function parseRetryAfter(headers) {
+	const h = headers.get("retry-after");
+	if (!h) return null;
+	const asNumber = Number(h);
+	if (Number.isFinite(asNumber) && asNumber > 0) return asNumber * 1e3;
+	const asDate = Date.parse(h);
+	if (Number.isFinite(asDate)) return Math.max(0, asDate - Date.now());
+	return null;
+}
+/** Exponential backoff: 500ms, 1s, 2s, 4s, ... capped at 16s. Attempt is 0-indexed. */
+function backoffMs(attempt) {
+	return Math.min(500 * 2 ** attempt, 16e3);
+}
+function buildHeaders(opts) {
+	const headers = {
+		"Content-Type": "application/json",
+		Accept: "application/json"
+	};
+	if (opts.authHeader) headers[opts.authHeader.name] = opts.authHeader.value;
+	else if (opts.bearer || opts.apiKey) headers.Authorization = `Bearer ${opts.bearer ?? opts.apiKey}`;
+	if (opts.idempotencyKey) headers["Idempotency-Key"] = opts.idempotencyKey;
+	return headers;
+}
+function isSchemaRejection(status, body) {
+	if (status !== 400) return false;
+	const lower = body.toLowerCase();
+	return lower.includes("response_format") || lower.includes("json_schema") || lower.includes("is unavailable") || lower.includes("not supported");
+}
+function isTemperatureOneRejection(status, body) {
+	if (status !== 400 || !/temperature/i.test(body)) return false;
+	return /temperature[^.\n]{0,120}\b(?:only|must|should|required|requires?)\b[^.\n]{0,40}\b1(?:\.0+)?\b/i.test(body) || /\bonly\s+1(?:\.0+)?\s+is\s+allowed\b[^.\n]{0,120}\btemperature\b/i.test(body);
+}
+function buildBody(req, forceJsonObject, defaultThinking) {
+	const body = {
+		model: req.model,
+		messages: req.messages,
+		temperature: req.temperature ?? 0
+	};
+	if (req.maxTokens != null) if (usesMaxCompletionTokens(req.model)) body.max_completion_tokens = req.maxTokens;
+	else body.max_tokens = req.maxTokens;
+	const thinking = req.thinking ?? defaultThinking;
+	if (thinking !== void 0) body.thinking = { type: thinking };
+	if (req.jsonSchema && !forceJsonObject) body.response_format = {
+		type: "json_schema",
+		json_schema: {
+			name: req.jsonSchema.name,
+			schema: req.jsonSchema.schema,
+			strict: true
+		}
+	};
+	else if (req.jsonMode || req.jsonSchema) body.response_format = { type: "json_object" };
+	return body;
+}
+function usesMaxCompletionTokens(model) {
+	return /^gpt-5(?:[.-]|$)/i.test(model);
+}
+async function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Combine the per-attempt timeout signal with an optional caller signal into
+* one signal the fetch listens on. Prefers the native `AbortSignal.any`; falls
+* back to manual wiring on runtimes that predate it. The caller signal is also
+* propagated to the timeout controller so aborting it cancels the in-flight
+* fetch immediately.
+*/
+function linkSignals(timeoutController, caller) {
+	if (!caller) return timeoutController.signal;
+	if (typeof AbortSignal.any === "function") return AbortSignal.any([timeoutController.signal, caller]);
+	if (caller.aborted) timeoutController.abort();
+	else caller.addEventListener("abort", () => timeoutController.abort(), { once: true });
+	return timeoutController.signal;
+}
+/** True once the cross-attempt wall-clock budget (if any) is exhausted. */
+function deadlineExceeded(start, deadlineMs) {
+	return deadlineMs != null && Date.now() - start >= deadlineMs;
+}
+/**
+* Strip a ```json / ``` code fence if the model emitted one.
+* Idempotent for naked JSON. Some models (claude-code via router, certain
+* deepseek models) wrap output even under json_object.
+*/
+function stripFencedJson(raw) {
+	const trimmed = raw.trim();
+	const m = trimmed.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?```\s*$/);
+	return m ? m[1].trim() : trimmed;
+}
+function extractJsonPayload(raw) {
+	const stripped = stripFencedJson(raw);
+	try {
+		JSON.parse(stripped);
+		return stripped;
+	} catch {
+		if (stripped.startsWith("{") || stripped.startsWith("[")) return stripped;
+	}
+	const starts = [...stripped.matchAll(/[[{]/g)].map((match) => match.index).filter((index) => index != null);
+	for (const start of starts) {
+		const candidate = extractBalancedJson(stripped, start);
+		if (!candidate) continue;
+		try {
+			JSON.parse(candidate);
+			return candidate;
+		} catch {}
+	}
+	return stripped;
+}
+function extractBalancedJson(input, start) {
+	const opener = input[start];
+	const closer = opener === "{" ? "}" : opener === "[" ? "]" : null;
+	if (!closer) return null;
+	const stack = [closer];
+	let isInString = false;
+	let isEscaped = false;
+	for (let i = start + 1; i < input.length; i++) {
+		const char = input[i];
+		if (isEscaped) {
+			isEscaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			isEscaped = isInString;
+			continue;
+		}
+		if (char === "\"") {
+			isInString = !isInString;
+			continue;
+		}
+		if (isInString) continue;
+		if (char === "{") stack.push("}");
+		else if (char === "[") stack.push("]");
+		else if (char === stack[stack.length - 1]) {
+			stack.pop();
+			if (stack.length === 0) return input.slice(start, i + 1);
+		}
+	}
+	return null;
+}
+/**
+* Low-level call. Returns raw content + usage + cost. Retries on transient
+* failures; does NOT degrade schema here — callers that want graceful
+* degrade use `callLlmJson`.
+*/
+async function callLlm(req, opts = {}) {
+	const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+	const url = `${baseUrl}/chat/completions`;
+	const endpoint = "/chat/completions";
+	const timeoutMs = req.timeoutMs ?? opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const maximumAttempts = resolveMaximumAttempts(opts.maximumAttempts);
+	const fetchFn = opts.fetch ?? globalThis.fetch;
+	const headers = buildHeaders(opts);
+	const provider = opts.provider ?? providerFromBaseUrl(baseUrl);
+	const sink = opts.rawSink;
+	const redactor = opts.redactor ?? defaultProviderRedactor;
+	const traceContext = opts.traceContext;
+	const callerSignal = opts.signal;
+	const deadlineMs = opts.deadlineMs;
+	const deadlineStart = Date.now();
+	if (opts.customTokenPricing) costForTokenPricing(opts.customTokenPricing, {
+		inputTokens: 0,
+		outputTokens: 0
+	});
+	let lastErr;
+	let effectiveRequest = req;
+	for (let attempt = 0; attempt < maximumAttempts; attempt++) {
+		if (callerSignal?.aborted) throw new DOMException("callLlm aborted by caller signal", "AbortError");
+		if (attempt > 0 && deadlineExceeded(deadlineStart, deadlineMs)) throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+		const controller = new AbortController();
+		const attemptSignal = linkSignals(controller, callerSignal);
+		const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
+		const started = Date.now();
+		const requestBody = buildBody(effectiveRequest, opts.jsonSchemaTransport === "json-object", opts.thinking);
+		let attemptErrorRecorded = false;
+		if (sink) await recordRaw(sink, redactor, {
+			eventId: cryptoEventId(),
+			runId: traceContext?.runId,
+			spanId: traceContext?.spanId,
+			provider,
+			model: req.model,
+			endpoint,
+			baseUrl,
+			attemptIndex: attempt,
+			direction: "request",
+			timestamp: started,
+			requestHeaders: headers,
+			requestBody,
+			redactedFields: []
+		});
+		try {
+			const res = await fetchFn(url, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(requestBody),
+				signal: attemptSignal
+			});
+			clearTimeout(timeoutHandle);
+			const responseHeaders = sink ? headersToObject(res.headers) : void 0;
+			if (!res.ok) {
+				const body = await res.text();
+				if (sink) {
+					await recordRaw(sink, redactor, {
+						eventId: cryptoEventId(),
+						runId: traceContext?.runId,
+						spanId: traceContext?.spanId,
+						provider,
+						model: req.model,
+						endpoint,
+						baseUrl,
+						attemptIndex: attempt,
+						direction: "error",
+						timestamp: Date.now(),
+						durationMs: Date.now() - started,
+						statusCode: res.status,
+						responseHeaders,
+						responseBody: body,
+						errorMessage: `HTTP ${res.status}`,
+						redactedFields: []
+					});
+					attemptErrorRecorded = true;
+				}
+				const err = new LlmCallError(`LLM call ${res.status}: ${body.slice(0, 300)}`, res.status, body, req.model);
+				if (isTemperatureOneRejection(res.status, body) && effectiveRequest.temperature !== 1 && attempt < maximumAttempts - 1 && !deadlineExceeded(deadlineStart, deadlineMs)) {
+					lastErr = err;
+					effectiveRequest = {
+						...effectiveRequest,
+						temperature: 1
+					};
+					continue;
+				}
+				if (RETRYABLE_STATUS.has(res.status) && attempt < maximumAttempts - 1 && !deadlineExceeded(deadlineStart, deadlineMs)) {
+					lastErr = err;
+					await sleep(parseRetryAfter(res.headers) ?? backoffMs(attempt));
+					continue;
+				}
+				throw err;
+			}
+			const text = await res.text();
+			let json;
+			try {
+				json = JSON.parse(text);
+			} catch (parseErr) {
+				if (sink) {
+					await recordRaw(sink, redactor, {
+						eventId: cryptoEventId(),
+						runId: traceContext?.runId,
+						spanId: traceContext?.spanId,
+						provider,
+						model: req.model,
+						endpoint,
+						baseUrl,
+						attemptIndex: attempt,
+						direction: "error",
+						timestamp: Date.now(),
+						durationMs: Date.now() - started,
+						statusCode: res.status,
+						responseHeaders,
+						responseBody: text,
+						errorMessage: `non-JSON response: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`,
+						redactedFields: []
+					});
+					attemptErrorRecorded = true;
+				}
+				throw parseErr;
+			}
+			if (sink) await recordRaw(sink, redactor, {
+				eventId: cryptoEventId(),
+				runId: traceContext?.runId,
+				spanId: traceContext?.spanId,
+				provider,
+				model: req.model,
+				endpoint,
+				baseUrl,
+				attemptIndex: attempt,
+				direction: "response",
+				timestamp: Date.now(),
+				durationMs: Date.now() - started,
+				statusCode: res.status,
+				responseHeaders,
+				responseBody: json,
+				redactedFields: []
+			});
+			const choice = json.choices?.[0];
+			const usageRaw = json.usage && typeof json.usage === "object" && !Array.isArray(json.usage) ? json.usage : void 0;
+			const promptTokens = providerTokenCount(usageRaw?.prompt_tokens);
+			const completionTokens = providerTokenCount(usageRaw?.completion_tokens);
+			const totalTokens = providerTokenCount(usageRaw?.total_tokens);
+			const reasoningRaw = (usageRaw?.completion_tokens_details && typeof usageRaw.completion_tokens_details === "object" && !Array.isArray(usageRaw.completion_tokens_details) ? usageRaw.completion_tokens_details : void 0)?.reasoning_tokens;
+			const reasoningTokens = reasoningRaw === void 0 ? void 0 : providerTokenCount(reasoningRaw);
+			const cachedRaw = usageRaw?.prompt_tokens_details && typeof usageRaw.prompt_tokens_details === "object" && !Array.isArray(usageRaw.prompt_tokens_details) ? usageRaw.prompt_tokens_details.cached_tokens : void 0;
+			const cachedPromptTokens = cachedRaw === void 0 ? void 0 : providerTokenCount(cachedRaw);
+			const usageCaptured = promptTokens !== void 0 && completionTokens !== void 0 && (reasoningRaw === void 0 || reasoningTokens !== void 0 && reasoningTokens <= completionTokens) && (cachedRaw === void 0 || cachedPromptTokens !== void 0 && cachedPromptTokens <= promptTokens) && (totalTokens === void 0 || totalTokens === promptTokens + completionTokens);
+			const costFromProxy = json._response_cost ?? json.cost_usd;
+			const content = choice?.message?.content ?? "";
+			const configuredCost = typeof costFromProxy !== "number" && usageCaptured && opts.customTokenPricing ? costForTokenPricing(opts.customTokenPricing, {
+				inputTokens: promptTokens - (cachedPromptTokens ?? 0),
+				...cachedPromptTokens ? { cachedTokens: cachedPromptTokens } : {},
+				outputTokens: completionTokens
+			}) : void 0;
+			return {
+				content,
+				finishReason: choice?.finish_reason ?? null,
+				contentEmpty: content.trim().length === 0,
+				usage: {
+					promptTokens: promptTokens ?? 0,
+					completionTokens: completionTokens ?? 0,
+					totalTokens: totalTokens ?? (promptTokens ?? 0) + (completionTokens ?? 0),
+					captured: usageCaptured,
+					reasoningTokens,
+					cachedPromptTokens
+				},
+				costUsd: typeof costFromProxy === "number" ? costFromProxy : configuredCost ?? null,
+				model: json.model ?? req.model,
+				durationMs: Date.now() - started,
+				raw: json
+			};
+		} catch (err) {
+			clearTimeout(timeoutHandle);
+			lastErr = err;
+			if (callerSignal?.aborted) {
+				if (sink && !attemptErrorRecorded) await recordRaw(sink, redactor, {
+					eventId: cryptoEventId(),
+					runId: traceContext?.runId,
+					spanId: traceContext?.spanId,
+					provider,
+					model: req.model,
+					endpoint,
+					baseUrl,
+					attemptIndex: attempt,
+					direction: "error",
+					timestamp: Date.now(),
+					durationMs: Date.now() - started,
+					errorMessage: err instanceof Error ? err.message : String(err),
+					redactedFields: []
+				});
+				throw err;
+			}
+			if (sink && !attemptErrorRecorded) await recordRaw(sink, redactor, {
+				eventId: cryptoEventId(),
+				runId: traceContext?.runId,
+				spanId: traceContext?.spanId,
+				provider,
+				model: req.model,
+				endpoint,
+				baseUrl,
+				attemptIndex: attempt,
+				direction: "error",
+				timestamp: Date.now(),
+				durationMs: Date.now() - started,
+				errorMessage: err instanceof Error ? err.message : String(err),
+				redactedFields: []
+			});
+			if (attempt < maximumAttempts - 1 && isTransientLlmError(err) && !deadlineExceeded(deadlineStart, deadlineMs)) {
+				await sleep(backoffMs(attempt));
+				continue;
+			}
+			throw err;
+		}
+	}
+	throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
+async function recordRaw(sink, redactor, event) {
+	try {
+		await sink.record(redactor(event));
+	} catch {}
+}
+function headersToObject(h) {
+	const out = {};
+	h.forEach((value, key) => {
+		out[key] = value;
+	});
+	return out;
+}
+function cryptoEventId() {
+	if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/**
+* Structured-output call. Returns parsed JSON plus the raw result envelope.
+* Degrades `jsonSchema` → `jsonMode` on a 400 that names the schema param —
+* critical for deepseek-v3/v4, kimi-k2.6, and other models that don't accept
+* the `response_format.json_schema` shape but DO accept `json_object`.
+*/
+async function callLlmJson(req, opts = {}) {
+	const result = await callLlmStructured(req, opts);
+	return {
+		value: parseJsonResult(result, opts.jsonPayloadMode ?? "extract"),
+		result
+	};
+}
+/** Shared schema-to-JSON-mode fallback that preserves the raw result. */
+async function callLlmStructured(req, opts = {}) {
+	try {
+		return await callLlm({
+			...req,
+			jsonMode: req.jsonMode ?? !req.jsonSchema
+		}, opts);
+	} catch (err) {
+		if (opts.jsonSchemaTransport !== "json-object" && err instanceof LlmCallError && isSchemaRejection(err.status, err.body) && req.jsonSchema) return await callLlm({
+			...req,
+			jsonMode: true,
+			jsonSchema: void 0
+		}, opts);
+		throw err;
+	}
+}
+function parseJsonResult(result, jsonPayloadMode) {
+	try {
+		if (result.finishReason === "length") throw new Error(`LLM returned truncated JSON content (model=${result.model}, finishReason=length)`);
+		return parseJsonSafely(result.content, result.model, jsonPayloadMode);
+	} catch (error) {
+		if (error instanceof LlmResponseError) throw error;
+		const cause = error instanceof Error ? error : new Error(String(error));
+		throw new LlmResponseError(cause.message, result, { cause });
+	}
+}
+function parseJsonSafely(content, model, jsonPayloadMode) {
+	const payload = jsonPayloadMode === "exact" ? content : extractJsonPayload(content);
+	try {
+		return JSON.parse(payload);
+	} catch (err) {
+		throw new Error(`LLM returned non-JSON content (model=${model}): ${err instanceof Error ? err.message : String(err)}\n--- raw content ---\n${content.slice(0, 800)}`);
+	}
+}
+var LlmRouteAssertionError = class extends CaptureIntegrityError {
+	reason;
+	baseUrl;
+	constructor(message, reason, baseUrl) {
+		super(message);
+		this.reason = reason;
+		this.baseUrl = baseUrl;
+	}
+};
+/**
+* Fail-loud assertion that the configured LLM client points at the route
+* the caller intends. Designed for the matrix-runner preflight: invoke
+* once before any LLM call to catch misconfiguration before a sweep burns
+* dollars on the wrong provider.
+*
+* Throws `LlmRouteAssertionError`. Pure — no I/O — so it's safe to call
+* from constructors and CI gates.
+*/
+function assertLlmRoute(opts, req = {}) {
+	const baseUrlExplicit = opts.baseUrl !== void 0;
+	const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+	if (req.requireExplicitBaseUrl && !baseUrlExplicit) throw new LlmRouteAssertionError(`assertLlmRoute: requireExplicitBaseUrl set but opts.baseUrl is undefined; would fall back to ${DEFAULT_BASE_URL}.`, "no_explicit_base_url", baseUrl);
+	if (req.blockedBaseUrls?.some((p) => matchUrl(baseUrl, p))) throw new LlmRouteAssertionError(`assertLlmRoute: baseUrl ${baseUrl} matches a blocked pattern.`, "base_url_blocked", baseUrl);
+	if (req.allowedBaseUrls && req.allowedBaseUrls.length > 0) {
+		if (!req.allowedBaseUrls.some((p) => matchUrl(baseUrl, p))) throw new LlmRouteAssertionError(`assertLlmRoute: baseUrl ${baseUrl} is not in the allowed list (${req.allowedBaseUrls.map(describePattern).join(", ")}).`, "base_url_not_allowed", baseUrl);
+	}
+	if (req.requireAuth && !opts.apiKey && !opts.bearer && !opts.authHeader) throw new LlmRouteAssertionError(`assertLlmRoute: requireAuth set but no apiKey, bearer, or authHeader was supplied.`, "no_auth", baseUrl);
+	if (req.expectedProvider) {
+		const actual = opts.provider ?? providerFromBaseUrl(baseUrl);
+		if (actual !== req.expectedProvider) throw new LlmRouteAssertionError(`assertLlmRoute: expected provider ${req.expectedProvider} but baseUrl ${baseUrl} resolves to ${actual}.`, "wrong_provider", baseUrl);
+	}
+}
+function matchUrl(url, pattern) {
+	if (pattern instanceof RegExp) return pattern.test(url);
+	return url.toLowerCase().startsWith(pattern.toLowerCase());
+}
+function describePattern(p) {
+	return p instanceof RegExp ? p.source : p;
+}
+/**
+* Probe whether a model is reachable. Returns latency + null error on
+* success; `ok=false` + error message on any failure (HTTP, timeout,
+* network, parse). Designed for sweep preflights — fail loud at the
+* boundary before burning a 30-leaf run on a misconfigured router.
+*
+* Sends a tiny `ping` message with `maxTokens=64`. Reasoning models
+* (glm-5.1, deepseek-v4) can burn the entire budget on internal reasoning
+* for short prompts, so don't tighten this further. We don't validate
+* content; HTTP 200 means reachable.
+*/
+async function probeLlm(model, opts = {}) {
+	const start = Date.now();
+	try {
+		await callLlm({
+			model,
+			messages: [{
+				role: "user",
+				content: "ping"
+			}],
+			maxTokens: 64,
+			timeoutMs: opts.timeoutMs ?? 3e4
+		}, opts);
+		return {
+			ok: true,
+			latencyMs: Date.now() - start,
+			error: null
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			latencyMs: Date.now() - start,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+/**
+* Stateful client — construct once with defaults, call many times.
+* Thin wrapper around the free functions; exists for callers that want
+* to inject a single configured instance into multiple primitives.
+*/
+var LlmClient = class {
+	maximumAttempts;
+	opts;
+	constructor(opts = {}) {
+		this.opts = opts;
+		this.maximumAttempts = resolveMaximumAttempts(opts.maximumAttempts);
+	}
+	call(req, per) {
+		const options = {
+			...this.opts,
+			...per
+		};
+		return req.jsonSchema ? callLlmStructured(req, options) : callLlm(req, options);
+	}
+	callJson(req, per) {
+		return callLlmJson(req, {
+			...this.opts,
+			...per
+		});
+	}
+};
+//#endregion
+export { assertLlmRoute as a, callLlmJson as c, isTransientLlmError as d, maximumChargeForLlmRequest as f, LlmRouteAssertionError as i, costReceiptFromLlm as l, stripFencedJson as m, LlmClient as n, backoffMs as o, probeLlm as p, LlmResponseError as r, callLlm as s, LlmCallError as t, costReceiptFromLlmError as u };
+
+//# sourceMappingURL=llm-client--GR4JbZE.js.map