@snoai/memory 0.0.0-stage → 1.0.1

package/dist/internal/engine/extraction/capture-policy-detector.d.ts

@@ -0,0 +1,2 @@
+import { a as EXPLICIT_MEMORY_COMMAND_MANAGEMENT_PATTERNS, c as PROMPT_INJECTION_PATTERNS, d as escapeMemoryForPrompt, f as formatRelevantMemoriesContext, i as DetectCategoryOptions, l as detectCategory, m as shouldCapture, n as CaptureDropReason, o as EXPLICIT_MEMORY_COMMAND_POSITIVE_PATTERNS, p as looksLikePromptInjection, r as CategoryVoteResult, s as EXPLICIT_MEMORY_COMMAND_RECALL_QUESTION_PATTERNS, t as CaptureDecision, u as detectCategoryVote } from "../../../capture-policy-detector-CxbHPkMX.js";
+export { CaptureDecision, CaptureDropReason, CategoryVoteResult, DetectCategoryOptions, EXPLICIT_MEMORY_COMMAND_MANAGEMENT_PATTERNS, EXPLICIT_MEMORY_COMMAND_POSITIVE_PATTERNS, EXPLICIT_MEMORY_COMMAND_RECALL_QUESTION_PATTERNS, PROMPT_INJECTION_PATTERNS, detectCategory, detectCategoryVote, escapeMemoryForPrompt, formatRelevantMemoriesContext, looksLikePromptInjection, shouldCapture };

package/dist/internal/engine/extraction/capture-policy-detector.js

@@ -0,0 +1,2 @@
+import { a as detectCategory, c as formatRelevantMemoriesContext, i as PROMPT_INJECTION_PATTERNS, l as looksLikePromptInjection, n as EXPLICIT_MEMORY_COMMAND_POSITIVE_PATTERNS, o as detectCategoryVote, r as EXPLICIT_MEMORY_COMMAND_RECALL_QUESTION_PATTERNS, s as escapeMemoryForPrompt, t as EXPLICIT_MEMORY_COMMAND_MANAGEMENT_PATTERNS, u as shouldCapture } from "../../../capture-policy-detector-DaMfy9CZ.js";
+export { EXPLICIT_MEMORY_COMMAND_MANAGEMENT_PATTERNS, EXPLICIT_MEMORY_COMMAND_POSITIVE_PATTERNS, EXPLICIT_MEMORY_COMMAND_RECALL_QUESTION_PATTERNS, PROMPT_INJECTION_PATTERNS, detectCategory, detectCategoryVote, escapeMemoryForPrompt, formatRelevantMemoriesContext, looksLikePromptInjection, shouldCapture };

package/dist/internal/engine/extraction/embedding-provider-client.d.ts

@@ -0,0 +1,2 @@
+import { i as EmbeddingProviderKind, n as createEmbedder, r as EmbeddingConfig, t as Embedder } from "../../../embedding-provider-client-vynZMuit.js";
+export { Embedder, type EmbeddingConfig, type EmbeddingProviderKind, createEmbedder };

package/dist/internal/engine/extraction/embedding-provider-client.js

@@ -0,0 +1,2 @@
+import { n as createEmbedder, t as Embedder } from "../../../embedding-provider-client-Q_hJonK9.js";
+export { Embedder, createEmbedder };

package/dist/internal/engine/extraction/extraction-text-sanitizer.d.ts

@@ -0,0 +1,2 @@
+import { n as buildIndexedText, r as stripEnvelopeMetadata, t as boundSectionContent } from "../../../extraction-text-sanitizer-B_AhIecT.js";
+export { boundSectionContent, buildIndexedText, stripEnvelopeMetadata };

package/dist/internal/engine/extraction/extraction-text-sanitizer.js

