@snoai/memory 1.2.12 → 1.2.14

package/dist/{rem-trigger-B_S0CBa7.js → rem-trigger-i_E8I9lv.js}

@@ -1,4 +1,4 @@
-import { $ as FIXED_IDX_MEMORY_ACTIVE_TASK_CURRENT_REVISION, A as modelCallDestination, At as FIXED_MEMORY_PROFILE_RECOVERY_ENTRIES, B as FIXED_EXTERNAL_VALUE_49, C as getSnoStationMemStateDir, Cn as CHUNK_OVERLAP_TOKENS, Cr as CachedEmbeddingProvider, Ct as FIXED_MEMORY_CHUNKS_MEM_FACET_IDX, D as settingsToPluginConfig, Dn as DEFAULT_IMPORTANCE, Dr as LocalEmbedProvider, Dt as FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD, En as DEFAULT_BM25_WEIGHT, Et as FIXED_MEMORY_MEMORIES, Fn as DEFAULT_VECTOR_WEIGHT, Fr as REM_SIDECAR_TOKEN_HEADER, G as FIXED_EXTERNAL_VALUE_55, Gn as IMPORTANCE_WEIGHT_BASE, H as FIXED_EXTERNAL_VALUE_52, Hn as HEAD_EXTRACT_MIN_CONTENT_TOKENS, In as EMBEDDER_DIM, It as FIXED_MEMORY_SNO_EXTRACT_CHAT, J as FIXED_EXTERNAL_VALUE_58, Jn as LIGHTWEIGHT_COSINE_WEIGHT, K as FIXED_EXTERNAL_VALUE_56, Kt as FIXED_PROTOCOL_VALUE_69, Ln as EMBEDDER_MODEL_DEFAULT, Mn as DEFAULT_RERANK_MODEL, Mt as FIXED_MEMORY_PROVIDER_PROJECT_AGENTS, Nn as DEFAULT_RERANK_TIMEOUT_MS, Nt as FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS, O as MODEL_CALLS, On as DEFAULT_RECALL_LIFECYCLE, Or as ensureModelDownloaded, Ot as FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD, P as observeAgentId, Q as FIXED_IDX_MEMORY, Rn as EMBEDDER_PROVIDER_DEFAULT, Rt as FIXED_MEMORY_TASK_LIFECYCLE_COMMANDS, Sn as CHUNK_MIN_TOKENS, St as FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX, T as readSettings, Tn as CHUNK_TOKENIZER_MODE, Tr as LOCAL_EMBEDDING_MODEL, Tt as FIXED_MEMORY_EXTRACTION_TIMESTAMPS, U as FIXED_EXTERNAL_VALUE_53, Un as HEAD_EXTRACT_OVERLAP_DROP_RATIO, V as FIXED_EXTERNAL_VALUE_51, W as FIXED_EXTERNAL_VALUE_54, Wn as HEAD_EXTRACT_TOKEN_BUDGET, X as FIXED_EXTERNAL_VALUE_8, Xn as LIGHTWEIGHT_RERANK_PENALTY, Y as FIXED_EXTERNAL_VALUE_62, Yn as LIGHTWEIGHT_FUSION_WEIGHT, Z as FIXED_EXTERNAL_VALUE_9, _t as FIXED_MEMORY_CHUNKS, a as REM_MODEL_OUTPUT_TOKEN_CAP, an as PERSISTED_PROVIDER_SYSTEM, ar as MMR_LAMBDA, at as FIXED_IDX_MEMORY_MEMORIES_LANE_PROJECT, bn as CHUNKING_VERSION$1, br as experimentCandidatePoolOverride, bt as FIXED_MEMORY_CHUNKS_AU, cn as SUPPORTED_LOCALES, ct as FIXED_IDX_MEMORY_MEMORIES_PROJECT_FACT_KEY_ACTIVE, d as getRemDiscoveryPath, dn as ADJACENCY_BONUS_PER_PAIR, dt as FIXED_MEMORY_ACTIVE_TASK_EVIDENCE, en as FIXED_VEC_MEMORY, er as MAX_CHUNK_FETCH_LIMIT, et as FIXED_IDX_MEMORY_ACTIVE_TASK_EVIDENCE_INSTANCE, fr as RERANK_BLEND_CROSS, ft as FIXED_MEMORY_ACTIVE_TASK_INSTANCES, g as readRemOperationalConfig, gr as TIME_DECAY_FLOOR, gt as FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS, ht as FIXED_MEMORY_ACTIVE_TASK_REVISIONS, in as PERSISTED_CONTENT_HASH_V3, it as FIXED_IDX_MEMORY_MEMORIES_FACT_ID, jt as FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS, k as MODEL_CALL_WORKLOAD, kt as FIXED_MEMORY_MIGRATION_MARKERS, lr as RECENCY_WEIGHT, lt as FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP, mr as RETRIEVAL_STORAGE_CHUNK_PROFILE, mt as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_MANIFESTS, nn as PERSISTED_CANDIDATE_HASH_V1, nt as FIXED_IDX_MEMORY_MEMORIES_CATEGORY, o as REM_RUN_PATH, or as MULTI_HIT_BONUS_CAP, ot as FIXED_IDX_MEMORY_MEMORIES_PROJECT, pr as RERANK_BLEND_VECTOR, pt as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_EVIDENCE, q as FIXED_EXTERNAL_VALUE_57, qn as INTRA_MEMORY_COSINE_THRESHOLD, qt as FIXED_PROTOCOL_VALUE_73, r as REM_CORRELATION_ID_HEADER, rn as PERSISTED_CONTENT_HASH_V1, rt as FIXED_IDX_MEMORY_MEMORIES_CONTENT_HASH, s as REM_SIDECAR_HOST, sn as llmRoutingConfigSchema, sr as MULTI_HIT_BONUS_PER_HIT, st as FIXED_IDX_MEMORY_MEMORIES_PROJECT_CONTENT_HASH, tn as FIXED_VEC_MEMORY_CHUNKS, tr as MAX_LIST_LIMIT, tt as FIXED_IDX_MEMORY_ACTIVE_TASK_INSTANCES_PROJECTION, un as ADJACENCY_BONUS_CAP, ut as FIXED_MEMORY, vn as BONUS_TOTAL_INVARIANT, vt as FIXED_MEMORY_CHUNKS_AD, wn as CHUNK_TARGET_TOKENS, wr as LOCAL_EMBEDDING_CACHE_DIR_DEFAULT, wt as FIXED_MEMORY_CHUNKS_MEM_IDX, xn as CHUNK_MAX_TOKENS, xr as experimentMmrDisabled, xt as FIXED_MEMORY_CHUNKS_FTS, yn as CACHE_TTL_MS, yt as FIXED_MEMORY_CHUNKS_AI, zn as EVAL_QA_TRACES_FILENAME, zt as FIXED_MEMORY_UNPLACED_CANDIDATES } from "./config-BWHnCb_Z.js";
+import { $ as FIXED_IDX_MEMORY_ACTIVE_TASK_CURRENT_REVISION, $n as MAX_CHUNK_FETCH_LIMIT, A as modelCallDestination, At as FIXED_MEMORY_PROFILE_RECOVERY_ENTRIES, B as FIXED_EXTERNAL_VALUE_49, C as getSnoStationMemStateDir, Cn as CHUNK_OVERLAP_TOKENS, Cr as LOCAL_EMBEDDING_CACHE_DIR_DEFAULT, Ct as FIXED_MEMORY_CHUNKS_MEM_FACET_IDX, D as settingsToPluginConfig, Dn as DEFAULT_IMPORTANCE, Dr as ensureModelDownloaded, Dt as FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD, En as DEFAULT_BM25_WEIGHT, Er as LocalEmbedProvider, Et as FIXED_MEMORY_MEMORIES, Fn as EMBEDDER_DIM, Fr as REM_SIDECAR_TOKEN_HEADER, G as FIXED_EXTERNAL_VALUE_55, H as FIXED_EXTERNAL_VALUE_52, Hn as HEAD_EXTRACT_OVERLAP_DROP_RATIO, In as EMBEDDER_MODEL_DEFAULT, It as FIXED_MEMORY_SNO_EXTRACT_CHAT, J as FIXED_EXTERNAL_VALUE_58, Jn as LIGHTWEIGHT_FUSION_WEIGHT, K as FIXED_EXTERNAL_VALUE_56, Kn as INTRA_MEMORY_COSINE_THRESHOLD, Kt as FIXED_PROTOCOL_VALUE_69, Ln as EMBEDDER_PROVIDER_DEFAULT, Mn as DEFAULT_RERANK_TIMEOUT_MS, Mt as FIXED_MEMORY_PROVIDER_PROJECT_AGENTS, Nt as FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS, O as MODEL_CALLS, On as DEFAULT_RECALL_LIFECYCLE, Ot as FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD, P as observeAgentId, Pn as DEFAULT_VECTOR_WEIGHT, Q as FIXED_IDX_MEMORY, Rn as EVAL_QA_TRACES_FILENAME, Rt as FIXED_MEMORY_TASK_LIFECYCLE_COMMANDS, Sn as CHUNK_MIN_TOKENS, Sr as CachedEmbeddingProvider, St as FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX, T as readSettings, Tn as CHUNK_TOKENIZER_MODE, Tt as FIXED_MEMORY_EXTRACTION_TIMESTAMPS, U as FIXED_EXTERNAL_VALUE_53, Un as HEAD_EXTRACT_TOKEN_BUDGET, V as FIXED_EXTERNAL_VALUE_51, Vn as HEAD_EXTRACT_MIN_CONTENT_TOKENS, W as FIXED_EXTERNAL_VALUE_54, Wn as IMPORTANCE_WEIGHT_BASE, X as FIXED_EXTERNAL_VALUE_8, Y as FIXED_EXTERNAL_VALUE_62, Yn as LIGHTWEIGHT_RERANK_PENALTY, Z as FIXED_EXTERNAL_VALUE_9, _t as FIXED_MEMORY_CHUNKS, a as REM_MODEL_OUTPUT_TOKEN_CAP, an as PERSISTED_PROVIDER_SYSTEM, ar as MULTI_HIT_BONUS_CAP, at as FIXED_IDX_MEMORY_MEMORIES_LANE_PROJECT, bn as CHUNKING_VERSION$1, br as experimentMmrDisabled, bt as FIXED_MEMORY_CHUNKS_AU, cn as SUPPORTED_LOCALES, cr as RECENCY_WEIGHT, ct as FIXED_IDX_MEMORY_MEMORIES_PROJECT_FACT_KEY_ACTIVE, d as getRemDiscoveryPath, dn as ADJACENCY_BONUS_PER_PAIR, dr as RERANK_BLEND_CROSS, dt as FIXED_MEMORY_ACTIVE_TASK_EVIDENCE, en as FIXED_VEC_MEMORY, er as MAX_LIST_LIMIT, et as FIXED_IDX_MEMORY_ACTIVE_TASK_EVIDENCE_INSTANCE, fr as RERANK_BLEND_VECTOR, ft as FIXED_MEMORY_ACTIVE_TASK_INSTANCES, g as readRemOperationalConfig, gt as FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS, hr as TIME_DECAY_FLOOR, ht as FIXED_MEMORY_ACTIVE_TASK_REVISIONS, in as PERSISTED_CONTENT_HASH_V3, ir as MMR_LAMBDA, it as FIXED_IDX_MEMORY_MEMORIES_FACT_ID, jt as FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS, k as MODEL_CALL_WORKLOAD, kt as FIXED_MEMORY_MIGRATION_MARKERS, lt as FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP, mt as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_MANIFESTS, nn as PERSISTED_CANDIDATE_HASH_V1, nt as FIXED_IDX_MEMORY_MEMORIES_CATEGORY, o as REM_RUN_PATH, or as MULTI_HIT_BONUS_PER_HIT, ot as FIXED_IDX_MEMORY_MEMORIES_PROJECT, pr as RETRIEVAL_STORAGE_CHUNK_PROFILE, pt as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_EVIDENCE, q as FIXED_EXTERNAL_VALUE_57, qn as LIGHTWEIGHT_COSINE_WEIGHT, qt as FIXED_PROTOCOL_VALUE_73, r as REM_CORRELATION_ID_HEADER, rn as PERSISTED_CONTENT_HASH_V1, rt as FIXED_IDX_MEMORY_MEMORIES_CONTENT_HASH, s as REM_SIDECAR_HOST, sn as llmRoutingConfigSchema, st as FIXED_IDX_MEMORY_MEMORIES_PROJECT_CONTENT_HASH, tn as FIXED_VEC_MEMORY_CHUNKS, tt as FIXED_IDX_MEMORY_ACTIVE_TASK_INSTANCES_PROJECTION, un as ADJACENCY_BONUS_CAP, ut as FIXED_MEMORY, vn as BONUS_TOTAL_INVARIANT, vt as FIXED_MEMORY_CHUNKS_AD, wn as CHUNK_TARGET_TOKENS, wr as LOCAL_EMBEDDING_MODEL, wt as FIXED_MEMORY_CHUNKS_MEM_IDX, xn as CHUNK_MAX_TOKENS, xt as FIXED_MEMORY_CHUNKS_FTS, yn as CACHE_TTL_MS, yr as experimentCandidatePoolOverride, yt as FIXED_MEMORY_CHUNKS_AI, zt as FIXED_MEMORY_UNPLACED_CANDIDATES } from "./config-C1X5rsAx.js";
 import { createLogger, createLogger as createLogger$1, currentLogContext, privateLogReference, withLogContext } from "@snoai/utils/logger";
 import path, { dirname, join, resolve } from "node:path";
 import { appendFileSync, closeSync, createReadStream, existsSync, fstatSync, fsyncSync, ftruncateSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
@@ -171,10 +171,11 @@ async function forwardObserveLedgerUntilIdle(options) {
 const operations = new AsyncLocalStorage();
 const log$23 = createLogger("sno-station-mem:cancellation");
 /** Carries cancellation through the existing nested extraction and reflection writers. */
-async function withMemoryOperation(method, signal, run) {
+async function withMemoryOperation(method, signal, run, deadlineMs) {
 	const operation = {
 		id: randomUUID(),
 		signal,
+		deadlineMs,
 		writes: 0,
 		transactionDepth: 0
 	};
@@ -201,6 +202,10 @@ async function withMemoryOperation(method, signal, run) {
 function memoryOperationId() {
 	return operations.getStore()?.id;
 }
+/** The owning operation's absolute performance.now() deadline, shared by all extraction calls. */
+function memoryOperationDeadline() {
+	return operations.getStore()?.deadlineMs;
+}
 function memoryOperationSignal(signal) {
 	const request = operations.getStore()?.signal;
 	if (!request) return signal;
@@ -7326,7 +7331,14 @@ function createLlmClient(config) {
 	});
 	let lastError = null;
 	let lastUsage = null;
-	const resolveRequestTimeoutMs = (request) => request.timeoutMs ?? config.timeoutMs ?? 3e4;
+	const resolveRequestTimeoutMs = (request) => {
+		if (destinationFor(request) !== "sno-gpu" || !request.callId.startsWith("E") || MODEL_CALLS[request.callId].occasion !== "memoryExtract") return request.timeoutMs ?? config.timeoutMs ?? 3e4;
+		const operationDeadline = memoryOperationDeadline();
+		if (operationDeadline === void 0) return request.timeoutMs ?? 3e5;
+		const remainingMs = operationDeadline - performance.now();
+		if (remainingMs <= 0) throw new LlmClientTerminalError("timeout", "Memory operation deadline exhausted before extraction");
+		return Math.min(request.timeoutMs ?? remainingMs, remainingMs);
+	};
 	const destinationFor = (request) => {
 		if (!config.routing) return "host";
 		const route = resolveLlmRoute({
@@ -7396,20 +7408,23 @@ function createLlmClient(config) {
 				destination,
 				transport
 			});
+			const hostTimeoutMs = resolveRequestTimeoutMs(request);
 			const hostStarted = performance.now();
 			const hostInFlight = ++hostRequestsInFlight;
 			const result = await withLogContext({ attempt_id: randomUUID() }, async () => {
 				let outcome = "failed";
+				let hostReport = {};
 				try {
 					const completion = await agentPort.complete({
 						system: systemContent,
 						prompt,
 						maxTokens: request.maxTokens ?? 4096,
 						...request.enableThinking !== void 0 ? { enableThinking: request.enableThinking } : {},
-						timeoutMs: resolveRequestTimeoutMs(request),
+						timeoutMs: hostTimeoutMs,
 						...request.signal ? { signal: request.signal } : {}
 					});
 					outcome = completion.kind;
+					if (completion.kind === "ok") hostReport = completion;
 					return completion;
 				} finally {
 					hostRequestsInFlight -= 1;
@@ -7421,27 +7436,32 @@ function createLlmClient(config) {
 						duration_ms: performance.now() - hostStarted,
 						in_flight_at_dispatch: hostInFlight,
 						requested_model: "unavailable",
-						returned_model: "unavailable",
-						usage: { source: "unavailable" },
+						returned_model: hostReport.model ?? "unavailable",
+						usage: hostReport.usage ? {
+							source: "provider_reported",
+							inputTokens: hostReport.usage.inputTokens,
+							outputTokens: hostReport.usage.outputTokens,
+							totalTokens: hostReport.usage.inputTokens + hostReport.usage.outputTokens
+						} : { 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)
+							timeoutMs: hostTimeoutMs
 						})).digest("hex"),
 						output_cap: "unavailable",
 						passed_output_cap: request.maxTokens ?? 4096,
 						output_cap_reason: "host_may_strip_requested_cap",
-						timeout_ms: resolveRequestTimeoutMs(request),
+						timeout_ms: hostTimeoutMs,
 						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"
+						...hostReport.usage || hostReport.model ? {} : { provider_unavailable_reason: "host_port_does_not_report_provider_fields" }
 					}, {
 						event_name: "llm.request.completed",
 						file: "packages/memory/src/model/llm-client.ts",
@@ -7759,7 +7779,8 @@ function createLlmClient(config) {
 				signal: memoryOperationSignal(input.signal)
 			});
 			checkMemoryOperation();
-			const deadlineMs = performance.now() + resolveRequestTimeoutMs(request);
+			request.timeoutMs = resolveRequestTimeoutMs(request);
+			const deadlineMs = performance.now() + request.timeoutMs;
 			try {
 				let content = await requestContentWithHostFallback(state, request, JSON_SYSTEM_CONTENT, deadlineMs);
 				if (content === null) return null;
@@ -7832,7 +7853,8 @@ function createLlmClient(config) {
 				signal: memoryOperationSignal(input.signal)
 			});
 			checkMemoryOperation();
-			const deadlineMs = performance.now() + resolveRequestTimeoutMs(request);
+			request.timeoutMs = resolveRequestTimeoutMs(request);
+			const deadlineMs = performance.now() + request.timeoutMs;
 			try {
 				const text = (await requestContentWithHostFallback(state, request, textSystemContent(request), deadlineMs))?.raw.trim();
 				return text && text.length > 0 ? text : null;
@@ -27179,9 +27201,7 @@ const DEFAULT_RETRIEVAL_CONFIG = {
 	recencyWeight: RECENCY_WEIGHT,
 	temporalExpiry: false,
 	temporalDecay: true,
-	rerankModel: DEFAULT_RERANK_MODEL,
 	rerankTimeoutMs: DEFAULT_RERANK_TIMEOUT_MS,
-	rerankProvider: "voyage",
 	lengthNormAnchor: 0,
 	hardMinScore: 0,
 	timeDecayHalfLifeDays: 60,
@@ -27478,13 +27498,15 @@ Object.assign(MemoryRetriever.prototype, {
 			site_id: "retrieval.retriever-search-modes.precisionRecall.aaf0b2eb17"
 		});
 		trace?.startStage("rerank", fused.map((r) => r.entry.id));
-		const rerankOutcome = await this.rerank(context.query, fused, queryVector);
+		const rerankOutcome = await this.rerank(context.query, fused, queryVector, {
+			signal: context.signal,
+			deadlineAt: context.rerankDeadlineAt
+		});
 		fused = rerankOutcome.candidates;
 		this.throwIfAborted(context);
 		const rerankStageMetadata = rerankOutcome.fallback ? {
 			...rerankOutcome.stats,
-			rerankFallbackReason: rerankOutcome.fallback.reason,
-			rerankFallbackProvider: rerankOutcome.fallback.provider
+			rerankFallbackReason: rerankOutcome.fallback.reason
 		} : rerankOutcome.stats;
 		trace?.endStage(fused.map((r) => r.entry.id), fused.map((r) => r.score), rerankStageMetadata);
 		fused = this.applyScoringPipeline(fused, trace, context.limit);
@@ -27556,95 +27578,31 @@ Object.assign(MemoryRetriever.prototype, {
 });
 //#endregion
 //#region src/engine/retrieval/retrieval-rerank-provider.ts
-/** @file retrieval-rerank-provider.ts
-* @purpose Adapts external rerank provider request and response formats.
-* @boundary HTTP payload shaping and response parsing only.
-*/
-const RERANK_DEFAULT_ENDPOINTS = {
-	voyage: "https://api.voyageai.com/v1/rerank",
-	jina: "https://api.jina.ai/v1/rerank",
-	pinecone: "https://api.pinecone.io/rerank",
-	dashscope: "https://dashscope.aliyuncs.com/api/v1/services/rerank"
-};
-function buildRerankHttpError(status) {
-	if (classifyLlmFailure({ status }).category === "auth") return new RetrievalError(`Rerank API failed with status ${status}`);
-}
-function buildRerankRequest(provider, apiKey, model, query, candidates, topN) {
-	switch (provider) {
-		case "tei": return {
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${apiKey}`
-			},
-			body: {
-				query,
-				texts: candidates,
-				raw_scores: true
-			}
-		};
-		case "dashscope": return {
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${apiKey}`
-			},
-			body: {
-				model,
-				input: {
-					query,
-					documents: candidates
-				}
-			}
-		};
-		case "pinecone": return {
-			headers: {
-				"Content-Type": "application/json",
-				"Api-Key": apiKey,
-				"X-Pinecone-API-Version": "2024-10"
-			},
-			body: {
-				model,
-				query,
-				documents: candidates.map((text) => ({ text })),
-				top_n: topN,
-				rank_fields: ["text"]
-			}
-		};
-		case "voyage": return {
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${apiKey}`
-			},
-			body: {
-				model,
-				query,
-				documents: candidates,
-				top_k: topN
-			}
-		};
-		default: return {
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${apiKey}`
-			},
-			body: {
-				model,
-				query,
-				documents: candidates,
-				top_n: topN
-			}
-		};
-	}
+function buildRerankRequest(apiKey, query, candidates) {
+	return {
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`,
+			"X-Sno-Source": "sno-station",
+			"X-Sno-Workload": "station-rerank"
+		},
+		body: {
+			query,
+			texts: candidates,
+			raw_scores: true
+		}
+	};
 }
-function parseRerankResponse(provider, data) {
-	/** Parses items into the normalized shape used by precision recall retrieval ranking. */
-	const parseItems = (items, scoreKeys) => {
+/** Sno's reranker answers a list of `{index, score}`, bare or under `results` / `data`. */
+function parseRerankResponse(data) {
+	const parseItems = (items) => {
 		if (!Array.isArray(items)) return void 0;
 		const parsed = [];
 		for (const raw of items) {
 			const index = typeof raw?.index === "number" ? raw.index : Number(raw?.index);
 			if (!Number.isFinite(index)) continue;
 			let score;
-			for (const key of scoreKeys) {
+			for (const key of ["score", "relevance_score"]) {
 				const value = raw?.[key];
 				const n = typeof value === "number" ? value : Number(value);
 				if (Number.isFinite(n)) {
@@ -27661,17 +27619,7 @@ function parseRerankResponse(provider, data) {
 		return parsed.length > 0 ? parsed : void 0;
 	};
 	const objectData = data && typeof data === "object" && !Array.isArray(data) ? data : void 0;
-	switch (provider) {
-		case "tei": return parseItems(data, ["score", "relevance_score"]) ?? parseItems(objectData?.results, ["score", "relevance_score"]) ?? parseItems(objectData?.data, ["score", "relevance_score"]);
-		case "dashscope": {
-			const output = objectData?.output;
-			if (output) return parseItems(output.results, ["relevance_score", "score"]);
-			return parseItems(objectData?.results, ["relevance_score", "score"]);
-		}
-		case "pinecone": return parseItems(objectData?.data, ["score", "relevance_score"]) ?? parseItems(objectData?.results, ["score", "relevance_score"]);
-		case "voyage": return parseItems(objectData?.data, ["relevance_score", "score"]) ?? parseItems(objectData?.results, ["relevance_score", "score"]);
-		default: return parseItems(objectData?.results, ["relevance_score", "score"]) ?? parseItems(objectData?.data, ["relevance_score", "score"]);
-	}
+	return parseItems(data) ?? parseItems(objectData?.results) ?? parseItems(objectData?.data);
 }
 //#endregion
 //#region src/engine/retrieval/retriever-rerank.ts
@@ -27734,16 +27682,14 @@ function isTransientRerankError(error) {
 	if (isRerankTimeout(error)) return true;
 	return error instanceof TypeError && error.cause !== void 0;
 }
-async function fetchRerankWithRetry(send) {
+async function fetchRerankWithRetry(send, stop) {
 	let lastError;
 	for (let attempt = 1; attempt <= RERANK_TRANSIENT_ATTEMPTS; attempt += 1) {
 		let retryDelayMs = RERANK_TRANSIENT_BACKOFF_MS * attempt;
 		try {
-			const response = await send();
-			if (response.ok) return {
-				response,
-				data: await response.json()
-			};
+			const reply = await send();
+			const { response } = reply;
+			if (response.ok) return reply;
 			if (!RERANK_TRANSIENT_STATUSES.has(response.status) || attempt === RERANK_TRANSIENT_ATTEMPTS) return { response };
 			if (response.status === 429) {
 				const retryAfter = response.headers.get("retry-after");
@@ -27752,37 +27698,48 @@ async function fetchRerankWithRetry(send) {
 			await response.body?.cancel();
 			lastError = /* @__PURE__ */ new Error(`rerank API responded ${response.status}`);
 		} catch (error) {
-			if (!isTransientRerankError(error) || attempt === RERANK_TRANSIENT_ATTEMPTS) throw error;
+			if (!isTransientRerankError(error) || attempt === RERANK_TRANSIENT_ATTEMPTS || stop?.aborted) throw error;
 			lastError = error;
 		}
-		await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+		if (stop?.aborted) throw lastError;
+		await new Promise((resolve) => {
+			const onAbort = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			const timer = setTimeout(() => {
+				stop?.removeEventListener("abort", onAbort);
+				resolve();
+			}, retryDelayMs);
+			stop?.addEventListener("abort", onAbort, { once: true });
+		});
+		if (stop?.aborted) throw lastError;
 	}
 	throw lastError;
 }
 Object.assign(MemoryRetriever.prototype, {
-	async rerank(query, candidates, queryVector) {
+	async rerank(query, candidates, queryVector, options) {
 		if (candidates.length === 0) return { candidates };
 		if (this.config.rerank === "none") return { candidates };
-		const provider = this.config.rerankProvider ?? "none";
-		if (this.config.rerank === "cross-encoder" && !this.config.rerankApiKey) throw new RetrievalError(`rerank "cross-encoder" requires retrieval.rerankApiKey (provider: ${provider}); set the key, or set retrieval.rerank to "lightweight" to choose the local ranker`);
+		const unranked = () => this.rerankLightweight(candidates, queryVector);
+		if (this.config.rerank === "cross-encoder" && !this.config.rerankApiKey) throw new RetrievalError("rerank \"cross-encoder\" requires retrieval.rerankApiKey; set the key, or set retrieval.rerank to \"lightweight\" to choose the local ranker");
 		if (this.config.rerank === "lightweight" || !this.config.rerankApiKey) return { candidates: this.rerankLightweight(candidates, queryVector) };
-		const rerankEndpoint = this.config.rerankEndpoint ?? RERANK_DEFAULT_ENDPOINTS[provider];
+		const rerankEndpoint = this.config.rerankEndpoint;
 		if (!rerankEndpoint) {
-			log$4.warn("rerank skipped: no endpoint for provider", { provider }, {
+			log$4.warn("rerank skipped: no reranker address", {}, {
 				event_name: "memory.retriever_rerank.diagnostic",
 				file: "packages/memory/src/engine/retrieval/retriever-rerank.ts",
 				function: "rerank",
 				site_id: "retrieval.retriever-rerank.rerank.6fbc6b3a22"
 			});
 			return {
-				candidates,
-				fallback: {
-					reason: "no_endpoint",
-					provider
-				}
+				candidates: unranked(),
+				fallback: { reason: "no_endpoint" }
 			};
 		}
 		const rerankTimeoutMs = this.config.rerankTimeoutMs ?? 15e3;
+		const stepBudget = AbortSignal.timeout(Math.max(0, Math.floor(options?.deadlineAt === void 0 ? rerankTimeoutMs : options.deadlineAt - Date.now())));
+		const stepStop = options?.signal ? AbortSignal.any([options.signal, stepBudget]) : stepBudget;
 		const rerankApiKey = this.config.rerankApiKey;
 		const maxCandidates = this.config.rerankMaxCandidates;
 		const overCap = maxCandidates !== void 0 && candidates.length > maxCandidates;
@@ -27803,11 +27760,8 @@ Object.assign(MemoryRetriever.prototype, {
 				site_id: "retrieval.retriever-rerank.rerank.query_over_window"
 			});
 			return {
-				candidates,
-				fallback: {
-					reason: "query_over_window",
-					provider
-				}
+				candidates: unranked(),
+				fallback: { reason: "query_over_window" }
 			};
 		}
 		let truncatedCandidates = 0;
@@ -27830,17 +27784,54 @@ Object.assign(MemoryRetriever.prototype, {
 			const runBatch = async (start) => {
 				let batchTexts = rerankTexts.slice(start, start + batchSize);
 				for (let pass = 0;; pass += 1) {
-					const { headers, body } = buildRerankRequest(provider, rerankApiKey, this.config.rerankModel ?? "rerank-2", query, batchTexts, batchTexts.length);
-					const { response, data } = await fetchRerankWithRetry(() => fetch(rerankEndpoint, {
-						method: "POST",
-						headers,
-						body: JSON.stringify(body),
-						signal: AbortSignal.timeout(rerankTimeoutMs)
-					}));
+					const { headers, body } = buildRerankRequest(rerankApiKey, query, batchTexts);
+					const sendAttempt = async () => {
+						const clientRequestId = randomUUID();
+						const attemptStarted = performance.now();
+						let outcome = "failed";
+						let statusCode;
+						try {
+							const attempt = await fetch(rerankEndpoint, {
+								method: "POST",
+								headers: {
+									...headers,
+									"X-Request-ID": clientRequestId
+								},
+								body: JSON.stringify(body),
+								signal: AbortSignal.any([AbortSignal.timeout(rerankTimeoutMs), stepStop])
+							});
+							statusCode = attempt.status;
+							if (!attempt.ok) {
+								outcome = "http_error";
+								return { response: attempt };
+							}
+							const data = await attempt.json();
+							outcome = "success";
+							return {
+								response: attempt,
+								data
+							};
+						} catch (error) {
+							outcome = isRerankTimeout(error) ? "timeout" : "failed";
+							throw error;
+						} finally {
+							log$4.info("Rerank request completed", {
+								outcome,
+								status_code: statusCode ?? "unavailable",
+								duration_ms: performance.now() - attemptStarted,
+								texts_sent: batchTexts.length,
+								client_request_id: clientRequestId
+							}, {
+								event_name: "rerank.request.completed",
+								file: "packages/memory/src/engine/retrieval/retriever-rerank.ts",
+								function: "runBatch",
+								site_id: "rerank.request.completed"
+							});
+						}
+					};
+					const { response, data } = await fetchRerankWithRetry(sendAttempt, stepStop);
 					if (!response.ok) {
 						const retryAfter = response.headers.get("retry-after");
-						const fatalError = buildRerankHttpError(response.status);
-						if (fatalError) throw fatalError;
 						const errorBody = await response.text().catch(() => "<unreadable body>");
 						const refusal = pass === 0 ? parseOverWindowRefusal(errorBody) : void 0;
 						if (refusal) {
@@ -27882,10 +27873,9 @@ Object.assign(MemoryRetriever.prototype, {
 						});
 						return "http_error";
 					}
-					const parsed = parseRerankResponse(provider, data);
+					const parsed = parseRerankResponse(data);
 					if (!parsed) {
 						log$4.warn("rerank API returned unparseable response", {
-							provider,
 							endpoint_hash: createHash("sha256").update(rerankEndpoint).digest("hex"),
 							batchStart: start
 						}, {
@@ -27916,11 +27906,8 @@ Object.assign(MemoryRetriever.prototype, {
 				for (const outcome of settled) if (outcome.status === "rejected" && outcome.reason instanceof RetrievalError) throw outcome.reason;
 				for (const outcome of settled) if (outcome.status === "rejected") throw outcome.reason;
 				for (const outcome of settled) if (outcome.status === "fulfilled" && typeof outcome.value === "string") return {
-					candidates,
-					fallback: {
-						reason: outcome.value,
-						provider
-					}
+					candidates: unranked(),
+					fallback: { reason: outcome.value }
 				};
 				for (const outcome of settled) if (outcome.status === "fulfilled" && typeof outcome.value !== "string") items.push(...outcome.value);
 			}
@@ -27935,9 +27922,7 @@ Object.assign(MemoryRetriever.prototype, {
 				const candidate = toRerank[item.index];
 				if (!candidate) continue;
 				const sourceScore = this.getRerankSourceScore(candidate);
-				let crossScore = item.score;
-				if (provider === "tei") crossScore = 1 / (1 + Math.exp(-item.score));
-				const blendedScore = clamp01(crossScore * blendCross + sourceScore * blendVector, 0);
+				const blendedScore = clamp01(1 / (1 + Math.exp(-item.score)) * blendCross + sourceScore * blendVector, 0);
 				reranked.push({
 					...candidate,
 					score: blendedScore,
@@ -27955,8 +27940,7 @@ Object.assign(MemoryRetriever.prototype, {
 			log$4.debug("reranked", {
 				totalCandidateCount: candidates.length,
 				sentToRerankCount: toRerank.length,
-				returnedCount: reranked.length,
-				provider
+				returnedCount: reranked.length
 			}, {
 				event_name: "memory.retriever_rerank.diagnostic",
 				file: "packages/memory/src/engine/retrieval/retriever-rerank.ts",
@@ -27998,11 +27982,8 @@ Object.assign(MemoryRetriever.prototype, {
 				});
 			}
 			return {
-				candidates,
-				fallback: {
-					reason,
-					provider
-				}
+				candidates: unranked(),
+				fallback: { reason }
 			};
 		}
 	},

package/dist/{retriever-DyxY59Lg.d.ts → retriever-6ybsoVuY.d.ts}

@@ -1,13 +1,13 @@
-import { h as MemoryCategory, l as DecayScore, r as AggregationQuery, u as DecayableMemory, x as RetrievalResult, y as MemorySearchResult } from "./types-Ae3a8562.js";
-import { sn as RecallLifecycleConfig } from "./index-Pb9LrHgL.js";
+import { h as MemoryCategory, l as DecayScore, r as AggregationQuery, u as DecayableMemory, x as RetrievalResult, y as MemorySearchResult } from "./types-Dm_XhSne.js";
+import { on as RecallLifecycleConfig } from "./index-8CfO_-6T.js";
 import { t as Embedder } from "./embedding-provider-client-vynZMuit.js";
 import "./trace-C1JxMfs-.js";
-import "./memory-metadata-codec-wVAuoKrG.js";
+import "./memory-metadata-codec-CFY8YtXf.js";
 import { K as RemFacetPolicy } from "./index-DPfJrOFD.js";
-import { C as MemoryStore } from "./memory-store-base-Bk2dOKED.js";
-import "./store-BDIAl2cc.js";
-import { n as AccessTracker } from "./access-tracker-BOPHSJjf.js";
-import { r as TierPromoter } from "./memory-tier-promoter-MkZPQ8u1.js";
+import { C as MemoryStore } from "./memory-store-base-D0bLwzyF.js";
+import "./store-HyzTUvwj.js";
+import { n as AccessTracker } from "./access-tracker-DT04huAG.js";
+import { r as TierPromoter } from "./memory-tier-promoter-Cf1OdoZK.js";
 import "@snoai/utils/logger";
 //#region src/engine/retrieval/retrieval-trace.d.ts
 /** @file retrieval-trace.ts
@@ -209,7 +209,6 @@ declare class RetrievalStatsCollector {
 }
 //#endregion
 //#region src/engine/retrieval/retrieval-config.d.ts
-type RerankProvider = "jina" | "siliconflow" | "voyage" | "pinecone" | "dashscope" | "tei";
 interface RetrievalConfig {
   /** Enable the historical recency, decay, and retention score transforms. */
   temporalWeighting: boolean;
@@ -228,7 +227,6 @@ interface RetrievalConfig {
   /** Dynamic memories decay 3× faster in time-decay scoring (default ON) */
   temporalDecay: boolean;
   rerankApiKey?: string;
-  rerankModel?: string;
   rerankTimeoutMs?: number;
   lengthNormAnchor: number;
   hardMinScore: number;
@@ -247,15 +245,10 @@ interface RetrievalConfig {
   timeDecayFloor?: number;
   /** Relevance vs diversity tradeoff (default: 0.7) */
   mmrLambda?: number;
-  /** Custom rerank API endpoint URL */
+  /** Address of Sno's reranker (the Sno GPU address plus `/rerank`) */
   rerankEndpoint?: string;
-  /** Rerank provider name */
-  rerankProvider?: RerankProvider | string;
   /**
-   * Hard cap on how many candidates are sent to the cross-encoder rerank API
-   * in one request. Some rerank deployments (e.g. this repo's Sno TEI
-   * reranker) reject a batch above a fixed size instead of truncating it, so
-   * an unset value here must never silently violate that limit. Candidates
+   * Cap on how many candidates are sent to Sno's reranker in total. Candidates
    * beyond the cap are NOT dropped — they still flow through the standard
    * `unreturned` preservation-floor path, same as a real reranker choosing
    * not to return them.
@@ -288,6 +281,8 @@ interface RetrievalContext {
    */
   includeRefused?: boolean;
   signal?: AbortSignal;
+  /** The time (ms since the epoch) by which a Sno reranker must have finished, retries included, before recall falls back to local ranking; set by callers that have a deadline. */
+  rerankDeadlineAt?: number;
   sessionId?: string;
   explicitLocale?: string;
   /** Retrieval source: "manual" for user-triggered, "auto-recall" for system-initiated, "cli" for CLI commands */
@@ -359,12 +354,10 @@ interface RetentionScorer {
  *
  * - `missing_api_key`: cross-encoder configured but no rerankApiKey set;
  *   call routes through the lightweight cosine path instead.
- * - `no_endpoint`: provider has no known endpoint in `RERANK_DEFAULT_ENDPOINTS`
- *   and `rerankEndpoint` was not overridden; rerank was skipped.
- * - `http_error`: provider responded with a non-OK status that did not map
- *   to a fatal RetrievalError (i.e. degraded but not propagated).
- * - `invalid_response`: provider HTTP 2xx but response shape did not parse.
- * - `timeout`: the per-call AbortSignal fired before the provider responded.
+ * - `no_endpoint`: no reranker address (`rerankEndpoint`) was set; rerank was skipped.
+ * - `http_error`: the reranker responded with a non-OK status.
+ * - `invalid_response`: the reranker answered HTTP 2xx but the response shape did not parse.
+ * - `timeout`: the per-call AbortSignal fired before the reranker responded.
  * - `request_error`: any other thrown error inside the fetch path.
  * - `query_over_window`: the query alone fills the reranker's per-pair token window, so no
  *   document could be sent with it. Nothing was requested.
@@ -373,7 +366,6 @@ declare const RERANK_FALLBACK_REASONS: readonly ["missing_api_key", "no_endpoint
 type RerankFallbackReason = (typeof RERANK_FALLBACK_REASONS)[number];
 interface RerankFallbackSignal {
   reason: RerankFallbackReason;
-  provider: string;
 }
 interface RerankOutcome {
   candidates: RetrievalResult[];
@@ -452,7 +444,10 @@ interface MemoryRetrieverInternals {
   precisionRecall(context: RetrievalContext, trace?: TraceCollector): Promise<RetrievalResult[]>;
   aggregationComplete(context: RetrievalContext, trace?: TraceCollector): Promise<RetrievalResult[]>;
   rrfFuse(vector: MemorySearchResult[], keyword: MemorySearchResult[]): RetrievalResult[];
-  rerank(query: string, candidates: RetrievalResult[], queryVector: Float32Array): Promise<RerankOutcome>;
+  rerank(query: string, candidates: RetrievalResult[], queryVector: Float32Array, options?: {
+    signal?: AbortSignal;
+    deadlineAt?: number;
+  }): Promise<RerankOutcome>;
   rerankLightweight(candidates: RetrievalResult[], queryVector: Float32Array): RetrievalResult[];
   getRerankSourceScore(result: RetrievalResult): number;
   applyScoringPipeline(results: RetrievalResult[], trace?: TraceCollector, limit?: number): RetrievalResult[];
@@ -468,4 +463,4 @@ declare function createRetriever(store: MemoryStore, embedder: Embedder, logger?
   warn: (message: string, fields?: Record<string, unknown>) => void;
 }, config?: RetrievalConfig): MemoryRetriever;
 //#endregion
-export { RerankFallbackSignal as a, collectParallelStage as c, RetrievalConfig as d, RetrievalContext as f, RerankFallbackReason as i, DEFAULT_RETRIEVAL_CONFIG as l, MemoryRetrieverInternals as n, RerankOutcome as o, withServingValidityDefault as p, RERANK_FALLBACK_REASONS as r, createRetriever as s, MemoryRetriever as t, RerankProvider as u };
+export { RerankFallbackSignal as a, collectParallelStage as c, RetrievalContext as d, withServingValidityDefault as f, RerankFallbackReason as i, DEFAULT_RETRIEVAL_CONFIG as l, MemoryRetrieverInternals as n, RerankOutcome as o, RERANK_FALLBACK_REASONS as r, createRetriever as s, MemoryRetriever as t, RetrievalConfig as u };