@snoai/memory 0.0.0-stage → 1.0.0

package/dist/llm-client-B7Xoxqou.js

@@ -0,0 +1,1378 @@
+import { ct as FIXED_PROTOCOL_VALUE_69, d as FIXED_EXTERNAL_VALUE_8, f as FIXED_EXTERNAL_VALUE_9 } from "./signed-registry-constants-yq3DlG3B.js";
+import { i as memoryOperationSignal, r as memoryOperationId, t as checkMemoryOperation } from "./operation-cancellation-CTKWwNHk.js";
+import { t as MODEL_CALLS } from "./model-call-table-CspopkBg.js";
+import { classifyLlmFailure, isCredentialFailure, isTransientLlmStatus } from "./internal/model/llm-failure.js";
+import { a as repairCommonJson, i as previewText, n as readModelReplyJson, r as extractJsonFromResponse } from "./model-reply-text-CKopStP2.js";
+import { resolveLlmRoute } from "./internal/model/llm-mode-routing.js";
+import { countTokens } from "@snoai/chunking";
+import { createLogger, withLogContext } from "@snoai/utils/logger";
+import path from "node:path";
+import { createHash, createPublicKey, randomUUID, verify } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync } from "node:fs";
+import { CallPipeline, ConfigRegistryManager, KeyPool, loadLlmixTrustManifest, registryRootOptionsFromTrustManifest } from "@snoai/llmix";
+import { Buffer } from "node:buffer";
+import { fileURLToPath } from "node:url";
+//#region src/model/llmix-registry.ts
+/** @file llmix-registry.ts
+* @purpose Loads the bundled signed LLMIx registry for sno-station-mem.
+* @boundary Trust-anchor verification and package-relative asset resolution only.
+*/
+const SNO_STATION_MEM_RELEASE_ANCHOR_URL = FIXED_EXTERNAL_VALUE_8;
+const SNO_STATION_MEM_RELEASE_KEY_ID = FIXED_EXTERNAL_VALUE_9;
+const SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS = 2;
+const SNO_STATION_MEM_RELEASE_ANCHOR_RETRY_DELAY_MS = 50;
+const ALLOWED_HTTP_ENDPOINT_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"100.100.200.71"
+]);
+function parsePresetId(preset) {
+	const [module, presetName] = preset.split("/");
+	if (!module || !presetName) throw new Error(`sno-station-mem llm-client: invalid LLMIx preset id "${preset}"`);
+	return {
+		module,
+		preset: presetName
+	};
+}
+function assertSupportedProvider(provider) {
+	if (provider === "openai" || provider === "openrouter" || provider === "sno-gpu") return provider;
+	throw new Error(`sno-station-mem llm-client: unsupported LLMIx provider "${provider}"`);
+}
+function resolveEndpointBase(baseSource, preservePath) {
+	let parsed;
+	try {
+		parsed = new URL(baseSource);
+	} catch {
+		throw new Error(`sno-station-mem llm-client: invalid extraction.llm.baseURL "${baseSource}"`);
+	}
+	if (parsed.protocol !== "https:" && !ALLOWED_HTTP_ENDPOINT_HOSTS.has(parsed.hostname)) throw new Error("sno-station-mem llm-client: extraction.llm.baseURL must use https");
+	if (parsed.protocol === "https:" && parsed.hostname.toLowerCase() === "api.openai.com") throw new Error("sno-station-mem llm-client: direct api.openai.com transport is forbidden; use local ccproxy or an explicit custom endpoint");
+	if (!preservePath) return parsed.origin;
+	const base = parsed.toString();
+	return base.endsWith("/") ? base : `${base}/`;
+}
+function packageRootFromImportMeta() {
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	const bundledRoot = path.resolve(moduleDir, "..");
+	return [bundledRoot, path.resolve(moduleDir, "../..")].find(hasBundledRegistryAssets) ?? bundledRoot;
+}
+function hasBundledRegistryAssets(packageRoot) {
+	return existsSync(path.join(packageRoot, "config", "llm", "current.json")) && existsSync(path.join(packageRoot, "config", "llm.trust.json"));
+}
+function resolveBundledLlmixRegistryPaths(packageRoot = packageRootFromImportMeta()) {
+	const registryDir = path.join(packageRoot, "config", "llm");
+	const trustManifestPath = path.join(packageRoot, "config", "llm.trust.json");
+	if (!hasBundledRegistryAssets(packageRoot)) throw new Error("sno-station-mem LLMIx registry assets are missing from the installed package");
+	return {
+		registryDir,
+		trustManifestPath
+	};
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPublicKeyJwk(document) {
+	if (!isJsonObject(document) || document.id !== "did:web:www.sno.ai") return null;
+	const methods = document.verificationMethod;
+	if (!Array.isArray(methods)) return null;
+	for (const method of methods) {
+		if (!isJsonObject(method) || method.id !== SNO_STATION_MEM_RELEASE_KEY_ID) continue;
+		const jwk = method.publicKeyJwk;
+		if (isJsonObject(jwk) && jwk.kty === "OKP" && jwk.crv === "Ed25519" && typeof jwk.x === "string") return jwk;
+	}
+	return null;
+}
+function verifyEd25519(jwk, paeBytes, signature) {
+	const publicKey = createPublicKey({
+		key: jwk,
+		format: "jwk"
+	});
+	return verify(null, Buffer.from(paeBytes), publicKey, Buffer.from(signature, "base64"));
+}
+function releaseAnchorFailureMessage(error) {
+	if (!isJsonObject(error) || !isJsonObject(error.details)) return null;
+	const cause = error.details.cause;
+	if (typeof cause !== "string") return null;
+	return cause.includes("sno-station-mem LLMIx release anchor fetch") ? cause : null;
+}
+async function fetchReleaseAnchorOnce(fetchImpl, timeoutMs) {
+	const controller = new AbortController();
+	let timeout;
+	const timeoutPromise = new Promise((_resolve, reject) => {
+		timeout = setTimeout(() => {
+			controller.abort();
+			reject(/* @__PURE__ */ new Error(`sno-station-mem LLMIx release anchor fetch timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([fetchImpl(SNO_STATION_MEM_RELEASE_ANCHOR_URL, { signal: controller.signal }), timeoutPromise]);
+	} finally {
+		if (timeout !== void 0) clearTimeout(timeout);
+	}
+}
+function isTransientAnchorResponse(response) {
+	return isTransientLlmStatus(response.status);
+}
+async function fetchReleaseAnchor(fetchImpl, timeoutMs) {
+	for (let attempt = 1; attempt <= SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS; attempt++) {
+		try {
+			const response = await fetchReleaseAnchorOnce(fetchImpl, timeoutMs);
+			if (attempt === SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS || !isTransientAnchorResponse(response)) return response;
+		} catch (error) {
+			if (attempt === SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS) throw error;
+		}
+		await new Promise((resolve) => setTimeout(resolve, SNO_STATION_MEM_RELEASE_ANCHOR_RETRY_DELAY_MS));
+	}
+	throw new Error("sno-station-mem LLMIx release anchor fetch exhausted");
+}
+function createSnoMemSnoStationMemDidWebVerifier(fetchImpl = globalThis.fetch, options = {}) {
+	const anchorTimeoutMs = options.anchorTimeoutMs ?? 5e3;
+	return { async verify(input) {
+		if (input.domain !== "www.sno.ai" || input.keyId !== SNO_STATION_MEM_RELEASE_KEY_ID) return false;
+		if (input.algorithm !== "ed25519") return false;
+		const response = await fetchReleaseAnchor(fetchImpl, anchorTimeoutMs);
+		if (!response.ok) return false;
+		const jwk = readPublicKeyJwk(await response.json());
+		if (jwk === null) return false;
+		return verifyEd25519(jwk, input.paeBytes, input.signature);
+	} };
+}
+async function openBundledLlmixRegistry(packageRoot, fetchImpl = globalThis.fetch, options = {}) {
+	const paths = resolveBundledLlmixRegistryPaths(packageRoot);
+	const trustManifest = await loadLlmixTrustManifest(paths.trustManifestPath);
+	const signedRoot = registryRootOptionsFromTrustManifest(trustManifest, { didWebVerifier: createSnoMemSnoStationMemDidWebVerifier(fetchImpl, options) });
+	try {
+		return await ConfigRegistryManager.open(paths.registryDir, { signedRoot });
+	} catch (error) {
+		const anchorFailure = releaseAnchorFailureMessage(error);
+		if (anchorFailure !== null) throw new Error(anchorFailure, { cause: error });
+		throw error;
+	}
+}
+async function resolveBundledLlmixPreset(presetId) {
+	return loadBundledLlmixPreset(await openBundledLlmixRegistry(), presetId);
+}
+async function loadBundledLlmixPreset(registry, presetId) {
+	const id = parsePresetId(presetId);
+	const preset = await registry.getPreset(id.module, id.preset);
+	return {
+		preset: presetId,
+		provider: assertSupportedProvider(preset.provider),
+		model: preset.model,
+		...preset.providerOptions ? { providerOptions: preset.providerOptions } : {},
+		...preset.timeout?.totalTime ? { timeoutMs: preset.timeout.totalTime * 1e3 } : {}
+	};
+}
+function materializeBundledLlmixEndpoint(input) {
+	const path = input.preset.provider === "sno-gpu" ? input.preset.providerOptions?.["sno-gpu"]?.gpuPath : "chat/completions";
+	if (!path) throw new Error(`sno-station-mem llm-client: signed endpoint path missing from preset ${input.preset.preset}`);
+	return {
+		url: new URL(path, resolveEndpointBase(input.baseSource, input.preset.provider !== "sno-gpu")).toString(),
+		preset: input.preset
+	};
+}
+async function resolveConfiguredBundledLlmixEndpoint(input) {
+	const registry = await openBundledLlmixRegistry();
+	const configured = await loadBundledLlmixPreset(registry, input.configuredPresetId);
+	const endpointPresetId = input.selectEndpointPreset(configured.provider);
+	return materializeBundledLlmixEndpoint({
+		preset: endpointPresetId === input.configuredPresetId ? configured : await loadBundledLlmixPreset(registry, endpointPresetId),
+		baseSource: input.selectBaseSource(configured.provider)
+	});
+}
+//#endregion
+//#region src/model/llm-endpoint-resolution.ts
+const SNO_GPU_ORIGIN = "https://rt3-llm.sno.ai";
+const PROVIDER_API_BASES = {
+	openai: FIXED_PROTOCOL_VALUE_69,
+	openrouter: "https://openrouter.ai/api/v1"
+};
+async function resolveSignedPreset(presetId) {
+	return resolveBundledLlmixPreset(presetId);
+}
+function selectEndpointPreset(input) {
+	return input.provider === "sno-gpu" ? MODEL_CALLS[input.callId].snoPreset : input.configuredPreset;
+}
+async function resolveLlmEndpoint(input) {
+	return {
+		...await resolveConfiguredBundledLlmixEndpoint({
+			configuredPresetId: input.configuredPreset,
+			selectEndpointPreset: (provider) => {
+				if (input.transport !== "chat-completions" && provider !== "sno-gpu") throw new Error(`sno-station-mem llm-client: ${provider} does not support ${input.transport}`);
+				return selectEndpointPreset({
+					configuredPreset: input.configuredPreset,
+					provider,
+					callId: input.callId
+				});
+			},
+			selectBaseSource: (provider) => input.baseOverride ?? (provider === "sno-gpu" ? SNO_GPU_ORIGIN : PROVIDER_API_BASES[provider])
+		}),
+		userBaseUrlOverride: input.baseOverride !== void 0
+	};
+}
+//#endregion
+//#region src/model/llm-provider-transport.ts
+const log$1 = createLogger("sno-station-mem:llm-provider-transport");
+const routeInFlight = /* @__PURE__ */ new Map();
+const providerResponses = new AsyncLocalStorage();
+async function observeRequest(input, run) {
+	const route = createHash("sha256").update(input.endpoint).digest("hex");
+	const inFlight = (routeInFlight.get(route) ?? 0) + 1;
+	routeInFlight.set(route, inFlight);
+	const diagnostic = { started: performance.now() };
+	return withLogContext({ attempt_id: randomUUID() }, async () => {
+		let outcome = "failed";
+		let failure;
+		try {
+			const result = await run(diagnostic);
+			outcome = typeof result === "object" && result !== null && "content" in result && result.content === "" ? "empty_success" : "success";
+			return result;
+		} catch (error) {
+			failure = error;
+			outcome = getProviderTerminalCategory(error) ?? "failed";
+			throw error;
+		} finally {
+			const remaining = (routeInFlight.get(route) ?? 1) - 1;
+			if (remaining === 0) routeInFlight.delete(route);
+			else routeInFlight.set(route, remaining);
+			log$1.info("Model request completed", {
+				outcome,
+				error: failure,
+				call_id: input.slot ?? "unavailable",
+				destination: input.label ?? "unavailable",
+				route_hash: route,
+				transport: input.transport,
+				requested_model: input.model,
+				returned_model: diagnostic.returnedModel ?? "unavailable",
+				prompt_template_hash: input.promptTemplateHash ?? "unavailable",
+				extraction_skill_hash: input.extractionSkillHash ?? "unavailable",
+				prompt_template_unavailable_reason: input.promptTemplateHash ? void 0 : "caller_does_not_provide_template_identity",
+				config_hash: createHash("sha256").update(JSON.stringify({
+					...input,
+					endpoint: route
+				})).digest("hex"),
+				output_cap: input.cap ?? "unavailable",
+				timeout_ms: input.timeout,
+				sampling: {
+					source: Object.keys(input.sampling).length ? "sent" : "unknown",
+					values: input.sampling
+				},
+				in_flight_at_dispatch: inFlight,
+				status_code: diagnostic.status ?? "unavailable",
+				duration_ms: performance.now() - diagnostic.started,
+				dispatch_to_headers_ms: diagnostic.headersAt === void 0 ? "unavailable" : diagnostic.headersAt - diagnostic.started,
+				headers_to_body_ms: diagnostic.headersAt === void 0 || diagnostic.bodyAt === void 0 ? "unavailable" : diagnostic.bodyAt - diagnostic.headersAt,
+				first_token_ms: "unavailable",
+				first_token_reason: "non_streaming_transport",
+				server_queue_ms: "unavailable",
+				server_service_ms: "unavailable",
+				finish_reason: diagnostic.finishReason ?? "unavailable",
+				usage: diagnostic.usage ? {
+					source: diagnostic.usage.estimated ? "estimated" : "provider_reported",
+					...diagnostic.usage
+				} : { source: "unavailable" }
+			}, {
+				event_name: "llm.request.completed",
+				file: "packages/memory/src/model/llm-provider-transport.ts",
+				function: "observeRequest",
+				site_id: "llm.transport.request.completed"
+			});
+		}
+	});
+}
+const CCPROXY_OPENAI_BASE_URL = FIXED_PROTOCOL_VALUE_69;
+const CCPROXY_PLACEHOLDER_API_KEY = "ccproxy-placeholder";
+/** Keys from pipeline kwargs that belong in the chat/completions POST body. */
+const FORWARDED_KWARGS = [
+	"temperature",
+	"top_p",
+	"max_tokens",
+	"max_completion_tokens",
+	"seed",
+	"response_format"
+];
+/** Assembles call body from validated inputs for deterministic LLM transport. */
+function buildCallBody(kwargs, provider) {
+	const body = {};
+	for (const key of FORWARDED_KWARGS) {
+		if (provider === "sno-gpu" && key === "temperature") continue;
+		if (kwargs[key] != null) body[key] = kwargs[key];
+	}
+	return body;
+}
+function hasAbortSignalShape$1(value) {
+	return typeof value === "object" && value !== null && typeof value.aborted === "boolean" && typeof value.addEventListener === "function";
+}
+function requestAbortSignal(timeoutMs, callerSignal) {
+	const timeoutSignal = AbortSignal.timeout(Math.floor(timeoutMs));
+	if (!hasAbortSignalShape$1(callerSignal)) return {
+		signal: timeoutSignal,
+		timeoutSignal
+	};
+	return {
+		signal: callerSignal.aborted ? callerSignal : AbortSignal.any([timeoutSignal, callerSignal]),
+		timeoutSignal,
+		callerSignal
+	};
+}
+const PROVIDER_TERMINAL_ERROR_PREFIX = "sno-station-mem provider terminal";
+var ProviderTerminalError = class extends Error {
+	category;
+	statusCode;
+	constructor(category, message, statusCode) {
+		super(`${PROVIDER_TERMINAL_ERROR_PREFIX} ${category}: ${message}`);
+		this.category = category;
+		this.name = "ProviderTerminalError";
+		this.statusCode = statusCode;
+	}
+};
+/** Recovers terminal transport semantics after CallPipeline serializes an error to text. */
+function getProviderTerminalCategory(error) {
+	if (error instanceof ProviderTerminalError) return error.category;
+	const message = error instanceof Error ? error.message : String(error);
+	const match = new RegExp(`^${PROVIDER_TERMINAL_ERROR_PREFIX} (cancelled|timeout|auth):`).exec(message);
+	return match?.[1] === "cancelled" || match?.[1] === "timeout" || match?.[1] === "auth" ? match[1] : null;
+}
+function abortedProviderCategory(requestAbort) {
+	if (requestAbort.callerSignal?.aborted) return "cancelled";
+	if (requestAbort.timeoutSignal.aborted) return "timeout";
+	return null;
+}
+function throwTerminalAbort(error, requestAbort) {
+	const category = abortedProviderCategory(requestAbort);
+	if (category) throw new ProviderTerminalError(category, error instanceof Error ? error.message : String(error), 499);
+	throw error;
+}
+function estimateTokens(text) {
+	return Math.max(1, countTokens(text));
+}
+function estimateUsage(messages, content) {
+	const inputTokens = estimateTokens(JSON.stringify(messages));
+	const outputTokens = estimateTokens(content);
+	return {
+		inputTokens,
+		outputTokens,
+		totalTokens: inputTokens + outputTokens,
+		estimated: true
+	};
+}
+function readProviderUsage(usage) {
+	if (typeof usage?.prompt_tokens === "number" && typeof usage.completion_tokens === "number" && typeof usage.total_tokens === "number") return {
+		inputTokens: usage.prompt_tokens,
+		outputTokens: usage.completion_tokens,
+		totalTokens: usage.total_tokens
+	};
+}
+function normalizeProviderUsage(usage, messages, content) {
+	return readProviderUsage(usage) ?? estimateUsage(messages, content);
+}
+function readProviderRequestId(bodyId, headers) {
+	return [bodyId, headers.get("x-request-id")].find((value) => typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value));
+}
+function notifyProviderResponse(callback, response) {
+	providerResponses.getStore()?.push(response);
+	callback?.(response);
+}
+/** A call that ended without an answer is still a trace for the request in flight. */
+function recordProviderFailure(response) {
+	providerResponses.getStore()?.push(response);
+}
+/**
+* The status line alone does not say what the provider objected to, and a 400 always does — it is
+* the one class of failure where the server knows the answer and we were throwing it away. Measured
+* 2026-08-12: a REM wave died on `B-profile extraction returned HTTP 400`, and the reason for it was
+* unreachable without editing this file and re-running.
+*
+* Read only for a non-auth status: an auth failure's body is the one that can carry credential
+* material back, and it is also the one status that needs no explanation.
+*/
+async function describeProviderFailure(response, diagnostic) {
+	let detail;
+	try {
+		detail = (await response.text()).trim();
+		if (diagnostic) diagnostic.bodyAt = performance.now();
+	} catch {
+		return `HTTP ${response.status}`;
+	}
+	if (detail.length === 0) return `HTTP ${response.status}`;
+	const collapsed = detail.replace(/\s+/g, " ");
+	const shown = collapsed.length > 500 ? `${collapsed.slice(0, 500)}…` : collapsed;
+	return `HTTP ${response.status}: ${shown}`;
+}
+/** Calls the fixed B-profile raw-completions route without transport-level retries. */
+async function callSnoProfileCompletion(request) {
+	return observeRequest({
+		endpoint: request.endpointUrl,
+		model: request.model,
+		transport: "raw-completions",
+		slot: request.callId,
+		label: request.destination,
+		timeout: request.timeoutMs,
+		cap: request.singleTokenVerdict ? 1 : request.maxTokens,
+		sampling: {},
+		promptTemplateHash: request.promptTemplateHash,
+		extractionSkillHash: request.extractionSkillHash
+	}, async (diagnostic) => {
+		const requestAbort = requestAbortSignal(request.timeoutMs, request.signal);
+		let response;
+		try {
+			response = await fetch(request.endpointUrl, {
+				method: "POST",
+				signal: requestAbort.signal,
+				headers: {
+					"Content-Type": "application/json",
+					"X-Internal-Token": request.apiKey,
+					...request.requestId ? { "X-Request-ID": request.requestId } : {},
+					...request.operationId ? { "X-Sno-Operation": request.operationId } : {}
+				},
+				body: JSON.stringify({
+					model: request.model,
+					prompt: request.prompt,
+					...request.singleTokenVerdict ? { max_tokens: 1 } : request.maxTokens ? { max_tokens: request.maxTokens } : {}
+				})
+			});
+			diagnostic.headersAt = performance.now();
+			diagnostic.status = response.status;
+		} catch (error) {
+			throwTerminalAbort(error, requestAbort);
+		}
+		if (!response.ok) {
+			if (classifyLlmFailure({ status: response.status }).category === "auth") throw new ProviderTerminalError("auth", `B-profile extraction returned HTTP ${response.status}`, response.status);
+			const error = /* @__PURE__ */ new Error(`B-profile extraction returned ${await describeProviderFailure(response, diagnostic)}`);
+			error.statusCode = response.status;
+			throw error;
+		}
+		let body;
+		try {
+			body = await response.json();
+			diagnostic.bodyAt = performance.now();
+		} catch (error) {
+			throwTerminalAbort(error, requestAbort);
+		}
+		const content = body.choices?.[0]?.text;
+		if (typeof content !== "string") throw new Error("B-profile extraction response is missing choices[0].text");
+		const model = typeof body.model === "string" && body.model.trim() ? body.model : void 0;
+		const usage = readProviderUsage(body.usage);
+		diagnostic.returnedModel = model;
+		diagnostic.finishReason = body.choices?.[0]?.finish_reason;
+		diagnostic.usage = normalizeProviderUsage(body.usage, [request.prompt], content);
+		const requestId = readProviderRequestId(body.id, response.headers);
+		if (request.callId && request.destination) notifyProviderResponse(request.onProviderResponse, {
+			durationMs: performance.now() - diagnostic.started,
+			callId: request.callId,
+			destination: request.destination,
+			provider: "sno-gpu",
+			...requestId ? { requestId } : {},
+			...model ? { model } : {},
+			...usage ? { usage } : {}
+		});
+		return {
+			content,
+			model: model ?? request.model,
+			usage: normalizeProviderUsage(body.usage, [request.prompt], content)
+		};
+	});
+}
+function isCcproxyOpenAiBaseUrl(value) {
+	if (!value) return false;
+	try {
+		const configured = new URL(value);
+		const expected = new URL(CCPROXY_OPENAI_BASE_URL);
+		return configured.origin === expected.origin && configured.pathname.replace(/\/+$/, "") === expected.pathname.replace(/\/+$/, "");
+	} catch {
+		return false;
+	}
+}
+async function snoStationMemDispatch(ctx) {
+	const cfgExt = ctx.config;
+	const provider = ctx.provider;
+	if (provider !== "openai" && provider !== "openrouter" && provider !== "sno-gpu") throw new Error(`sno-station-mem llm-client: unsupported provider "${provider}"`);
+	const endpointUrl = cfgExt.endpointUrl;
+	if (typeof endpointUrl !== "string") throw new Error("sno-station-mem llm-client: resolved endpointUrl is required");
+	const timeoutMs = cfgExt.timeoutMs ?? 3e4;
+	const callBody = buildCallBody(ctx.kwargs, provider);
+	const sampling = Object.fromEntries([
+		"temperature",
+		"top_p",
+		"seed"
+	].flatMap((key) => callBody[key] === void 0 ? [] : [[key, callBody[key]]]));
+	return observeRequest({
+		endpoint: endpointUrl,
+		model: ctx.model,
+		transport: "chat-completions",
+		slot: cfgExt.callId,
+		label: cfgExt.destination,
+		timeout: timeoutMs,
+		cap: typeof callBody.max_tokens === "number" ? callBody.max_tokens : typeof callBody.max_completion_tokens === "number" ? callBody.max_completion_tokens : void 0,
+		sampling,
+		promptTemplateHash: cfgExt.promptTemplateHash,
+		extractionSkillHash: cfgExt.extractionSkillHash,
+		forwardedConfigHash: createHash("sha256").update(JSON.stringify({
+			response_format: callBody.response_format,
+			seed: callBody.seed,
+			max_tokens: callBody.max_tokens,
+			max_completion_tokens: callBody.max_completion_tokens,
+			temperature: callBody.temperature,
+			top_p: callBody.top_p
+		})).digest("hex")
+	}, async (diagnostic) => {
+		const requestAbort = requestAbortSignal(timeoutMs, cfgExt.signal);
+		const headers = { "Content-Type": "application/json" };
+		if (typeof cfgExt.requestId === "string") headers["X-Request-ID"] = cfgExt.requestId;
+		if (provider === "sno-gpu") {
+			headers["X-Internal-Token"] = ctx.apiKey;
+			if (typeof cfgExt.operationId === "string") headers["X-Sno-Operation"] = cfgExt.operationId;
+		} else headers.Authorization = `Bearer ${ctx.apiKey}`;
+		let response;
+		try {
+			response = await fetch(endpointUrl, {
+				method: "POST",
+				signal: requestAbort.signal,
+				headers,
+				body: JSON.stringify({
+					model: ctx.model,
+					messages: ctx.messages,
+					...callBody
+				})
+			});
+			diagnostic.headersAt = performance.now();
+			diagnostic.status = response.status;
+		} catch (error) {
+			const category = abortedProviderCategory(requestAbort);
+			if (category) throw new ProviderTerminalError(category, error instanceof Error ? error.message : String(error), 499);
+			throw error;
+		}
+		if (!response.ok) {
+			if (classifyLlmFailure({ status: response.status }).category === "auth") throw new ProviderTerminalError("auth", `HTTP ${response.status}`, response.status);
+			const err = new Error(await describeProviderFailure(response, diagnostic));
+			err.statusCode = response.status;
+			throw err;
+		}
+		let body;
+		try {
+			body = await response.json();
+			diagnostic.bodyAt = performance.now();
+		} catch (parseErr) {
+			if (abortedProviderCategory(requestAbort)) throwTerminalAbort(parseErr, requestAbort);
+			const err = /* @__PURE__ */ new Error(`Malformed response body: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+			err.statusCode = 502;
+			throw err;
+		}
+		const rawContent = body.choices?.[0]?.message?.content;
+		if (typeof rawContent !== "string") {
+			const err = /* @__PURE__ */ new Error("Chat completion response is missing choices[0].message.content");
+			err.statusCode = 502;
+			throw err;
+		}
+		const content = rawContent;
+		const model = typeof body.model === "string" && body.model.trim() ? body.model : void 0;
+		const usage = readProviderUsage(body.usage);
+		diagnostic.returnedModel = model;
+		diagnostic.finishReason = body.choices?.[0]?.finish_reason;
+		diagnostic.usage = normalizeProviderUsage(body.usage, ctx.messages, content);
+		const requestId = readProviderRequestId(body.id, response.headers);
+		const onProviderResponse = cfgExt.onProviderResponse;
+		if (cfgExt.callId && cfgExt.destination) notifyProviderResponse(typeof onProviderResponse === "function" ? onProviderResponse : void 0, {
+			durationMs: performance.now() - diagnostic.started,
+			callId: cfgExt.callId,
+			destination: cfgExt.destination,
+			provider,
+			...requestId ? { requestId } : {},
+			...model ? { model } : {},
+			...usage ? { usage } : {}
+		});
+		return {
+			content,
+			model: model ?? ctx.model,
+			usage: normalizeProviderUsage(body.usage, ctx.messages, content)
+		};
+	});
+}
+async function callProvider(ctx) {
+	const cfgExt = ctx.config;
+	const rawCompletion = cfgExt.rawCompletion;
+	if (typeof rawCompletion === "object" && rawCompletion !== null) {
+		const raw = rawCompletion;
+		if (typeof raw.endpointUrl !== "string" || typeof raw.prompt !== "string" || typeof raw.timeoutMs !== "number") throw new Error("sno-station-mem llm-client: invalid raw profile completion config");
+		return {
+			...await callSnoProfileCompletion({
+				...cfgExt.promptTemplateHash ? { promptTemplateHash: cfgExt.promptTemplateHash } : {},
+				...cfgExt.extractionSkillHash ? { extractionSkillHash: cfgExt.extractionSkillHash } : {},
+				endpointUrl: raw.endpointUrl,
+				model: ctx.model,
+				apiKey: ctx.apiKey,
+				prompt: raw.prompt,
+				timeoutMs: raw.timeoutMs,
+				...cfgExt.callId ? { callId: cfgExt.callId } : {},
+				...cfgExt.destination ? { destination: cfgExt.destination } : {},
+				...cfgExt.onProviderResponse ? { onProviderResponse: cfgExt.onProviderResponse } : {},
+				...typeof raw.requestId === "string" ? { requestId: raw.requestId } : {},
+				...typeof raw.operationId === "string" ? { operationId: raw.operationId } : {},
+				...typeof raw.maxTokens === "number" ? { maxTokens: raw.maxTokens } : {},
+				...raw.singleTokenVerdict === true ? { singleTokenVerdict: true } : {},
+				...hasAbortSignalShape$1(raw.signal) ? { signal: raw.signal } : {}
+			}),
+			success: true
+		};
+	}
+	return {
+		...await snoStationMemDispatch(ctx),
+		success: true
+	};
+}
+function resolveProviderApiKey(config, resolved, userBaseUrlOverride) {
+	if (config.apiKey?.trim()) return config.apiKey;
+	if (resolved.provider === "openai" && (!userBaseUrlOverride || isCcproxyOpenAiBaseUrl(config.baseURL?.trim()))) return CCPROXY_PLACEHOLDER_API_KEY;
+	throw new Error(`sno-station-mem llm-client: missing API key for preset ${config.preset}; set snoGpu.apiKey`);
+}
+//#endregion
+//#region src/model/llm-client.ts
+const log = createLogger("sno-station-mem:llm-client");
+let hostRequestsInFlight = 0;
+/**
+* Last-resort output cap for a raw-completion caller that set none. Every use is logged as an
+* error naming the caller, because this exists to keep a broken call alive, not to spare anyone
+* from choosing their own budget.
+*/
+const RAW_COMPLETION_FALLBACK_MAX_TOKENS = 4096;
+/**
+* How many times one request may be asked before an empty reply is accepted as the answer.
+*
+* The serving side answers an otherwise valid request with an empty body often enough to matter:
+* measured 2026-08-17 against the live endpoint, 25% of 36 paired calls with `enable_thinking`
+* and 31% without (llm-provider-transport.ts:242, where that fault is recorded as still open).
+* An empty body is not a transport error, so the call pipeline never retried it, and every caller
+* turned it into `null`. The REM replace clause stage then journals that null as
+* `clause_parse_failed` and releases the pair, so the memory is never updated at all — measured
+* 2026-08-26, 2 of 4 identical runs of `rem-replace-roundtrip-reopen` died that way on a
+* two-clause fixture the model answers correctly 12 times out of 12 when asked directly.
+*
+* Asking again is all this does. It is bounded by attempt count AND by the caller's own deadline,
+* so a slow endpoint cannot turn one request into three timeouts. It does not repair the
+* serving-side fault and must not be read as having repaired it.
+*/
+const EMPTY_REPLY_ATTEMPTS = 3;
+const JSON_SYSTEM_CONTENT = "You are a memory extraction assistant. Always respond with valid JSON only.";
+const JSON_REPAIR_INSTRUCTION = "Your previous reply was not valid JSON. Respond with ONLY the JSON object, no prose.";
+const REFLECTION_TEXT_SYSTEM_CONTENT = "You are a memory reflection assistant. Return concise plain text only.";
+const CONFLICT_ADJUDICATION_SYSTEM_CONTENT = "You adjudicate memory conflicts. Follow the verdict contract and return only the requested JSON object or verdict token.";
+var LlmClientTerminalError = class extends Error {
+	category;
+	requestTimedOut;
+	constructor(category, message, requestTimedOut = false) {
+		super(message);
+		this.category = category;
+		this.requestTimedOut = requestTimedOut;
+		this.name = "LlmClientTerminalError";
+	}
+};
+var ModelCallRefusedError = class extends Error {
+	callId;
+	destination;
+	reason;
+	constructor(callId, destination, reason) {
+		super(reason);
+		this.callId = callId;
+		this.destination = destination;
+		this.reason = reason;
+		this.name = "ModelCallRefusedError";
+	}
+};
+/**
+* Whether a failure ends the whole run rather than costing one call.
+*
+* A real cancellation and an auth failure are terminal: nothing downstream should keep spending
+* model time or, worse, keep writing. A timeout is NOT — the transport aborts on its own deadline
+* and reports `cancelled` with `requestTimedOut` set, and treating that as a cancellation once
+* cost an entire conversation for one slow call.
+*
+* SOURCE OF TRUTH. The same predicate is spelled out by hand in memory-extraction-pipeline.ts,
+* task-lifecycle-route.ts, profile-section-writer.ts and b-profile-extraction.ts; those copies
+* should be replaced by this import, and are flagged rather than changed here.
+*/
+function isTerminalLlmFailure(error) {
+	return error instanceof LlmClientTerminalError && (error.category === "cancelled" && !error.requestTimedOut || error.category === "auth");
+}
+function parseJsonResponse(raw, accept) {
+	const parsedValue = readModelReplyJson(raw, (value) => accept === void 0 || accept(value) ? { value } : void 0);
+	if (parsedValue !== void 0) return {
+		ok: true,
+		value: parsedValue.value
+	};
+	const jsonStr = extractJsonFromResponse(raw);
+	if (!jsonStr) return {
+		ok: false,
+		error: `no JSON found (chars=${raw.length}, preview=${JSON.stringify(previewText(raw))})`
+	};
+	try {
+		const value = JSON.parse(jsonStr);
+		if (accept && !accept(value)) return {
+			ok: false,
+			error: "caller check rejected payload"
+		};
+		return {
+			ok: true,
+			value
+		};
+	} catch (error) {
+		const repairedJsonStr = repairCommonJson(jsonStr);
+		if (repairedJsonStr !== jsonStr) try {
+			const value = JSON.parse(repairedJsonStr);
+			if (accept && !accept(value)) return {
+				ok: false,
+				error: "caller check rejected payload"
+			};
+			return {
+				ok: true,
+				value
+			};
+		} catch {
+			return {
+				ok: false,
+				error: `JSON.parse failed: ${error instanceof Error ? error.message : String(error)}; repair also failed (chars=${jsonStr.length})`
+			};
+		}
+		return {
+			ok: false,
+			error: `JSON.parse failed: ${error instanceof Error ? error.message : String(error)} (chars=${jsonStr.length})`
+		};
+	}
+}
+function buildPipelineConfig(preset, config, endpoint, request, destination, operationId) {
+	return {
+		provider: preset.provider,
+		model: preset.model,
+		...preset.providerOptions ? { providerOptions: preset.providerOptions } : {},
+		timeout: { totalTime: Math.ceil((request.timeoutMs ?? config.timeoutMs ?? preset.timeoutMs ?? 3e4) / 1e3) },
+		common: {
+			enableThinking: request.enableThinking ?? false,
+			maxOutputTokens: request.maxTokens ?? 4096
+		},
+		caching: { strategy: "disabled" },
+		preset: preset.preset,
+		baseUrl: endpoint.url,
+		endpointUrl: endpoint.url,
+		...endpoint.userBaseUrlOverride ? { userBaseUrlOverride: endpoint.userBaseUrlOverride } : {},
+		timeoutMs: request.timeoutMs ?? config.timeoutMs ?? preset.timeoutMs ?? 3e4,
+		callId: request.callId,
+		destination,
+		...request.requestId ? { requestId: request.requestId } : {},
+		...operationId ? { operationId } : {},
+		...request.promptTemplateHash ? { promptTemplateHash: request.promptTemplateHash } : {},
+		...request.extractionSkillHash ? { extractionSkillHash: request.extractionSkillHash } : {},
+		...request.signal ? { signal: request.signal } : {},
+		...config.onProviderResponse ? { onProviderResponse: config.onProviderResponse } : {}
+	};
+}
+function hasAbortSignalShape(value) {
+	return typeof value === "object" && value !== null && typeof value.aborted === "boolean" && typeof value.addEventListener === "function";
+}
+function readRequiredString(request, field) {
+	const value = request[field];
+	if (typeof value !== "string" || !value.trim()) throw new Error(`sno-station-mem llm-client: ${field} is required`);
+	return value;
+}
+function normalizeMemoryLlmRequest(value) {
+	if (typeof value !== "object" || value === null) throw new Error("sno-station-mem llm-client: structured request object is required");
+	const raw = value;
+	const prompt = readRequiredString(raw, "prompt");
+	const callId = readRequiredString(raw, "callId");
+	if (!(callId in MODEL_CALLS)) throw new Error(`Unknown model call id ${callId}`);
+	const timeoutMs = raw.timeoutMs;
+	if (timeoutMs !== void 0 && (!Number.isFinite(timeoutMs) || Number(timeoutMs) <= 0)) throw new Error("sno-station-mem llm-client: timeoutMs must be a positive number");
+	const maxTokens = raw.maxTokens;
+	if (maxTokens !== void 0 && (!Number.isInteger(maxTokens) || Number(maxTokens) <= 0)) throw new Error("sno-station-mem llm-client: maxTokens must be a positive integer");
+	const emptyReplyAttempts = raw.emptyReplyAttempts;
+	if (emptyReplyAttempts !== void 0 && (!Number.isInteger(emptyReplyAttempts) || Number(emptyReplyAttempts) < 1 || Number(emptyReplyAttempts) > EMPTY_REPLY_ATTEMPTS)) throw new Error(`sno-station-mem llm-client: emptyReplyAttempts must be an integer from 1 to ${EMPTY_REPLY_ATTEMPTS}`);
+	const enableThinking = raw.enableThinking;
+	if (enableThinking !== void 0 && typeof enableThinking !== "boolean") throw new Error("sno-station-mem llm-client: enableThinking must be a boolean");
+	const signal = raw.signal;
+	if (signal !== void 0 && !hasAbortSignalShape(signal)) throw new Error("sno-station-mem llm-client: signal must be an AbortSignal");
+	const requestId = raw.requestId;
+	if (requestId !== void 0 && (typeof requestId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(requestId))) throw new Error("sno-station-mem llm-client: requestId must be a content-free correlation token");
+	return {
+		prompt,
+		...typeof raw.hostPrompt === "string" ? { hostPrompt: raw.hostPrompt } : {},
+		callId,
+		...timeoutMs !== void 0 ? { timeoutMs: Number(timeoutMs) } : {},
+		...maxTokens !== void 0 ? { maxTokens: Number(maxTokens) } : {},
+		...emptyReplyAttempts !== void 0 ? { emptyReplyAttempts: Number(emptyReplyAttempts) } : {},
+		...enableThinking !== void 0 ? { enableThinking } : {},
+		...requestId !== void 0 ? { requestId } : {},
+		...typeof raw.promptTemplateHash === "string" && /^[a-f0-9]{64}$/.test(raw.promptTemplateHash) ? { promptTemplateHash: raw.promptTemplateHash } : {},
+		...typeof raw.extractionSkillHash === "string" && /^[a-f0-9]{64}$/.test(raw.extractionSkillHash) ? { extractionSkillHash: raw.extractionSkillHash } : {},
+		...signal ? { signal } : {}
+	};
+}
+function textSystemContent(request) {
+	return MODEL_CALLS[request.callId].occasion === "conflictAdjudication" ? CONFLICT_ADJUDICATION_SYSTEM_CONTENT : REFLECTION_TEXT_SYSTEM_CONTENT;
+}
+/** Creates the LLM client facade with provider routing, key rotation, and JSON parsing. */
+function createLlmClient(config) {
+	let presetPromise = null;
+	const getPreset = () => {
+		presetPromise ??= resolveSignedPreset(config.preset).catch((error) => {
+			presetPromise = null;
+			throw error;
+		});
+		return presetPromise;
+	};
+	const endpointPromises = /* @__PURE__ */ new Map();
+	const getEndpoint = (callId, transport) => {
+		const key = `${callId}:${transport}`;
+		let endpointPromise = endpointPromises.get(key);
+		if (!endpointPromise) {
+			endpointPromise = resolveLlmEndpoint({
+				configuredPreset: config.preset,
+				callId,
+				transport,
+				...config.baseURL ? { baseOverride: config.baseURL } : {}
+			}).catch((error) => {
+				endpointPromises.delete(key);
+				throw error;
+			});
+			endpointPromises.set(key, endpointPromise);
+		}
+		return endpointPromise;
+	};
+	const pipeline = new CallPipeline({
+		dispatch: callProvider,
+		maxRetries: 2,
+		retryBaseMs: 100,
+		retryMaxDelayMs: 500,
+		transformKwargsOverrides: { "sno-gpu": (_context, kwargs) => kwargs }
+	});
+	let lastError = null;
+	let lastUsage = null;
+	const resolveRequestTimeoutMs = (request) => request.timeoutMs ?? config.timeoutMs ?? 3e4;
+	const destinationFor = (request) => {
+		if (!config.routing) return "host";
+		const route = resolveLlmRoute({
+			callId: request.callId,
+			config: config.routing
+		});
+		return "off" in route ? "off" : route.destination;
+	};
+	/**
+	* Resolves the transport this facade can dispatch. A routed-OFF request is
+	* a graceful no-op (not an error), and an unavailable transport also skips.
+	* Neither case substitutes another tier.
+	*/
+	const resolveRequestTransport = (state, request) => {
+		if (!config.routing) return "chat-completions";
+		const decision = resolveLlmRoute({
+			callId: request.callId,
+			config: config.routing
+		});
+		if ("off" in decision) {
+			log.debug("Model client request diagnostic", {
+				call_id: request.callId,
+				destination: destinationFor(request),
+				error: `sno-station-mem: llm-client [${request.callId}] routed off (${decision.reason}); deterministic fallback applies`
+			}, {
+				event_name: "memory.llm_client.diagnostic",
+				file: "packages/memory/src/model/llm-client.ts",
+				function: "resolveRequestTransport",
+				site_id: "shared.llm-client.resolveRequestTransport.8f631601af"
+			});
+			return null;
+		}
+		if (decision.transport === "agent-host-seam") {
+			if (config.agentPort) return "agent-host-seam";
+			state.error = `sno-station-mem: llm-client [${request.callId}] routed to agent-host-seam but AgentLlmPort is unavailable`;
+			log.warn("Model client request diagnostic", {
+				call_id: request.callId,
+				destination: destinationFor(request),
+				error: state.error
+			}, {
+				event_name: "memory.llm_client.diagnostic",
+				file: "packages/memory/src/model/llm-client.ts",
+				function: "resolveRequestTransport",
+				site_id: "shared.llm-client.resolveRequestTransport.ffa933b519"
+			});
+			return null;
+		}
+		return decision.transport;
+	};
+	const requestContent = async (state, request, systemContent, prompt = request.prompt, forcedDestination) => {
+		checkMemoryOperation();
+		state.error = null;
+		state.usage = null;
+		const transport = forcedDestination === "host" ? "agent-host-seam" : resolveRequestTransport(state, request);
+		if (!transport) return null;
+		const route = config.routing ? resolveLlmRoute({
+			callId: request.callId,
+			config: config.routing
+		}) : null;
+		const destination = forcedDestination ?? (route && "destination" in route ? route.destination : "host");
+		if (transport === "agent-host-seam") {
+			const agentPort = config.agentPort;
+			if (!agentPort) throw new LlmClientTerminalError("transport", `sno-station-mem: llm-client [${request.callId}] AgentLlmPort is unavailable`);
+			config.onTransportAttempt?.({
+				callId: request.callId,
+				destination,
+				transport
+			});
+			const hostStarted = performance.now();
+			const hostInFlight = ++hostRequestsInFlight;
+			const result = await withLogContext({ attempt_id: randomUUID() }, async () => {
+				let outcome = "failed";
+				try {
+					const completion = await agentPort.complete({
+						system: systemContent,
+						prompt,
+						maxTokens: request.maxTokens ?? 4096,
+						...request.enableThinking !== void 0 ? { enableThinking: request.enableThinking } : {},
+						timeoutMs: resolveRequestTimeoutMs(request),
+						...request.signal ? { signal: request.signal } : {}
+					});
+					outcome = completion.kind;
+					return completion;
+				} finally {
+					hostRequestsInFlight -= 1;
+					log.info("Host model request completed", {
+						outcome,
+						transport: "agent-host-seam",
+						call_id: request.callId,
+						destination,
+						duration_ms: performance.now() - hostStarted,
+						in_flight_at_dispatch: hostInFlight,
+						requested_model: "unavailable",
+						returned_model: "unavailable",
+						usage: { source: "unavailable" },
+						prompt_template_hash: request.promptTemplateHash ?? "unavailable",
+						extraction_skill_hash: request.extractionSkillHash ?? "unavailable",
+						prompt_template_unavailable_reason: request.promptTemplateHash ? void 0 : "caller_does_not_provide_template_identity",
+						config_hash: createHash("sha256").update(JSON.stringify({
+							transport,
+							maxTokens: request.maxTokens ?? 4096,
+							timeoutMs: resolveRequestTimeoutMs(request)
+						})).digest("hex"),
+						output_cap: "unavailable",
+						passed_output_cap: request.maxTokens ?? 4096,
+						output_cap_reason: "host_may_strip_requested_cap",
+						timeout_ms: resolveRequestTimeoutMs(request),
+						sampling: { source: "unknown" },
+						finish_reason: "unavailable",
+						route: "agent-host-seam",
+						dispatch_to_headers_ms: "unavailable",
+						headers_to_body_ms: "unavailable",
+						first_token_ms: "unavailable",
+						provider_unavailable_reason: "host_port_does_not_report_provider_fields"
+					}, {
+						event_name: "llm.request.completed",
+						file: "packages/memory/src/model/llm-client.ts",
+						function: "requestContent",
+						site_id: "llm.host.request.completed"
+					});
+				}
+			});
+			if (result.kind === "cancelled") {
+				state.error = `[${request.callId}] agent-llm cancelled (${result.reason})`;
+				log.warn("Host model request cancelled", {
+					call_id: request.callId,
+					destination,
+					error: state.error
+				}, {
+					event_name: "memory.llm_client.diagnostic",
+					file: "packages/memory/src/model/llm-client.ts",
+					function: "requestContent",
+					site_id: "llm.client.host_cancelled"
+				});
+				throw new LlmClientTerminalError("cancelled", state.error, result.reason === "deadline" && !request.signal?.aborted);
+			}
+			if (result.kind === "error") {
+				state.error = `[${request.callId}] agent-llm ${result.category}: ${result.message}`;
+				recordProviderFailure({
+					callId: request.callId,
+					destination: "host",
+					provider: "agent-host-seam",
+					failure: `host_${result.category}`,
+					durationMs: performance.now() - hostStarted
+				});
+				log.warn("Host model request failed", {
+					call_id: request.callId,
+					destination,
+					failure_category: result.category,
+					error: state.error
+				}, {
+					event_name: "memory.llm_client.diagnostic",
+					file: "packages/memory/src/model/llm-client.ts",
+					function: "requestContent",
+					site_id: "llm.client.host_error"
+				});
+				if (config.refuseOnUnavailable && ([
+					"auth",
+					"credential-expired",
+					"credential-revoked",
+					"exhausted",
+					"throttle"
+				].includes(result.category) || result.message === "no-agent-endpoint" || result.message.includes("HTTP 503") || result.message.includes("worker-not-ready") || result.message.includes("stale-binding"))) throw new ModelCallRefusedError(request.callId, "host", result.message);
+				if (isCredentialFailure(result.category)) throw new LlmClientTerminalError("auth", state.error);
+				return null;
+			}
+			return {
+				raw: result.text,
+				transport
+			};
+		}
+		const endpoint = await getEndpoint(request.callId, transport);
+		checkMemoryOperation();
+		const preset = endpoint.preset;
+		const apiKey = resolveProviderApiKey(config, preset, endpoint.userBaseUrlOverride);
+		const operationId = config.operationId ?? memoryOperationId();
+		if (transport === "raw-completions") {
+			if (preset.provider !== "sno-gpu") throw new Error("raw completion requires the sno-gpu provider");
+			if (MODEL_CALLS[request.callId].replyParser.snoGpu !== "single-token-verdict" && !request.maxTokens) log.error("Model client request diagnostic", {
+				call_id: request.callId,
+				destination,
+				error: `sno-station-mem llm-client: raw completion [${request.callId}] set no maxTokens; sending ${RAW_COMPLETION_FALLBACK_MAX_TOKENS} so the call still runs. Fix the caller — without a cap the serving side truncates at 16 tokens.`
+			}, {
+				event_name: "memory.llm_client.diagnostic",
+				file: "packages/memory/src/model/llm-client.ts",
+				function: "requestContent",
+				site_id: "shared.llm-client.requestContent.ff17976562"
+			});
+			const pipelineConfig = {
+				...buildPipelineConfig(preset, config, endpoint, request, destination, operationId),
+				rawCompletion: {
+					endpointUrl: endpoint.url,
+					prompt,
+					timeoutMs: resolveRequestTimeoutMs(request),
+					maxTokens: request.maxTokens ?? RAW_COMPLETION_FALLBACK_MAX_TOKENS,
+					...request.requestId ? { requestId: request.requestId } : {},
+					...operationId ? { operationId } : {},
+					...MODEL_CALLS[request.callId].replyParser.snoGpu === "single-token-verdict" ? { singleTokenVerdict: true } : {},
+					...request.signal ? { signal: request.signal } : {}
+				}
+			};
+			pipeline.setKeyPool(preset.provider, new KeyPool(apiKey.split(",")));
+			config.onTransportAttempt?.({
+				callId: request.callId,
+				destination,
+				transport
+			});
+			const response = await pipeline.call({
+				config: pipelineConfig,
+				messages: [prompt]
+			});
+			if (!response.success) {
+				state.error = `sno-station-mem: llm-client [${request.callId}] pipeline error: ${response.error}`;
+				log.warn("Raw model request failed", {
+					call_id: request.callId,
+					destination,
+					error: state.error
+				}, {
+					event_name: "memory.llm_client.diagnostic",
+					file: "packages/memory/src/model/llm-client.ts",
+					function: "requestContent",
+					site_id: "llm.client.raw_pipeline_failed"
+				});
+				const category = getProviderTerminalCategory(response.error);
+				if (config.refuseOnUnavailable && (category === "auth" || classifyLlmFailure({ message: response.error }).category === "auth" || /(?:ECONNREFUSED|\b5\d\d\b)/i.test(response.error ?? ""))) throw new ModelCallRefusedError(request.callId, "sno-gpu", response.error ?? "model unavailable");
+				if (category) throw new LlmClientTerminalError(category, state.error);
+				return null;
+			}
+			state.usage = response.usage;
+			return {
+				raw: response.content,
+				transport
+			};
+		}
+		const pipelineConfig = buildPipelineConfig(preset, config, endpoint, request, destination, operationId);
+		pipeline.setKeyPool(preset.provider, new KeyPool(apiKey.split(",")));
+		config.onTransportAttempt?.({
+			callId: request.callId,
+			destination,
+			transport
+		});
+		const response = await pipeline.call({
+			config: pipelineConfig,
+			messages: [{
+				role: "system",
+				content: systemContent
+			}, {
+				role: "user",
+				content: prompt
+			}]
+		});
+		if (!response.success) {
+			state.error = `sno-station-mem: llm-client [${request.callId}] pipeline error: ${response.error}`;
+			log.warn("Chat model request failed", {
+				call_id: request.callId,
+				destination,
+				error: state.error
+			}, {
+				event_name: "memory.llm_client.diagnostic",
+				file: "packages/memory/src/model/llm-client.ts",
+				function: "requestContent",
+				site_id: "llm.client.chat_pipeline_failed"
+			});
+			const category = getProviderTerminalCategory(response.error);
+			if (config.refuseOnUnavailable && (category === "auth" || classifyLlmFailure({ message: response.error }).category === "auth" || /(?:ECONNREFUSED|\b5\d\d\b)/i.test(response.error ?? ""))) throw new ModelCallRefusedError(request.callId, "sno-gpu", response.error ?? "model unavailable");
+			if (category) throw new LlmClientTerminalError(category, state.error);
+			return null;
+		}
+		state.usage = response.usage;
+		const raw = response.content;
+		if (!raw) {
+			state.error = `sno-station-mem: llm-client [${request.callId}] empty response from preset ${config.preset}`;
+			log.warn("Model reply empty", {
+				call_id: request.callId,
+				destination,
+				error: state.error
+			}, {
+				event_name: "memory.llm_client.diagnostic",
+				file: "packages/memory/src/model/llm-client.ts",
+				function: "requestContent",
+				site_id: "llm.client.empty_reply"
+			});
+			return {
+				raw: "",
+				transport
+			};
+		}
+		return {
+			raw,
+			transport
+		};
+	};
+	const addUsage = (total, more) => total && more ? {
+		inputTokens: total.inputTokens + more.inputTokens,
+		outputTokens: total.outputTokens + more.outputTokens,
+		totalTokens: total.totalTokens + more.totalTokens
+	} : total ?? more;
+	/**
+	* Wraps `requestContent` with the bounded re-ask described on `EMPTY_REPLY_ATTEMPTS`. A `null`
+	* result is returned untouched — it means no call was made, not that the model said nothing.
+	*/
+	const requestContentRetryingEmpty = async (state, request, systemContent, deadlineMs, prompt = request.prompt) => {
+		let content = await requestContent(state, request, systemContent, prompt);
+		let usage = state.usage;
+		try {
+			checkMemoryOperation();
+			const attemptLimit = request.emptyReplyAttempts ?? EMPTY_REPLY_ATTEMPTS;
+			for (let attempt = 2; attempt <= attemptLimit; attempt += 1) {
+				if (content === null || content.raw.trim().length > 0) break;
+				const remainingMs = deadlineMs - performance.now();
+				if (remainingMs <= 0) break;
+				log.debug("Retrying empty model reply", {
+					call_id: request.callId,
+					destination: destinationFor(request),
+					attempt,
+					attempt_limit: attemptLimit
+				}, {
+					event_name: "memory.llm_client.diagnostic",
+					file: "packages/memory/src/model/llm-client.ts",
+					function: "requestContentRetryingEmpty",
+					site_id: "shared.llm-client.requestContentRetryingEmpty.cd874fefff"
+				});
+				content = await requestContent(state, {
+					...request,
+					timeoutMs: remainingMs
+				}, systemContent, prompt);
+				usage = addUsage(usage, state.usage);
+				checkMemoryOperation();
+			}
+		} finally {
+			state.usage = usage;
+		}
+		return content;
+	};
+	const requestContentWithHostFallback = async (state, request, systemContent, deadlineMs) => {
+		let content = null;
+		let snoError;
+		try {
+			content = await requestContentRetryingEmpty(state, request, systemContent, deadlineMs);
+		} catch (error) {
+			snoError = error;
+		}
+		if (destinationFor(request) !== "sno-gpu" || content?.raw.trim()) {
+			if (snoError !== void 0) throw snoError;
+			return content;
+		}
+		if (request.signal?.aborted || snoError instanceof LlmClientTerminalError && snoError.category === "cancelled" && !snoError.requestTimedOut) {
+			if (snoError !== void 0) throw snoError;
+			return content;
+		}
+		const originalLastError = state.error;
+		const originalLastUsage = state.usage;
+		const source = snoError instanceof Error ? snoError.message : originalLastError ?? "";
+		const status = /\bHTTP ([1-5]\d\d)\b/.exec(source)?.[1];
+		let snoFailure = "transport";
+		if (status) snoFailure = `HTTP ${status}`;
+		else if (content) snoFailure = "empty_reply";
+		else if (snoError instanceof LlmClientTerminalError) snoFailure = snoError.category;
+		else if (!config.apiKey?.trim()) snoFailure = "missing_key";
+		const operationId = config.operationId ?? memoryOperationId();
+		let hostFailure = "empty_reply";
+		if (!config.agentPort) hostFailure = "port_unavailable";
+		else if ([
+			"E10",
+			"P1",
+			"REM1"
+		].includes(request.callId) && !request.hostPrompt) hostFailure = "host_prompt_missing";
+		else try {
+			const host = await requestContent(state, request, systemContent, request.hostPrompt ?? request.prompt, "host");
+			if (host?.raw.trim()) {
+				log.info("Sno model call answered by host", {
+					call_id: request.callId,
+					operation_id: operationId,
+					sno_failure: snoFailure,
+					host_outcome: "answered",
+					timeout_ms: resolveRequestTimeoutMs(request)
+				}, {
+					event_name: "memory.llm_client.fallback",
+					file: "packages/memory/src/model/llm-client.ts",
+					function: "requestContentWithHostFallback",
+					site_id: "llm.client.fallback.answered"
+				});
+				state.usage = addUsage(originalLastUsage, state.usage);
+				return host;
+			}
+			if (host === null) hostFailure = "host_error";
+		} catch (error) {
+			if (request.signal?.aborted) throw error;
+			hostFailure = error instanceof LlmClientTerminalError ? error.category : "transport";
+		}
+		state.error = originalLastError;
+		state.usage = originalLastUsage;
+		log.warn("Sno model call and host fallback failed", {
+			call_id: request.callId,
+			operation_id: operationId,
+			sno_failure: snoFailure,
+			host_failure: hostFailure
+		}, {
+			event_name: "memory.llm_client.fallback",
+			file: "packages/memory/src/model/llm-client.ts",
+			function: "requestContentWithHostFallback",
+			site_id: "llm.client.fallback.failed"
+		});
+		if (snoError !== void 0) throw snoError;
+		return content;
+	};
+	return {
+		/** Implements complete json as the local LLM transport operation. */
+		async completeJson(input) {
+			const state = {
+				error: null,
+				usage: null
+			};
+			const request = normalizeMemoryLlmRequest({
+				...input,
+				signal: memoryOperationSignal(input.signal)
+			});
+			checkMemoryOperation();
+			const deadlineMs = performance.now() + resolveRequestTimeoutMs(request);
+			try {
+				let content = await requestContentWithHostFallback(state, request, JSON_SYSTEM_CONTENT, deadlineMs);
+				if (content === null) return null;
+				let parsed = parseJsonResponse(content.raw, input.accept);
+				if (parsed.ok) return parsed.value;
+				if (content.transport === "agent-host-seam" && destinationFor(request) !== "sno-gpu") {
+					const remainingTimeoutMs = Math.floor(deadlineMs - performance.now());
+					if (remainingTimeoutMs <= 0) {
+						state.error = `sno-station-mem: llm-client [${request.callId}] deadline exhausted before JSON repair`;
+						log.warn("Model repair deadline exhausted", {
+							call_id: request.callId,
+							destination: destinationFor(request),
+							error: state.error
+						}, {
+							event_name: "memory.llm_client.diagnostic",
+							file: "packages/memory/src/model/llm-client.ts",
+							function: "completeJson",
+							site_id: "llm.client.json.deadline_exhausted"
+						});
+						throw new LlmClientTerminalError("cancelled", state.error, true);
+					}
+					content = await requestContentRetryingEmpty(state, {
+						...request,
+						timeoutMs: remainingTimeoutMs
+					}, JSON_SYSTEM_CONTENT, deadlineMs, `${request.prompt}\n\n${JSON_REPAIR_INSTRUCTION}`);
+					if (content === null) return null;
+					parsed = parseJsonResponse(content.raw, input.accept);
+					if (parsed.ok) return parsed.value;
+				}
+				state.error = `sno-station-mem: llm-client [${request.callId}] ${parsed.error}`;
+				log.warn("Model client request diagnostic", {
+					operation: "completeJson",
+					call_id: request.callId,
+					destination: destinationFor(request),
+					error: state.error
+				}, {
+					event_name: "memory.llm_client.diagnostic",
+					file: "packages/memory/src/model/llm-client.ts",
+					function: "completeJson",
+					site_id: "shared.llm-client.completeJson.e04c8e7e82"
+				});
+				return null;
+			} catch (err) {
+				checkMemoryOperation();
+				if (err instanceof LlmClientTerminalError || err instanceof ModelCallRefusedError) throw err;
+				state.error = `sno-station-mem: llm-client [${request.callId}] request failed for preset ${config.preset}: ${err instanceof Error ? err.message : String(err)}`;
+				log.warn("Model request failed", {
+					call_id: request.callId,
+					destination: destinationFor(request),
+					error: state.error
+				}, {
+					event_name: "memory.llm_client.diagnostic",
+					file: "packages/memory/src/model/llm-client.ts",
+					function: "completeJson",
+					site_id: "llm.client.json.request_failed"
+				});
+				return null;
+			} finally {
+				lastError = state.error;
+				lastUsage = state.usage;
+			}
+		},
+		async completeText(input) {
+			const state = {
+				error: null,
+				usage: null
+			};
+			const request = normalizeMemoryLlmRequest({
+				...input,
+				signal: memoryOperationSignal(input.signal)
+			});
+			checkMemoryOperation();
+			const deadlineMs = performance.now() + resolveRequestTimeoutMs(request);
+			try {
+				const text = (await requestContentWithHostFallback(state, request, textSystemContent(request), deadlineMs))?.raw.trim();
+				return text && text.length > 0 ? text : null;
+			} catch (err) {
+				checkMemoryOperation();
+				if (err instanceof LlmClientTerminalError || err instanceof ModelCallRefusedError) throw err;
+				state.error = `sno-station-mem: llm-client [${request.callId}] request failed for preset ${config.preset}: ${err instanceof Error ? err.message : String(err)}`;
+				log.warn("Model client request diagnostic", {
+					call_id: request.callId,
+					destination: destinationFor(request),
+					error: state.error
+				}, {
+					event_name: "memory.llm_client.diagnostic",
+					file: "packages/memory/src/model/llm-client.ts",
+					function: "completeText",
+					site_id: "shared.llm-client.completeText.ffa933b519"
+				});
+				return null;
+			} finally {
+				lastError = state.error;
+				lastUsage = state.usage;
+			}
+		},
+		getResolvedConfig() {
+			return getPreset();
+		},
+		/** Returns last error from LLM transport state without side effects. */
+		getLastError() {
+			return lastError;
+		},
+		/** Returns provider usage from the last successful provider response. */
+		getLastUsage() {
+			return lastUsage;
+		}
+	};
+}
+//#endregion
+export { isTerminalLlmFailure as a, createLlmClient as i, LlmClientTerminalError as n, ModelCallRefusedError as r, JSON_SYSTEM_CONTENT as t };