@@ -0,0 +1,114 @@
+import "../../config/index.js";
+import { wt as PERSISTED_PROVIDER_SYSTEM } from "../../../signed-registry-constants-yq3DlG3B.js";
+import { n as stripAmbientLearningInjectedPrefix, r as stripLeadingRuntimeWrappers } from "../../../ambient-learning-text-normalizer-CxjATmMp.js";
+import { createLogger } from "@snoai/utils/logger";
+import { sanitizeContentIngress } from "@snoai/content-sanitizer";
+//#region src/engine/extraction/extraction-text-sanitizer.ts
+/** @file extraction-text-sanitizer.ts
+* @purpose Normalize runtime payload text before it reaches memory extraction.
+* @boundary Removes channel/runtime envelope metadata only; does not classify or persist memories.
+*/
+const log = createLogger("sno-station-mem:extraction-text-sanitizer");
+/**
+* Keeps a section's clause list inside `DEFAULT_MAX_CONTEXT_TOKENS`, the repository-wide
+* per-record ceiling the store refuses to write past.
+*
+* A profile section is one row by design (`getByFactKey` is singular), and merging appends, so
+* a long-lived section grows without bound — measured 2026-09-14 on a real persona store, five
+* successive versions of `preferences.general` ran 516 → 533 → 538 → 540 → 576 tokens. Past the
+* ceiling the embedder and the reranker both truncate silently, so the tail of such a section is
+* already invisible to retrieval; dropping it here is the same loss made honest, and it keeps the
+* merge writing instead of throwing.
+*
+* Oldest clauses go first: `mergeProfileSection` seeds the map with the stored clauses and then
+* the incoming ones, so insertion order runs oldest to newest. The abstract is kept whatever
+* happens — it is the section's only summary and it leads the indexed text.
+*/
+function boundSectionContent(content, abstract, countRecordTokens) {
+	if (countRecordTokens(buildIndexedText(abstract, content)) <= 512) return content;
+	const clauses = content.split("\n");
+	let first = 0;
+	while (first < clauses.length && countRecordTokens(buildIndexedText(abstract, clauses.slice(first).join("\n"))) > 512) first += 1;
+	const kept = clauses.slice(first).join("\n");
+	log.warn("profile section trimmed to the record token ceiling", {
+		droppedClauses: first,
+		keptClauses: clauses.length - first,
+		maxTokens: 512
+	}, {
+		event_name: "memory.extraction_text_sanitizer.diagnostic",
+		file: "packages/memory/src/engine/extraction/extraction-text-sanitizer.ts",
+		function: "boundSectionContent",
+		site_id: "extraction.extraction-text-sanitizer.boundSectionContent.ceiling"
+	});
+	return kept;
+}
+/**
+* Build the string that goes into the `text` column of `nodix_memories`.
+*
+* The FTS5 BM25 index is derived from this column only (see
+* drizzle/0001_virtual_tables.sql). Concatenating abstract and content gives
+* BM25 the same source surface used for vector embedding.
+*/
+function buildIndexedText(abstract, content) {
+	const trimmed = content.trim();
+	if (!trimmed || trimmed === abstract.trim()) return abstract;
+	return `${abstract}\n${trimmed}`;
+}
+function isLikelyDelimitedMetadataLine(line) {
+	const trimmed = line?.trim();
+	if (!trimmed) return false;
+	if (/^(?:sender token|hidden starter|private context)\b/i.test(trimmed)) return true;
+	if (/^(?:sender|message|conversation|thread|channel|workspace|timestamp|created_at|replied message)\b/i.test(trimmed)) return true;
+	if (/^[{[\]},]+$/.test(trimmed)) return true;
+	if (/^"[^"]+"\s*:/.test(trimmed)) return true;
+	return false;
+}
+function stripDelimitedMetadataBlock(text, headerPattern) {
+	const lines = text.split("\n");
+	const kept = [];
+	for (let idx = 0; idx < lines.length; idx += 1) {
+		const line = lines[idx];
+		if (!line || !headerPattern.test(line)) {
+			kept.push(line ?? "");
+			continue;
+		}
+		let scanIdx = idx + 1;
+		while (scanIdx < lines.length && lines[scanIdx]?.trim() !== "") scanIdx += 1;
+		if (scanIdx >= lines.length) {
+			let fallbackIdx = idx + 1;
+			while (fallbackIdx < lines.length && isLikelyDelimitedMetadataLine(lines[fallbackIdx])) fallbackIdx += 1;
+			idx = fallbackIdx - 1;
+			continue;
+		}
+		while (scanIdx < lines.length && lines[scanIdx]?.trim() === "") scanIdx += 1;
+		idx = scanIdx - 1;
+	}
+	return kept.join("\n");
+}
+/**
+* Strip platform envelope metadata injected by SnoStationMem channels before the
+* conversation text reaches the extraction LLM.
+*/
+function stripEnvelopeMetadata(text) {
+	const threadStarterHeaderRe = /^Thread starter\s*\(untrusted, for context\):\s*$/i;
+	const forwardedContextHeaderRe = /^Forwarded message context\s*\(untrusted metadata\):\s*$/i;
+	let cleaned = stripLeadingRuntimeWrappers(text);
+	cleaned = stripAmbientLearningInjectedPrefix("user", cleaned);
+	cleaned = cleaned.replace(/^<<<EXTERNAL_UNTRUSTED_CONTENT\b.*$/gim, "");
+	cleaned = cleaned.replace(/^<<<END_EXTERNAL_UNTRUSTED_CONTENT\b.*$/gim, "");
+	cleaned = cleaned.replace(/^Sender\s*\(untrusted metadata\):\s*\n```json\n[\s\S]*?\n```\s*/gim, "");
+	cleaned = cleaned.replace(/^Conversation info\s*\(untrusted metadata\):\s*\n```json\n[\s\S]*?\n```\s*/gim, "");
+	cleaned = stripDelimitedMetadataBlock(cleaned, threadStarterHeaderRe);
+	cleaned = stripDelimitedMetadataBlock(cleaned, forwardedContextHeaderRe);
+	cleaned = cleaned.replace(/^\[Queued messages while agent was busy\]\s*/gim, "");
+	cleaned = cleaned.replace(/^System:\s*\[[\d\-: +GMT]+\]\s+\S+\[.*?\].*$/gm, "");
+	cleaned = cleaned.replace(/(?:Conversation info|Sender|Replied message)\s*\(untrusted[^)]*\):\s*```json\s*\{[\s\S]*?\}\s*```/g, "");
+	cleaned = cleaned.replace(/```json\s*\{[^}]*"message_id"\s*:[^}]*"sender_id"\s*:[^}]*\}\s*```/g, "");
+	cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+	return sanitizeContentIngress({
+		source: PERSISTED_PROVIDER_SYSTEM,
+		content: cleaned
+	}).projections.plainText;
+}
+//#endregion
+export { boundSectionContent, buildIndexedText, stripEnvelopeMetadata };

