@tangle-network/agent-eval 0.217.1 → 0.218.1

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

@@ -588,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: []
+				responseBody: text,
+				errorMessage: `non-JSON response: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`
 			});
-			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: []
-			});
-			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 {
@@ -918,4 +908,4 @@ var LlmClient = class {
 //#endregion
 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-BshCREn6.js.map
+//# sourceMappingURL=llm-client-_Y6ic-tf.js.map