@tangle-network/agent-eval 0.216.1 → 0.218.1

package/dist/{llm-client-CyBAoYiX.js → llm-client-_Y6ic-tf.js}

@@ -1,110 +1,8 @@
-import { t as AgentEvalError } from "./errors-DVZiqS7K.js";
-import { c as costForTokenPricing } from "./cost-ledger-BP8V4kUQ.js";
+import { t as AgentEvalError } from "./errors-BcOs5MKW.js";
+import { c as costForTokenPricing } from "./cost-ledger-D0352Z4d.js";
+import { a as LlmCallError, o as LlmResponseError, r as parseJsonResult } from "./json-BhdsJaOQ.js";
+import { a as providerFromBaseUrl, i as defaultProviderRedactor } from "./raw-provider-sink-75w4FWBj.js";
 import { t as newRecordId } from "./record-id-DUgsK5qp.js";
-import { a as providerFromBaseUrl, i as defaultProviderRedactor } from "./raw-provider-sink-DoHz4JNG.js";
-//#region src/llm-client/errors.ts
-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;
-	}
-};
-//#endregion
-//#region src/llm-client/json.ts
-/**
-* 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;
-}
-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 {
-		throw new Error(`LLM returned non-JSON content (model=${model})`);
-	}
-}
-//#endregion
 //#region src/abort-signal.ts
 /** Combine active cancellation sources without wrapping a single source. */
 function combineAbortSignals(...signals) {
@@ -690,269 +588,259 @@ function costReceiptFromLlmError(error, customTokenPricing) {
 async function callLlm(req, opts = {}) {
 	return callLlmAttempts(req, opts, false);
 }
-/** One retry owner for raw and structured calls. Fallback changes the next
-* request, not the attempt allowance, deadline origin, or raw-event sequence. */
-async function callLlmAttempts(req, opts, allowSchemaFallback) {
+const ENDPOINT = "/chat/completions";
+function startAttemptRun(req, opts, allowSchemaFallback) {
 	if (!opts.baseUrl) throw new Error("callLlm: opts.baseUrl is required");
 	const baseUrl = opts.baseUrl.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 minIntervalMs = resolveMinIntervalMs(opts.minIntervalMs);
-	const pacing = pacingStateFor(opts);
-	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();
+	const remainingMs = () => deadlineMs === void 0 ? Infinity : Math.max(0, deadlineMs - (Date.now() - deadlineStart));
+	const run = {
+		req,
+		opts,
+		allowSchemaFallback,
+		baseUrl,
+		url: `${baseUrl}${ENDPOINT}`,
+		timeoutMs: req.timeoutMs ?? opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS,
+		maximumAttempts: resolveMaximumAttempts(opts.maximumAttempts),
+		minIntervalMs: resolveMinIntervalMs(opts.minIntervalMs),
+		pacing: pacingStateFor(opts),
+		headers: buildHeaders(opts),
+		provider: opts.provider ?? providerFromBaseUrl(baseUrl),
+		deadlineStart,
+		remainingMs,
+		retryDelay: (ms) => sleep(Math.min(ms, remainingMs()), opts.signal),
+		effectiveRequest: req,
+		lastErr: void 0
+	};
 	if (opts.customTokenPricing) costForTokenPricing(opts.customTokenPricing, {
 		inputTokens: 0,
 		outputTokens: 0
 	});
-	let lastErr;
-	let effectiveRequest = req;
-	const remainingMs = () => deadlineMs === void 0 ? Infinity : Math.max(0, deadlineMs - (Date.now() - deadlineStart));
-	const retryDelay = (ms) => sleep(Math.min(ms, remainingMs()), callerSignal);
-	for (let attempt = 0; attempt < maximumAttempts; attempt++) {
-		if (callerSignal?.aborted) throw new DOMException("callLlm aborted by caller signal", "AbortError");
-		if (deadlineExceeded(deadlineStart, deadlineMs)) throw lastErr instanceof Error ? lastErr : new DOMException("callLlm deadline exceeded", "TimeoutError");
-		const requestBody = buildBody(effectiveRequest, opts.jsonSchemaTransport === "json-object", opts.thinking);
-		const controller = new AbortController();
-		const attemptSignal = combineAbortSignals(controller.signal, callerSignal);
-		let timeoutHandle;
-		let started = Date.now();
-		let dispatched = false;
-		let attemptErrorRecorded = false;
-		try {
-			if (minIntervalMs > 0) {
-				while (true) {
-					callerSignal?.throwIfAborted();
-					if (deadlineExceeded(deadlineStart, deadlineMs)) throw lastErr instanceof Error ? lastErr : new DOMException("callLlm deadline exceeded", "TimeoutError");
-					const waitMs = pacing.lastStartedAt === void 0 ? 0 : pacing.lastStartedAt + minIntervalMs - Date.now();
-					if (waitMs <= 0) break;
-					await retryDelay(waitMs);
-				}
-				started = Date.now();
-			}
+	return run;
+}
+function deadlineError(run) {
+	return run.lastErr instanceof Error ? run.lastErr : new DOMException("callLlm deadline exceeded", "TimeoutError");
+}
+/** Write one raw provider event for this attempt. Does nothing without a sink. */
+async function recordAttemptEvent(run, attempt, fields) {
+	const { opts } = run;
+	if (!opts.rawSink) return;
+	await recordRaw(opts.rawSink, opts.redactor ?? defaultProviderRedactor, {
+		eventId: newRecordId(),
+		runId: opts.traceContext?.runId,
+		spanId: opts.traceContext?.spanId,
+		provider: run.provider,
+		model: run.req.model,
+		endpoint: ENDPOINT,
+		baseUrl: run.baseUrl,
+		attemptIndex: attempt,
+		...fields,
+		redactedFields: []
+	});
+}
+/**
+* Wait for this client's pacing slot, and claim it. Every wake rechecks, so concurrent waiters
+* cannot dispatch a catch-up burst; the claim is made in the same synchronous step that finds the
+* slot free, so no other waiter can slip in between the check and the claim.
+*/
+async function awaitPacingSlot(run) {
+	const { opts, pacing, minIntervalMs } = run;
+	while (true) {
+		opts.signal?.throwIfAborted();
+		if (deadlineExceeded(run.deadlineStart, opts.deadlineMs)) throw deadlineError(run);
+		const waitMs = pacing.lastStartedAt === void 0 ? 0 : pacing.lastStartedAt + minIntervalMs - Date.now();
+		if (waitMs <= 0) {
+			const started = Date.now();
 			pacing.lastStartedAt = started;
-			dispatched = true;
-			timeoutHandle = setTimeout(() => controller.abort(), Math.min(timeoutMs, remainingMs()));
-			if (sink) await recordRaw(sink, redactor, {
-				eventId: newRecordId(),
-				runId: traceContext?.runId,
-				spanId: traceContext?.spanId,
-				provider,
-				model: req.model,
-				endpoint,
-				baseUrl,
-				attemptIndex: attempt,
-				direction: "request",
-				timestamp: started,
-				requestHeaders: headers,
-				requestBody,
-				redactedFields: []
-			});
-			attemptSignal.throwIfAborted();
-			const res = await fetchFn(url, {
-				method: "POST",
-				headers,
-				body: JSON.stringify(requestBody),
-				signal: attemptSignal
-			});
-			const responseHeaders = sink ? headersToObject(res.headers) : void 0;
-			const text = await res.text();
-			attemptSignal.throwIfAborted();
-			clearTimeout(timeoutHandle);
-			if (!res.ok) {
-				const body = text;
-				if (sink) {
-					await recordRaw(sink, redactor, {
-						eventId: newRecordId(),
-						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 failed with HTTP ${res.status}`, 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 (allowSchemaFallback && opts.jsonSchemaTransport !== "json-object" && effectiveRequest.jsonSchema && isSchemaRejection(res.status, body) && attempt < maximumAttempts - 1 && !deadlineExceeded(deadlineStart, deadlineMs)) {
-					lastErr = err;
-					effectiveRequest = {
-						...effectiveRequest,
-						jsonMode: true,
-						jsonSchema: void 0
-					};
-					continue;
-				}
-				if (RETRYABLE_STATUS.has(res.status) && attempt < maximumAttempts - 1 && !deadlineExceeded(deadlineStart, deadlineMs)) {
-					lastErr = err;
-					const wait = parseRetryAfter(res.headers) ?? backoffMs(attempt);
-					if (wait >= remainingMs()) {
-						callerSignal?.throwIfAborted();
-						break;
-					}
-					await retryDelay(wait);
-					continue;
-				}
-				throw err;
-			}
-			let json;
-			try {
-				json = JSON.parse(text);
-			} catch (parseErr) {
-				if (sink) {
-					await recordRaw(sink, redactor, {
-						eventId: newRecordId(),
-						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: newRecordId(),
-				runId: traceContext?.runId,
-				spanId: traceContext?.spanId,
-				provider,
-				model: req.model,
-				endpoint,
-				baseUrl,
-				attemptIndex: attempt,
-				direction: "response",
+			return started;
+		}
+		await run.retryDelay(waitMs);
+	}
+}
+/** Answer a non-2xx response: retry with an adjusted request or after a wait, give up, or throw its error. */
+async function handleHttpFailure(run, attempt, res, body, responseHeaders, started, state) {
+	const { req, opts, maximumAttempts, deadlineStart } = run;
+	await recordAttemptEvent(run, attempt, {
+		direction: "error",
+		timestamp: Date.now(),
+		durationMs: Date.now() - started,
+		statusCode: res.status,
+		responseHeaders,
+		responseBody: body,
+		errorMessage: `HTTP ${res.status}`
+	});
+	if (opts.rawSink) state.errorRecorded = true;
+	const err = new LlmCallError(`LLM call failed with HTTP ${res.status}`, res.status, body, req.model);
+	const canRetry = attempt < maximumAttempts - 1 && !deadlineExceeded(deadlineStart, opts.deadlineMs);
+	if (isTemperatureOneRejection(res.status, body) && run.effectiveRequest.temperature !== 1 && canRetry) {
+		run.lastErr = err;
+		run.effectiveRequest = {
+			...run.effectiveRequest,
+			temperature: 1
+		};
+		return { kind: "retry" };
+	}
+	if (run.allowSchemaFallback && opts.jsonSchemaTransport !== "json-object" && run.effectiveRequest.jsonSchema && isSchemaRejection(res.status, body) && canRetry) {
+		run.lastErr = err;
+		run.effectiveRequest = {
+			...run.effectiveRequest,
+			jsonMode: true,
+			jsonSchema: void 0
+		};
+		return { kind: "retry" };
+	}
+	if (RETRYABLE_STATUS.has(res.status) && canRetry) {
+		run.lastErr = err;
+		const wait = parseRetryAfter(res.headers) ?? backoffMs(attempt);
+		if (wait >= run.remainingMs()) {
+			opts.signal?.throwIfAborted();
+			return { kind: "exhausted" };
+		}
+		await run.retryDelay(wait);
+		return { kind: "retry" };
+	}
+	throw err;
+}
+/** Turn a parsed completion into the call result: content, tool calls, usage with its completeness, and cost. */
+function parseCompletion(run, json, started) {
+	const { req, opts } = run;
+	const choice = json.choices?.[0];
+	const toolCalls = parseWireToolCalls(choice?.message?.tool_calls, req.model);
+	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 = providerReportedCost(json);
+	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;
+	const servedModel = typeof json.model === "string" && json.model.trim() !== "" ? json.model : null;
+	if (opts.assertServedModel) assertServedModel(req.model, servedModel, opts.assertServedModel === true ? {} : opts.assertServedModel);
+	return {
+		content,
+		...toolCalls === void 0 ? {} : { toolCalls },
+		...req.logprobs === void 0 ? {} : { logprobs: parseWireLogprobs(choice?.logprobs?.content, req.model) },
+		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: servedModel ?? req.model,
+		servedModel,
+		durationMs: Date.now() - started,
+		raw: json
+	};
+}
+/** One attempt: pace, dispatch, read the answer. A failure either becomes a retry outcome or is thrown. */
+async function runAttempt(run, attempt) {
+	const { opts } = run;
+	const callerSignal = opts.signal;
+	if (callerSignal?.aborted) throw new DOMException("callLlm aborted by caller signal", "AbortError");
+	if (deadlineExceeded(run.deadlineStart, opts.deadlineMs)) throw deadlineError(run);
+	const requestBody = buildBody(run.effectiveRequest, opts.jsonSchemaTransport === "json-object", opts.thinking);
+	const controller = new AbortController();
+	const attemptSignal = combineAbortSignals(controller.signal, callerSignal);
+	let timeoutHandle;
+	let started = Date.now();
+	const state = {
+		dispatched: false,
+		errorRecorded: false
+	};
+	try {
+		if (run.minIntervalMs > 0) started = await awaitPacingSlot(run);
+		else run.pacing.lastStartedAt = started;
+		state.dispatched = true;
+		timeoutHandle = setTimeout(() => controller.abort(), Math.min(run.timeoutMs, run.remainingMs()));
+		await recordAttemptEvent(run, attempt, {
+			direction: "request",
+			timestamp: started,
+			requestHeaders: run.headers,
+			requestBody
+		});
+		attemptSignal.throwIfAborted();
+		const res = await (opts.fetch ?? globalThis.fetch)(run.url, {
+			method: "POST",
+			headers: run.headers,
+			body: JSON.stringify(requestBody),
+			signal: attemptSignal
+		});
+		const responseHeaders = opts.rawSink ? headersToObject(res.headers) : void 0;
+		const text = await res.text();
+		attemptSignal.throwIfAborted();
+		clearTimeout(timeoutHandle);
+		if (!res.ok) return await handleHttpFailure(run, attempt, res, text, responseHeaders, started, state);
+		let json;
+		try {
+			json = JSON.parse(text);
+		} catch (parseErr) {
+			await recordAttemptEvent(run, attempt, {
+				direction: "error",
 				timestamp: Date.now(),
 				durationMs: Date.now() - started,
 				statusCode: res.status,
 				responseHeaders,
-				responseBody: json,
-				redactedFields: []
-			});
-			const choice = json.choices?.[0];
-			const toolCalls = parseWireToolCalls(choice?.message?.tool_calls, req.model);
-			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 = providerReportedCost(json);
-			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;
-			const servedModel = typeof json.model === "string" && json.model.trim() !== "" ? json.model : null;
-			if (opts.assertServedModel) assertServedModel(req.model, servedModel, opts.assertServedModel === true ? {} : opts.assertServedModel);
-			return {
-				content,
-				...toolCalls === void 0 ? {} : { toolCalls },
-				...req.logprobs === void 0 ? {} : { logprobs: parseWireLogprobs(choice?.logprobs?.content, req.model) },
-				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: servedModel ?? req.model,
-				servedModel,
-				durationMs: Date.now() - started,
-				raw: json
-			};
-		} catch (err) {
-			clearTimeout(timeoutHandle);
-			lastErr = err;
-			if (callerSignal?.aborted) {
-				if (sink && dispatched && !attemptErrorRecorded) await recordRaw(sink, redactor, {
-					eventId: newRecordId(),
-					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 && dispatched && !attemptErrorRecorded) await recordRaw(sink, redactor, {
-				eventId: newRecordId(),
-				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: []
+				responseBody: text,
+				errorMessage: `non-JSON response: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`
 			});
-			const wait = backoffMs(attempt);
-			if (attempt < maximumAttempts - 1 && isTransientLlmError(err) && !deadlineExceeded(deadlineStart, deadlineMs) && wait < remainingMs()) {
-				await retryDelay(wait);
-				continue;
-			}
-			callerSignal?.throwIfAborted();
-			throw err;
-		} finally {
-			clearTimeout(timeoutHandle);
+			if (opts.rawSink) state.errorRecorded = true;
+			throw parseErr;
 		}
+		await recordAttemptEvent(run, attempt, {
+			direction: "response",
+			timestamp: Date.now(),
+			durationMs: Date.now() - started,
+			statusCode: res.status,
+			responseHeaders,
+			responseBody: json
+		});
+		return {
+			kind: "result",
+			result: parseCompletion(run, json, started)
+		};
+	} catch (err) {
+		clearTimeout(timeoutHandle);
+		run.lastErr = err;
+		if (state.dispatched && !state.errorRecorded) await recordAttemptEvent(run, attempt, {
+			direction: "error",
+			timestamp: Date.now(),
+			durationMs: Date.now() - started,
+			errorMessage: err instanceof Error ? err.message : String(err)
+		});
+		if (callerSignal?.aborted) throw err;
+		const wait = backoffMs(attempt);
+		if (attempt < run.maximumAttempts - 1 && isTransientLlmError(err) && !deadlineExceeded(run.deadlineStart, opts.deadlineMs) && wait < run.remainingMs()) {
+			await run.retryDelay(wait);
+			return { kind: "retry" };
+		}
+		callerSignal?.throwIfAborted();
+		throw err;
+	} finally {
+		clearTimeout(timeoutHandle);
+	}
+}
+async function callLlmAttempts(req, opts, allowSchemaFallback) {
+	const run = startAttemptRun(req, opts, allowSchemaFallback);
+	for (let attempt = 0; attempt < run.maximumAttempts; attempt++) {
+		const outcome = await runAttempt(run, attempt);
+		if (outcome.kind === "result") return outcome.result;
+		if (outcome.kind === "exhausted") break;
 	}
-	throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+	throw run.lastErr instanceof Error ? run.lastErr : new Error(String(run.lastErr));
 }
 async function recordRaw(sink, redactor, event) {
 	try {
@@ -1018,6 +906,6 @@ var LlmClient = class {
 	}
 };
 //#endregion
-export { LlmResponseError as C, LlmCallError as S, assertCrossFamily as _, maximumChargeForLlmRequest as a, extractJsonPayload as b, ModelSubstitutionError as c, assertServedModel as d, assertServedModelPolicy as f, CrossFamilyError as g, servedModelAcceptable as h, costReceiptFromLlmError as i, ServedCrossFamilyError as l, checkServedModel as m, callLlmJson as n, backoffMs as o, assertServedModels as p, costReceiptFromLlm as r, isTransientLlmError as s, LlmClient as t, assertCrossFamilyServed as u, judgeFamily as v, stripFencedJson as x, combineAbortSignals as y };
+export { combineAbortSignals as _, maximumChargeForLlmRequest as a, ModelSubstitutionError as c, assertServedModelPolicy as d, assertServedModels as f, judgeFamily as g, assertCrossFamily as h, costReceiptFromLlmError as i, assertCrossFamilyServed as l, CrossFamilyError as m, callLlmJson as n, backoffMs as o, checkServedModel as p, costReceiptFromLlm as r, isTransientLlmError as s, LlmClient as t, assertServedModel as u };
 
-//# sourceMappingURL=llm-client-CyBAoYiX.js.map
+//# sourceMappingURL=llm-client-_Y6ic-tf.js.map