package/dist/internal/engine/extraction/memory-metadata-codec.d.ts

@@ -0,0 +1,3 @@
+import { C as EntryLike, D as MemoryRelation, E as MemoryLayer, O as MemorySource, T as InsightMetadataPatch, k as MemoryState, w as InsightMetadata } from "../../../types-CWdhXLxr.js";
+import { _ as deriveFactKey, a as buildInsightMetadata, c as stringifyInsightMetadata, d as SUPPORT_CONTEXT_VOCABULARY, f as SupportContext, g as updateSupportStats, h as parseSupportInfo, i as appendRelation, l as ContextualSupport, m as normalizeContext, n as ExtractionError, o as isMemoryExpired, p as SupportInfoV2, r as appendLineage, s as parseInsightMetadata, t as DEFAULT_MERGE_LINEAGE_MAX, u as MAX_SUPPORT_SLICES } from "../../../memory-metadata-codec-DUvsYe_X.js";
+export { type ContextualSupport, DEFAULT_MERGE_LINEAGE_MAX, type EntryLike, ExtractionError, type InsightMetadata, type InsightMetadataPatch, MAX_SUPPORT_SLICES, type MemoryLayer, type MemoryRelation, type MemorySource, type MemoryState, SUPPORT_CONTEXT_VOCABULARY, type SupportContext, type SupportInfoV2, appendLineage, appendRelation, buildInsightMetadata, deriveFactKey, isMemoryExpired, normalizeContext, parseInsightMetadata, parseSupportInfo, stringifyInsightMetadata, updateSupportStats };

package/dist/internal/engine/extraction/memory-metadata-codec.js

