@oh-my-pi/pi-mnemopi 18.16.0 → 18.18.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [18.18.0] - 2026-11-07
+
+### Fixed
+
+- Fixed embedding rebuilds failing on hosted APIs that cap the inputs per request: `embed()` now splits large lists into requests of at most `MNEMOPI_EMBEDDING_BATCH_SIZE` texts (default 64; set `10` for DashScope) or the `embeddings.batchSize` runtime option, and returns `null` when the API returns a different number of vectors than texts ([#18278](https://github.com/can1357/oh-my-pi/pull/18278) by [@aleister1102](https://github.com/aleister1102))
+- Fixed an embedding model change deleting every stored vector when the new provider had no key, did not answer, or rejected a batch partway through: the store now embeds the whole corpus with the new model before replacing anything, keeps the old vectors if any request fails, and tries again on the next open ([#18278](https://github.com/can1357/oh-my-pi/pull/18278) by [@aleister1102](https://github.com/aleister1102))
+- Fixed rejected embedding API requests leaving no trace: the status and the first 300 characters of the response body now go to the log at `debug`, or at `warn` when runtime debug is on ([#18278](https://github.com/can1357/oh-my-pi/pull/18278) by [@aleister1102](https://github.com/aleister1102))
+
+## [18.17.0] - 2026-11-06
+
+### Changed
+
+- Development installs reuse fastembed’s ONNX Runtime instead of installing a duplicate native runtime.
+
 ## [18.14.2] - 2026-10-31
 
 ### Fixed

package/README.md

@@ -89,6 +89,7 @@ Common environment fallbacks:
 - `MNEMOPI_NO_EMBEDDINGS=1`: force FTS-only recall.
 - `MNEMOPI_EMBEDDING_MODEL`: defaults to `BAAI/bge-small-en-v1.5`.
 - `MNEMOPI_EMBEDDING_API_URL` and `MNEMOPI_EMBEDDING_API_KEY`: OpenAI-compatible embedding endpoint.
+- `MNEMOPI_EMBEDDING_BATCH_SIZE`: texts per embedding API request, default `64`. Larger inputs are split into several requests. Set it lower for a provider with a smaller per-request limit, for example `10` for DashScope.
 - `MNEMOPI_LLM_ENABLED=1`, `MNEMOPI_LLM_BASE_URL`, `MNEMOPI_LLM_API_KEY`, `MNEMOPI_LLM_MODEL`: OpenAI-compatible LLM endpoint.
 
 Local embeddings use the `fastembed` npm package. Its default `BGESmallENV15` model is 384-dimensional and uses the package's CLS pooling plus vector normalization path. Local GGUF LLMs are not available in this package.

package/dist/types/core/beam/store.d.ts

@@ -26,18 +26,21 @@ type StoreRememberBatchOptions = RememberBatchOptions & {
  * Every `memory_embeddings` row is stamped with the model that produced it (see
  * `runEmbedding` in `helpers.ts`). When the configured embedding model changes,
  * its vector dimension changes too, so the previously-stored vectors are no
- * longer comparable. On a mismatch we wipe every stored vector — the
- * `memory_embeddings` table, the `episodic_memory.binary_vector` column, and the
- * sqlite-vec `vec_episodes` index — then enqueue all live memories for
- * background re-embedding under the new model via `scheduleEmbedding`.
+ * longer comparable. On a mismatch we embed one probe text with the new model. Once
+ * it answers we embed the whole corpus under the new model in memory. Only when every
+ * batch comes back do we replace the stored vectors (the `memory_embeddings` table, the
+ * `episodic_memory.binary_vector` column, and the sqlite-vec `vec_episodes` index) in one
+ * transaction, so a rejected batch leaves the old vectors in place. The work runs as a
+ * tracked background task on `beam.pendingExtractions`, so `flushExtractions()` drains it.
  *
  * Runs once per store open; a fresh store (no embeddings) or an already-current
  * store is a no-op. The destructive wipe is skipped whenever it could not be
- * rebuilt — embeddings disabled via the runtime option OR the
- * `MNEMOPI_NO_EMBEDDINGS` env, or an unresolved (empty) active model — so a
- * stale-but-valid corpus is never destroyed without a replacement. MUST run
- * inside the active runtime-options scope so `currentEmbeddingModel()` /
- * `embeddingsDisabled()` reflect the per-instance configuration.
+ * rebuilt: embeddings disabled via the runtime option OR the `MNEMOPI_NO_EMBEDDINGS`
+ * env, an unresolved (empty) active model, or a provider that does not answer the
+ * probe (missing key, unreachable endpoint). A stale-but-valid corpus is never
+ * destroyed without a replacement. MUST run inside the active runtime-options scope
+ * so `currentEmbeddingModel()` / `embeddingsDisabled()` reflect the per-instance
+ * configuration.
  */
 export declare function reconcileEmbeddingModel(beam: BeamMemoryState): void;
 export declare function remember(beam: BeamMemoryState, content: string, options?: StoreRememberOptions): string;

package/dist/types/core/runtime-options.d.ts

@@ -31,6 +31,8 @@ export interface MnemopiEmbeddingRuntimeOptions {
     provider?: MnemopiEmbeddingProvider | ((texts: readonly string[]) => EmbeddingOutput | Promise<EmbeddingOutput>);
     /** Override `MNEMOPI_EMBEDDING_MAX_INPUT_CHARS`. `0` disables the cap. See `config.embeddingMaxInputChars`. */
     maxInputChars?: number;
+    /** Override `MNEMOPI_EMBEDDING_BATCH_SIZE`: max texts per embedding API request. */
+    batchSize?: number;
 }
 export interface MnemopiLlmRuntimeOptions {
     enabled?: boolean;
@@ -57,6 +59,7 @@ export interface ResolvedMnemopiEmbeddingRuntimeOptions {
     apiKey?: ApiKey;
     provider?: MnemopiEmbeddingProvider;
     maxInputChars?: number;
+    batchSize?: number;
 }
 export interface ResolvedMnemopiLlmRuntimeOptions {
     enabled?: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-mnemopi",
-	"version": "18.16.0",
+	"version": "18.18.0",
 	"description": "Local SQLite memory engine for omp agents",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -35,17 +35,17 @@
 	},
 	"scripts": {
 		"check": "oxlint . && oxfmt --check --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts' && bun run check:types",
-		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"check:types": "bun check --no-script -p tsconfig.json",
 		"lint": "oxlint .",
 		"test": "bun test --parallel",
 		"fix": "oxlint --fix --fix-suggestions . && bun run fmt",
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.16.0",
-		"@oh-my-pi/pi-catalog": "18.16.0",
-		"@oh-my-pi/pi-natives": "18.16.0",
-		"@oh-my-pi/pi-utils": "18.16.0"
+		"@oh-my-pi/pi-ai": "18.18.0",
+		"@oh-my-pi/pi-catalog": "18.18.0",
+		"@oh-my-pi/pi-natives": "18.18.0",
+		"@oh-my-pi/pi-utils": "18.18.0"
 	},
 	"peerDependencies": {
 		"fastembed": "3.0.0",
@@ -62,7 +62,7 @@
 	"devDependencies": {
 		"@types/bun": "^1.3.14",
 		"fastembed": "3.0.0",
-		"onnxruntime-node": "1.26.0"
+		"onnxruntime-node": "1.21.0"
 	},
 	"engines": {
 		"bun": ">=1.4.4"

package/src/core/beam/store.ts

@@ -3,7 +3,7 @@ import { logger, withLoopPhase } from "@oh-my-pi/pi-utils";
 import { transaction } from "../../db";
 import { toUtcIso } from "../../util/datetime";
 import { generateId } from "../../util/ids";
-import { currentEmbeddingModel, embeddingsDisabled } from "../embeddings";
+import { currentEmbeddingModel, embed, embeddingsDisabled } from "../embeddings";
 import { EpisodicGraph } from "../episodic-graph";
 import { countExtractedFactCategories, extractFactCategoriesSafe } from "../extraction";
 import { getMnemopiRuntimeOptions, withMnemopiRuntimeOptions } from "../runtime-options";
@@ -351,18 +351,21 @@ const EMBED_REBUILD_BATCH = 128;
  * Every `memory_embeddings` row is stamped with the model that produced it (see
  * `runEmbedding` in `helpers.ts`). When the configured embedding model changes,
  * its vector dimension changes too, so the previously-stored vectors are no
- * longer comparable. On a mismatch we wipe every stored vector — the
- * `memory_embeddings` table, the `episodic_memory.binary_vector` column, and the
- * sqlite-vec `vec_episodes` index — then enqueue all live memories for
- * background re-embedding under the new model via `scheduleEmbedding`.
+ * longer comparable. On a mismatch we embed one probe text with the new model. Once
+ * it answers we embed the whole corpus under the new model in memory. Only when every
+ * batch comes back do we replace the stored vectors (the `memory_embeddings` table, the
+ * `episodic_memory.binary_vector` column, and the sqlite-vec `vec_episodes` index) in one
+ * transaction, so a rejected batch leaves the old vectors in place. The work runs as a
+ * tracked background task on `beam.pendingExtractions`, so `flushExtractions()` drains it.
  *
  * Runs once per store open; a fresh store (no embeddings) or an already-current
  * store is a no-op. The destructive wipe is skipped whenever it could not be
- * rebuilt — embeddings disabled via the runtime option OR the
- * `MNEMOPI_NO_EMBEDDINGS` env, or an unresolved (empty) active model — so a
- * stale-but-valid corpus is never destroyed without a replacement. MUST run
- * inside the active runtime-options scope so `currentEmbeddingModel()` /
- * `embeddingsDisabled()` reflect the per-instance configuration.
+ * rebuilt: embeddings disabled via the runtime option OR the `MNEMOPI_NO_EMBEDDINGS`
+ * env, an unresolved (empty) active model, or a provider that does not answer the
+ * probe (missing key, unreachable endpoint). A stale-but-valid corpus is never
+ * destroyed without a replacement. MUST run inside the active runtime-options scope
+ * so `currentEmbeddingModel()` / `embeddingsDisabled()` reflect the per-instance
+ * configuration.
  */
 export function reconcileEmbeddingModel(beam: BeamMemoryState): void {
 	if (embeddingsDisabled()) return;
@@ -381,35 +384,84 @@ export function reconcileEmbeddingModel(beam: BeamMemoryState): void {
 	// (NULL/unstamped counts as a mismatch via `IS NOT`).
 	const mismatch = beam.db.query("SELECT 1 FROM memory_embeddings WHERE model IS NOT ? LIMIT 1").get(active);
 	if (mismatch) {
-		const staleModels = beam.db
-			.query("SELECT DISTINCT model FROM memory_embeddings WHERE model IS NOT ?")
-			.all(active) as { model: string | null }[];
-		const live = beam.db
-			.query(`
-				SELECT id AS memoryId, COALESCE(embed_text, content) AS content FROM working_memory WHERE superseded_by IS NULL
-				UNION ALL
-				SELECT id AS memoryId, content FROM episodic_memory WHERE superseded_by IS NULL
-			`)
-			.all() as EmbedItem[];
+		// Replace stored vectors only once the whole corpus embeds under the new model. A missing key,
+		// an unreachable endpoint, or a rejected batch keeps the stale vectors; the next open retries.
+		const migrate = async (): Promise<void> => {
+			try {
+				const probe = await embed(["mnemopi embedding probe"]);
+				if (probe === null || probe.length !== 1) {
+					logger.warn("mnemopi: embedding provider did not answer; keeping stored embeddings", { to: active });
+					return;
+				}
+				const staleModels = beam.db
+					.query("SELECT DISTINCT model FROM memory_embeddings WHERE model IS NOT ?")
+					.all(active) as { model: string | null }[];
+				const live = beam.db
+					.query(`
+						SELECT id AS memoryId, COALESCE(embed_text, content) AS content FROM working_memory WHERE superseded_by IS NULL
+						UNION ALL
+						SELECT id AS memoryId, content FROM episodic_memory WHERE superseded_by IS NULL
+					`)
+					.all() as EmbedItem[];
 
-		transaction(beam.db, () => {
-			beam.db.run("DELETE FROM memory_embeddings");
-			beam.db.run("UPDATE episodic_memory SET binary_vector = NULL");
-			if (vecAvailable(beam.db)) {
-				try {
-					beam.db.run("DELETE FROM vec_episodes");
-				} catch {
-					// sqlite-vec cleanup is best-effort; rebuild correctness takes precedence.
+				// Embed the whole corpus before touching anything stored. embed() handles the provider's
+				// per-request cap; a rejected chunk abandons the rebuild and leaves the stored vectors alone.
+				const toEmbed = live.filter(item => item.content.trim() !== "");
+				const staged: { memoryId: string; json: string }[] = [];
+				for (let offset = 0; offset < toEmbed.length; offset += EMBED_REBUILD_BATCH) {
+					const chunk = toEmbed.slice(offset, offset + EMBED_REBUILD_BATCH);
+					const vectors = await embed(chunk.map(item => item.content));
+					if (vectors === null || vectors.length !== chunk.length) {
+						logger.warn("mnemopi: embedding rebuild incomplete; keeping stored embeddings", {
+							to: active,
+							embedded: staged.length,
+							total: toEmbed.length,
+						});
+						return;
+					}
+					chunk.forEach((item, index) => {
+						const vector = vectors[index];
+						if (vector !== undefined) {
+							staged.push({ memoryId: item.memoryId, json: JSON.stringify(Array.from(vector)) });
+						}
+					});
 				}
-			}
-		});
 
-		logger.info("mnemopi: embedding model changed, rebuilding", {
-			from: staleModels.map(row => row.model ?? "(unstamped)"),
-			to: active,
-			count: live.length,
-		});
-		rebuild(live);
+				transaction(beam.db, () => {
+					// Only stale-model rows go. A vector that a concurrent remember() stamped under the active
+					// model survives, and the INSERT below overwrites any row this rebuild covers.
+					beam.db.query("DELETE FROM memory_embeddings WHERE model IS NOT ?").run(active);
+					beam.db.run("UPDATE episodic_memory SET binary_vector = NULL");
+					if (vecAvailable(beam.db)) {
+						try {
+							beam.db.run("DELETE FROM vec_episodes");
+						} catch {
+							// sqlite-vec cleanup is best-effort; rebuild correctness takes precedence.
+						}
+					}
+					using insertEmbedding = beam.db.prepare(
+						"INSERT OR REPLACE INTO memory_embeddings(memory_id, embedding_json, model) VALUES (?, ?, ?)",
+					);
+					for (const row of staged) insertEmbedding.run(row.memoryId, row.json, active);
+				});
+				beam.caches.queryCache?.invalidate();
+
+				logger.info("mnemopi: embedding model changed, rebuilt", {
+					from: staleModels.map(row => row.model ?? "(unstamped)"),
+					to: active,
+					count: staged.length,
+				});
+			} catch (error) {
+				// A store closed during shutdown lands here; the next open resumes from the stamps.
+				logger.debug("mnemopi: embedding migration aborted", { error: String(error) });
+			}
+		};
+		const task = withMnemopiRuntimeOptions(getMnemopiRuntimeOptions(), migrate);
+		const pending = beam.pendingExtractions;
+		if (pending !== undefined) {
+			pending.add(task);
+			void task.finally(() => pending.delete(task));
+		}
 		return;
 	}
 

package/src/core/embeddings.ts

@@ -361,7 +361,53 @@ async function getLocalModel(): Promise<LocalEmbeddingModel | null> {
 	}
 }
 
+const DEFAULT_EMBEDDING_BATCH_SIZE = 64;
+
+/**
+ * Max texts per `/embeddings` request. Some hosted providers cap the inputs per
+ * request (DashScope: 10), and a rejected request fails the whole call. Reads the
+ * runtime scope's `embeddings.batchSize`, then `MNEMOPI_EMBEDDING_BATCH_SIZE`, then 64.
+ */
+function embeddingBatchSize(): number {
+	return (
+		positiveBatchSize(activeEmbeddingOptions()?.batchSize) ??
+		positiveBatchSize(Number.parseInt($env.MNEMOPI_EMBEDDING_BATCH_SIZE ?? "", 10)) ??
+		DEFAULT_EMBEDDING_BATCH_SIZE
+	);
+}
+
+/** Floors a configured size to a whole request cap; undefined unless it is at least 1. */
+function positiveBatchSize(value: number | undefined): number | undefined {
+	if (value === undefined || !Number.isFinite(value)) return undefined;
+	const size = Math.floor(value);
+	return size >= 1 ? size : undefined;
+}
+
+// Same level policy as the local-model failures: debug, or warn when runtime debug is on.
+function logEmbeddingRejection(status: number, body: string): void {
+	logger[mnemopiDebugEnabled() ? "warn" : "debug"]("mnemopi embedding request rejected", {
+		status,
+		body: body.slice(0, 300),
+	});
+}
+
 async function embedApi(texts: readonly string[]): Promise<EmbeddingMatrix | null> {
+	const size = embeddingBatchSize();
+	if (texts.length <= size) {
+		return embedApiBatch(texts);
+	}
+	const matrix: EmbeddingMatrix = [];
+	for (let offset = 0; offset < texts.length; offset += size) {
+		const part = await embedApiBatch(texts.slice(offset, offset + size));
+		if (part === null) {
+			return null;
+		}
+		matrix.push(...part);
+	}
+	return matrix;
+}
+
+async function embedApiBatch(texts: readonly string[]): Promise<EmbeddingMatrix | null> {
 	const baseUrl = embeddingBaseUrl();
 	const isCustom = !hostMatchesUrl(baseUrl, "openrouter");
 	const apiKey = embeddingApiKey();
@@ -392,24 +438,35 @@ async function embedApi(texts: readonly string[]): Promise<EmbeddingMatrix | nul
 				defaultDelayMs: attempt => 2 ** attempt * 1000,
 			});
 			if (res.status === 401) {
-				throw new ProviderHttpError("mnemopi embedding request unauthorized (401)", 401, { headers: res.headers });
+				// Keep the provider's denial text: the log can only show what the error carries.
+				const detail = (await res.text().catch(() => "")).trim();
+				throw new ProviderHttpError(detail || "mnemopi embedding request unauthorized (401)", 401, {
+					headers: res.headers,
+				});
 			}
 			return res;
 		});
 		if (!response.ok) {
+			logEmbeddingRejection(response.status, await response.text().catch(() => ""));
 			return null;
 		}
 		const data = (await response.json()) as { data?: Array<{ embedding: number[] }> };
 		return withLoopPhase("mnemopi.embed", () => {
 			const { data: rows } = data;
-			if (rows === undefined) {
+			// A short or long matrix would stamp vectors onto the wrong memories.
+			if (rows === undefined || rows.length !== texts.length) {
 				return null;
 			}
 			apiCallCount += 1;
 			return rows.map(row => new Float32Array(row.embedding));
 		});
 	} catch (error) {
-		logger.debug("mnemopi embedding request failed", { status: extractHttpStatusFromError(error) });
+		const status = extractHttpStatusFromError(error);
+		if (status === undefined) {
+			logger.debug("mnemopi embedding request failed", { error: String(error) });
+		} else {
+			logEmbeddingRejection(status, error instanceof Error ? error.message : "");
+		}
 		return null;
 	}
 }

package/src/core/memory.ts

@@ -194,6 +194,7 @@ function resolveRuntimeOptions(options: MnemopiOptions): ResolvedMnemopiRuntimeO
 	const embeddingApiKey = options.embeddingApiKey ?? nestedEmbeddings?.apiKey;
 	const embeddingProvider = resolveEmbeddingProvider(nestedEmbeddings?.provider);
 	const embeddingMaxInputChars = nestedEmbeddings?.maxInputChars;
+	const embeddingBatchSize = nestedEmbeddings?.batchSize;
 
 	const embeddings =
 		embeddingDisabled !== undefined ||
@@ -201,7 +202,8 @@ function resolveRuntimeOptions(options: MnemopiOptions): ResolvedMnemopiRuntimeO
 		embeddingApiUrl !== undefined ||
 		embeddingApiKey !== undefined ||
 		embeddingProvider !== undefined ||
-		embeddingMaxInputChars !== undefined
+		embeddingMaxInputChars !== undefined ||
+		embeddingBatchSize !== undefined
 			? {
 					disabled: embeddingDisabled,
 					model: embeddingModel,
@@ -209,6 +211,7 @@ function resolveRuntimeOptions(options: MnemopiOptions): ResolvedMnemopiRuntimeO
 					apiKey: embeddingApiKey,
 					provider: embeddingProvider,
 					maxInputChars: embeddingMaxInputChars,
+					batchSize: embeddingBatchSize,
 				}
 			: undefined;
 

package/src/core/runtime-options.ts

@@ -41,6 +41,8 @@ export interface MnemopiEmbeddingRuntimeOptions {
 	provider?: MnemopiEmbeddingProvider | ((texts: readonly string[]) => EmbeddingOutput | Promise<EmbeddingOutput>);
 	/** Override `MNEMOPI_EMBEDDING_MAX_INPUT_CHARS`. `0` disables the cap. See `config.embeddingMaxInputChars`. */
 	maxInputChars?: number;
+	/** Override `MNEMOPI_EMBEDDING_BATCH_SIZE`: max texts per embedding API request. */
+	batchSize?: number;
 }
 
 export interface MnemopiLlmRuntimeOptions {
@@ -70,6 +72,7 @@ export interface ResolvedMnemopiEmbeddingRuntimeOptions {
 	apiKey?: ApiKey;
 	provider?: MnemopiEmbeddingProvider;
 	maxInputChars?: number;
+	batchSize?: number;
 }
 
 export interface ResolvedMnemopiLlmRuntimeOptions {