@@ -0,0 +1,2 @@
+import { a as buildInsightMetadata, c as stringifyInsightMetadata, d as normalizeContext, f as parseSupportInfo, h as deriveFactKey, i as appendRelation, l as MAX_SUPPORT_SLICES, n as ExtractionError, o as isMemoryExpired, p as updateSupportStats, r as appendLineage, s as parseInsightMetadata, t as DEFAULT_MERGE_LINEAGE_MAX, u as SUPPORT_CONTEXT_VOCABULARY } from "../../../memory-metadata-codec-DL1sbJiN.js";
+export { DEFAULT_MERGE_LINEAGE_MAX, ExtractionError, MAX_SUPPORT_SLICES, SUPPORT_CONTEXT_VOCABULARY, appendLineage, appendRelation, buildInsightMetadata, deriveFactKey, isMemoryExpired, normalizeContext, parseInsightMetadata, parseSupportInfo, stringifyInsightMetadata, updateSupportStats };

package/dist/internal/engine/extraction/memory-temporality-classifier.d.ts

@@ -0,0 +1,2 @@
+import { a as classifyTemporal, c as parseSessionTimestamp, i as TemporalType, l as serializeIntervalMetadata, n as TemporalInterval, o as inferExpiry, r as TemporalResolutionStatus, s as inferTemporalInterval, t as SessionTemporalContext } from "../../../memory-temporality-classifier-Brht5jyK.js";
+export { SessionTemporalContext, TemporalInterval, TemporalResolutionStatus, TemporalType, classifyTemporal, inferExpiry, inferTemporalInterval, parseSessionTimestamp, serializeIntervalMetadata };

package/dist/internal/engine/extraction/memory-temporality-classifier.js

@@ -0,0 +1,2 @@
+import { a as serializeIntervalMetadata, i as parseSessionTimestamp, n as inferExpiry, r as inferTemporalInterval, t as classifyTemporal } from "../../../memory-temporality-classifier-BUjXG5o7.js";
+export { classifyTemporal, inferExpiry, inferTemporalInterval, parseSessionTimestamp, serializeIntervalMetadata };

package/dist/internal/engine/i18n/all-resources.d.ts

@@ -0,0 +1,2 @@
+import { n as RESOURCES_BY_LOCALE, t as ALL_RESOURCES } from "../../../all-resources-Dij6l5h0.js";
+export { ALL_RESOURCES, RESOURCES_BY_LOCALE };

package/dist/internal/engine/i18n/all-resources.js

@@ -0,0 +1,2 @@
+import { n as RESOURCES_BY_LOCALE, t as ALL_RESOURCES } from "../../../all-resources-BQK2ugjB.js";
+export { ALL_RESOURCES, RESOURCES_BY_LOCALE };

package/dist/internal/engine/i18n/locales.d.ts

@@ -0,0 +1,2 @@
+import { i as isSupportedLocale, n as Locale, r as SUPPORTED_LOCALES, t as DEFAULT_LOCALE } from "../../../locales-JxGmkG6t.js";
+export { DEFAULT_LOCALE, Locale, SUPPORTED_LOCALES, isSupportedLocale };

package/dist/internal/engine/i18n/locales.js

@@ -0,0 +1,19 @@
+//#region src/engine/i18n/locales.ts
+const SUPPORTED_LOCALES = [
+	"en",
+	"de",
+	"es",
+	"fr",
+	"zh",
+	"zh-Hant",
+	"ja",
+	"ko",
+	"ru"
+];
+const DEFAULT_LOCALE = "en";
+const SUPPORTED_SET = new Set(SUPPORTED_LOCALES);
+function isSupportedLocale(value) {
+	return SUPPORTED_SET.has(value);
+}
+//#endregion
+export { DEFAULT_LOCALE, SUPPORTED_LOCALES, isSupportedLocale };

package/dist/internal/engine/i18n/res/_types.d.ts

@@ -0,0 +1,2 @@
+import { a as LocaleResources, c as ReflectionErrorSignalLike, d as TemporalIntervalAnchor, f as TemporalPhraseRule, i as ExtractionPromptsNs, l as ReflectionPromptsNs, n as CaptureTriggersNs, o as Namespace, p as ToolDescriptionsNs, r as CategoryRoutingNs, s as NoiseNs, t as ALL_NAMESPACES, u as ReflectionSliceClassifiersNs } from "../../../../_types-CUKHSRkS.js";
+export { ALL_NAMESPACES, CaptureTriggersNs, CategoryRoutingNs, ExtractionPromptsNs, LocaleResources, Namespace, NoiseNs, ReflectionErrorSignalLike, ReflectionPromptsNs, ReflectionSliceClassifiersNs, TemporalIntervalAnchor, TemporalPhraseRule, ToolDescriptionsNs };

package/dist/internal/engine/i18n/res/_types.js

@@ -0,0 +1,11 @@
+//#region src/engine/i18n/res/_types.ts
+const ALL_NAMESPACES = [
+	"captureTriggers",
+	"noise",
+	"toolDescriptions",
+	"extractionPrompts",
+	"reflectionPrompts",
+	"reflectionSliceClassifiers"
+];
+//#endregion
+export { ALL_NAMESPACES };

package/dist/internal/engine/observability/adapter.d.ts

@@ -0,0 +1,2 @@
+import { n as PluginObservability, t as EmitInput } from "../../../adapter-B7Jox9-6.js";
+export { EmitInput, PluginObservability };

package/dist/internal/engine/observability/adapter.js

@@ -0,0 +1,2 @@
+import { t as PluginObservability } from "../../../adapter-XaRHZWZ2.js";
+export { PluginObservability };

package/dist/internal/engine/observability/best-effort.d.ts

@@ -0,0 +1,2 @@
+import { n as bestEffort, r as bestEffortSync, t as ObserveLogger } from "../../../best-effort-BPZSzKk0.js";
+export { ObserveLogger, bestEffort, bestEffortSync };

package/dist/internal/engine/observability/best-effort.js

@@ -0,0 +1,41 @@
+import { createLogger } from "@snoai/utils/logger";
+//#region src/engine/observability/best-effort.ts
+/** @file best-effort.ts
+* @purpose Keeps cloud observability failures out of plugin control flow.
+* @boundary Telemetry-only error handling.
+*/
+const log = createLogger("sno-station-mem:best-effort");
+/** Failures never reach the caller, but every one is logged at error level. */
+async function bestEffort(label, fn, _logger) {
+	try {
+		await fn();
+	} catch (error) {
+		log.error("Background observability action failed", {
+			action: label,
+			error
+		}, {
+			event_name: "observability.action.failed",
+			file: "packages/memory/src/engine/observability/best-effort.ts",
+			function: "bestEffort",
+			site_id: "observability.bestEffort.failed"
+		});
+	}
+}
+function bestEffortSync(label, fn, _logger) {
+	try {
+		return fn();
+	} catch (error) {
+		log.error("Synchronous observability action failed", {
+			action: label,
+			error
+		}, {
+			event_name: "observability.action.failed",
+			file: "packages/memory/src/engine/observability/best-effort.ts",
+			function: "bestEffortSync",
+			site_id: "observability.bestEffortSync.failed"
+		});
+		return;
+	}
+}
+//#endregion
+export { bestEffort, bestEffortSync };

package/dist/internal/engine/observability/early-diagnostics.js

@@ -0,0 +1,2 @@
+import { encodeDiagnostic, writeEmergencyDiagnostic } from "../../../diagnostic-encoder.js";
+export { encodeDiagnostic, writeEmergencyDiagnostic };

package/dist/internal/engine/observability/memory-snapshot.d.ts

@@ -0,0 +1,2 @@
+import { n as SnapshotReason, r as readMemorySnapshotPayload, t as MemorySnapshotPayload } from "../../../memory-snapshot-CqY1BUUA.js";
+export { MemorySnapshotPayload, SnapshotReason, readMemorySnapshotPayload };

package/dist/internal/engine/observability/memory-snapshot.js

@@ -0,0 +1,44 @@
+import { openSqliteDatabaseReadonly } from "../../store/sqlite-runtime.js";
+import { existsSync } from "node:fs";
+//#region src/engine/observability/memory-snapshot.ts
+/** @file memory-snapshot.ts
+* @purpose Reads aggregate memory-store metadata for memory.snapshot events.
+* @boundary Read-only SQLite inspection for observability.
+*/
+function emptySnapshotPayload(snapshotUuid, reason) {
+	return {
+		session_uuid: snapshotUuid,
+		snapshot_reason: reason,
+		total_entries: 0,
+		total_bytes: 0
+	};
+}
+function hasMemoriesTable(db) {
+	return db.prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'nodix_memories'").get()?.present === 1;
+}
+async function readMemorySnapshotPayload(dbPath, _config, snapshotUuid, reason, liveDb) {
+	if (!existsSync(dbPath)) return emptySnapshotPayload(snapshotUuid, reason);
+	const handle = liveDb ? void 0 : openSqliteDatabaseReadonly(dbPath);
+	const db = liveDb ?? (handle ? handle.db : void 0);
+	if (!db) return emptySnapshotPayload(snapshotUuid, reason);
+	let row;
+	try {
+		if (!hasMemoriesTable(db)) return emptySnapshotPayload(snapshotUuid, reason);
+		row = db.prepare("SELECT COUNT(*) AS total_entries, COALESCE(SUM(LENGTH(CAST(text AS BLOB))), 0) AS total_bytes, MIN(timestamp) AS oldest_entry_ts_ms, MAX(timestamp) AS newest_entry_ts_ms FROM nodix_memories").get();
+	} finally {
+		if (handle) handle.db.close();
+	}
+	const payload = {
+		session_uuid: snapshotUuid,
+		snapshot_reason: reason,
+		total_entries: row.total_entries,
+		total_bytes: row.total_bytes
+	};
+	if (row.total_entries > 0) {
+		payload.oldest_entry_ts_ms = row.oldest_entry_ts_ms ?? 0;
+		payload.newest_entry_ts_ms = row.newest_entry_ts_ms ?? 0;
+	}
+	return payload;
+}
+//#endregion
+export { readMemorySnapshotPayload };

package/dist/internal/engine/observability/observable-embedder.d.ts

@@ -0,0 +1,2 @@
+import { t as ObservableEmbedder } from "../../../observable-embedder-CNNe9gkg.js";
+export { ObservableEmbedder };

package/dist/internal/engine/observability/observable-embedder.js

@@ -0,0 +1,43 @@
+import { bestEffort } from "./best-effort.js";
+import { t as Embedder } from "../../../embedding-provider-client-Q_hJonK9.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/engine/observability/observable-embedder.ts
+/** @file observable-embedding-provider-client.ts
+* @purpose Emits best-effort observe metadata around embedding calls.
+* @boundary Preserves Embedder behavior; observability failures never affect embedding.
+*/
+var ObservableEmbedder = class extends Embedder {
+	observability;
+	sessionUuidProvider;
+	observationScope = new AsyncLocalStorage();
+	constructor(config, stateDir, observability, sessionUuidProvider) {
+		super(config, stateDir);
+		this.observability = observability;
+		this.sessionUuidProvider = sessionUuidProvider;
+	}
+	async embed(text) {
+		return this.observeEmbedding(() => super.embed(text));
+	}
+	async embedDirect(text) {
+		return this.observeEmbedding(() => super.embedDirect(text));
+	}
+	async embedMany(values) {
+		return this.observeEmbedding(() => super.embedMany(values));
+	}
+	async embedChunks(texts) {
+		return this.observeEmbedding(() => super.embedChunks(texts));
+	}
+	async observeEmbedding(operation) {
+		if (this.observationScope.getStore()) return operation();
+		return this.observationScope.run(true, async () => {
+			try {
+				return await operation();
+			} catch (error) {
+				await bestEffort("embedding error", () => this.observability.emitError("embedding:throw", error, this.sessionUuidProvider()));
+				throw error;
+			}
+		});
+	}
+};
+//#endregion
+export { ObservableEmbedder };

package/dist/internal/engine/observability/observable-llm-client.d.ts

@@ -0,0 +1,2 @@
+import { t as ObservableLlmClient } from "../../../observable-llm-client-CRuKlefQ.js";
+export { ObservableLlmClient };

package/dist/internal/engine/observability/observable-llm-client.js

@@ -0,0 +1,98 @@
+import { resolveLlmRoute } from "../../model/llm-mode-routing.js";
+import { r as countTextTokens } from "../../../token-counter-BD1f48Km.js";
+import { Mutex } from "async-mutex";
+//#region src/engine/observability/observable-llm-client.ts
+/** @file observable-llm-client.ts
+* @purpose Emits best-effort observe metadata around plugin LLM calls.
+* @boundary Wraps the public LlmClient interface only.
+*/
+var ObservableLlmClient = class {
+	inner;
+	config;
+	observability;
+	sessionUuidProvider;
+	usageMutex = new Mutex();
+	constructor(inner, config, observability, sessionUuidProvider) {
+		this.inner = inner;
+		this.config = config;
+		this.observability = observability;
+		this.sessionUuidProvider = sessionUuidProvider;
+	}
+	async completeJson(request) {
+		return this.observeCall(request, () => this.inner.completeJson(request));
+	}
+	async completeText(request) {
+		return this.observeCall(request, () => this.inner.completeText(request));
+	}
+	async observeCall(request, call) {
+		const route = this.config.routing ? resolveLlmRoute({
+			callId: request.callId,
+			config: this.config.routing
+		}) : void 0;
+		if (route) {
+			if ("off" in route) return this.usageMutex.runExclusive(call);
+			if (route.transport === "agent-host-seam") try {
+				const result = await this.usageMutex.runExclusive(call);
+				if (result === null) await this.observability.emitError("llm.call:host_failed", this.inner.getLastError() ?? "host model returned nothing", this.sessionUuidProvider());
+				return result;
+			} catch (error) {
+				await this.observability.emitError("llm.call:host_throw", error, this.sessionUuidProvider());
+				throw error;
+			}
+		}
+		const resolved = await this.inner.getResolvedConfig().catch(async (error) => {
+			await this.observability.emitError("llm.call:resolve_config", error, this.sessionUuidProvider());
+			return null;
+		});
+		const started = Date.now();
+		try {
+			const { result, providerUsage } = await this.usageMutex.runExclusive(async () => {
+				return {
+					result: await call(),
+					providerUsage: this.inner.getLastUsage()
+				};
+			});
+			if (!resolved) return result;
+			const sessionUuid = this.sessionUuidProvider();
+			const hasProviderUsage = providerUsage !== null && providerUsage.inputTokens + providerUsage.outputTokens > 0;
+			if (result === null) {
+				await this.observability.emitError(hasProviderUsage ? "llm.call:empty_result" : "llm.call:usage_missing", this.inner.getLastError() ?? "no result", sessionUuid);
+				if (!hasProviderUsage) return result;
+			}
+			const promptCount = hasProviderUsage ? providerUsage.inputTokens : countTextTokens(request.prompt, resolved.model).count;
+			const completionCount = hasProviderUsage ? providerUsage.outputTokens : countTextTokens(result === null ? "" : JSON.stringify(result), resolved.model).count;
+			this.observability.trackBestEffort("llm.call", async () => {
+				await this.observability.emit({
+					eventType: "llm.call",
+					sessionUuid,
+					payload: {
+						call_id: request.callId,
+						destination: route && "destination" in route ? route.destination : "host",
+						model: `${resolved.provider}:${resolved.model}`,
+						prompt_tokens: promptCount,
+						completion_tokens: completionCount,
+						latency_ms: Math.max(0, Math.round(Date.now() - started)),
+						cache_read_tokens: 0,
+						cache_write_tokens: 0,
+						token_source: "plugin_internal_paid"
+					}
+				});
+			});
+			return result;
+		} catch (error) {
+			await this.observability.emitError("llm.call:provider_throw", error, this.sessionUuidProvider());
+			throw error;
+		}
+	}
+	getResolvedConfig() {
+		return this.inner.getResolvedConfig();
+	}
+	getLastError() {
+		return this.inner.getLastError();
+	}
+	getLastUsage() {
+		return this.inner.getLastUsage();
+	}
+};
+//#endregion
+export { ObservableLlmClient };

package/dist/internal/engine/observability/observable-memory-store.d.ts

@@ -0,0 +1,2 @@
+import { t as ObservableMemoryStore } from "../../../observable-memory-store-CnGDpOY5.js";
+export { ObservableMemoryStore };