@remit/search-service 0.0.1

package/src/chunking/entropy.ts

@@ -0,0 +1,161 @@
+import type { Chunk } from "../types.js";
+import { MAX_CHUNKS_PER_TYPE } from "./keys.js";
+
+const SIGNATURE_MARKERS: RegExp[] = [
+	/^--\s*$/m,
+	/^Best regards/im,
+	/^Best,/im,
+	/^Regards,/im,
+	/^Kind regards/im,
+	/^Thanks,/im,
+	/^Cheers,/im,
+	/^Sent from my (iPhone|iPad|Android|Samsung)/im,
+];
+
+const QUOTE_MARKERS: RegExp[] = [
+	/^>/m,
+	/^On .+ wrote:$/im,
+	/^-{3,}\s*Original Message\s*-{3,}$/im,
+	/^_{3,}$/m,
+	/^From:.*Sent:.*To:/im,
+];
+
+const stripQuoted = (text: string): string => {
+	const lines = text.split("\n");
+	const result: string[] = [];
+	for (const line of lines) {
+		let isQuoted = false;
+		for (const re of QUOTE_MARKERS) {
+			if (re.test(line)) {
+				isQuoted = true;
+				break;
+			}
+		}
+		if (isQuoted) break;
+		result.push(line);
+	}
+	return result.join("\n");
+};
+
+const stripSignature = (text: string): string => {
+	let earliest = text.length;
+	for (const re of SIGNATURE_MARKERS) {
+		const match = re.exec(text);
+		if (match && match.index < earliest) {
+			earliest = match.index;
+		}
+	}
+	return text.slice(0, earliest).trim();
+};
+
+export const stripBoilerplate = (text: string): string => {
+	return stripSignature(stripQuoted(text));
+};
+
+export const shannonEntropy = (text: string): number => {
+	if (text.length === 0) return 0;
+	const counts = new Map<string, number>();
+	for (const ch of text) {
+		counts.set(ch, (counts.get(ch) ?? 0) + 1);
+	}
+	let entropy = 0;
+	const len = text.length;
+	for (const c of counts.values()) {
+		const p = c / len;
+		entropy -= p * Math.log2(p);
+	}
+	return entropy;
+};
+
+const MIN_CHUNK_CHARS = 80;
+const MAX_CHUNK_CHARS = 2000;
+const ENTROPY_THRESHOLD = 3.5;
+const WINDOW_SIZE = 100;
+
+/**
+ * Hard ceiling for any chunk text handed to the embedder. Titan v2
+ * (amazon.titan-embed-text-v2:0) rejects inputs over 8192 tokens; 6000 chars
+ * stays comfortably under that even for dense, low-whitespace text.
+ */
+export const EMBED_CHAR_BUDGET = 6000;
+
+const splitParagraphs = (text: string): string[] => {
+	return text
+		.split(/\n\s*\n/)
+		.map((p) => p.trim())
+		.filter((p) => p.length > 0);
+};
+
+const mergeUntilCap = (paragraphs: string[]): string[] => {
+	const merged: string[] = [];
+	let current = "";
+	for (const p of paragraphs) {
+		if (current.length === 0) {
+			current = p;
+			continue;
+		}
+		if (current.length + p.length + 2 <= MAX_CHUNK_CHARS) {
+			current = `${current}\n\n${p}`;
+			continue;
+		}
+		merged.push(current);
+		current = p;
+	}
+	if (current.length > 0) merged.push(current);
+	return merged;
+};
+
+const isHighEntropy = (text: string): boolean => {
+	if (text.length < WINDOW_SIZE) {
+		return shannonEntropy(text) >= ENTROPY_THRESHOLD;
+	}
+	let maxEntropy = 0;
+	for (let i = 0; i + WINDOW_SIZE <= text.length; i += WINDOW_SIZE) {
+		const window = text.slice(i, i + WINDOW_SIZE);
+		const e = shannonEntropy(window);
+		if (e > maxEntropy) maxEntropy = e;
+	}
+	return maxEntropy >= ENTROPY_THRESHOLD;
+};
+
+export const splitToCharBudget = (text: string, budget: number): string[] => {
+	if (text.length <= budget) return [text];
+	const parts: string[] = [];
+	let cursor = 0;
+	while (cursor < text.length) {
+		parts.push(text.slice(cursor, cursor + budget));
+		cursor += budget;
+	}
+	return parts;
+};
+
+const splitOversized = (text: string): string[] =>
+	splitToCharBudget(text, MAX_CHUNK_CHARS);
+
+export const buildBodyChunks = (
+	text: string,
+	chunkIdFor: (suffix: string) => string,
+): Chunk[] => {
+	const stripped = stripBoilerplate(text);
+	if (stripped.length < MIN_CHUNK_CHARS) return [];
+
+	const paragraphs = splitParagraphs(stripped);
+	const informative = paragraphs.filter(isHighEntropy);
+	if (informative.length === 0) return [];
+
+	const merged = mergeUntilCap(informative);
+	const final: string[] = [];
+	for (const m of merged) {
+		for (const part of splitOversized(m)) {
+			if (part.length >= MIN_CHUNK_CHARS) final.push(part);
+		}
+	}
+
+	// Cap at MAX_CHUNKS_PER_TYPE so every produced body-N has a matching key in
+	// candidateChunkKeys (keys.ts) and stays reapable on delete.
+	return final.slice(0, MAX_CHUNKS_PER_TYPE).map((textChunk, idx) => ({
+		chunkId: chunkIdFor(`body-${idx}`),
+		chunkType: "body",
+		text: textChunk,
+	}));
+};

package/src/chunking/keys.ts

@@ -0,0 +1,22 @@
+const STRUCTURED_SUFFIXES = ["sender", "recipient", "subject", "attachment"];
+
+// Ceiling on body / entity chunks per message, shared with the producers
+// (entropy.ts, entities.ts) so every chunk a message can emit has a reapable
+// delete key. Observed counts are 1-19; DeleteVectors ignores keys that don't
+// exist, so the delete stays scan-free.
+export const MAX_CHUNKS_PER_TYPE = 128;
+
+export const chunkKeyFor = (messageId: string, suffix: string): string =>
+	`${messageId}::${suffix}`;
+
+// Every deterministic key a message's chunks can occupy, in lockstep with the
+// suffixes the chunker emits (structured.ts, entropy.ts, entities.ts). Lets a
+// message be deleted by addressing its keys directly — never listing the index.
+export const candidateChunkKeys = (messageId: string): string[] => {
+	const suffixes = [...STRUCTURED_SUFFIXES, "entities"];
+	for (let i = 0; i < MAX_CHUNKS_PER_TYPE; i++) {
+		suffixes.push(`body-${i}`);
+		suffixes.push(`entities-${i}`);
+	}
+	return suffixes.map((suffix) => chunkKeyFor(messageId, suffix));
+};

package/src/chunking/structured.test.ts

@@ -0,0 +1,120 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import type { EnvelopeChunkInput } from "../types.js";
+import {
+	buildStructuredChunks,
+	extractAttachmentFileTypes,
+} from "./structured.js";
+
+const baseEnvelope: EnvelopeChunkInput = {
+	from: { name: "Alice", email: "alice@example.com" },
+	to: [{ name: "Bob", email: "bob@example.com" }],
+	cc: [],
+	bcc: [],
+	subject: "Q1 invoice review",
+	attachments: [],
+};
+
+const idFor = (suffix: string): string => `msg-1::${suffix}`;
+
+describe("buildStructuredChunks", () => {
+	it("emits sender, recipient, and subject chunks for a basic envelope", () => {
+		const chunks = buildStructuredChunks(baseEnvelope, idFor);
+		const types = chunks.map((c) => c.chunkType);
+		assert.deepStrictEqual(types, ["sender", "recipient", "subject"]);
+
+		const sender = chunks.find((c) => c.chunkType === "sender");
+		assert.ok(sender);
+		assert.match(sender.text, /alice@example\.com/);
+		assert.match(sender.text, /Alice/);
+
+		const recipient = chunks.find((c) => c.chunkType === "recipient");
+		assert.ok(recipient);
+		assert.match(recipient.text, /bob@example\.com/);
+
+		const subject = chunks.find((c) => c.chunkType === "subject");
+		assert.ok(subject);
+		assert.match(subject.text, /Q1 invoice review/);
+	});
+
+	it("uses email-only when sender has no display name", () => {
+		const chunks = buildStructuredChunks(
+			{ ...baseEnvelope, from: { name: null, email: "alice@example.com" } },
+			idFor,
+		);
+		const sender = chunks.find((c) => c.chunkType === "sender");
+		assert.ok(sender);
+		assert.strictEqual(sender.text, "From: alice@example.com");
+	});
+
+	it("merges to/cc/bcc into a single recipient chunk", () => {
+		const chunks = buildStructuredChunks(
+			{
+				...baseEnvelope,
+				to: [{ name: "Bob", email: "bob@example.com" }],
+				cc: [{ name: "Carol", email: "carol@example.com" }],
+				bcc: [{ name: null, email: "dave@example.com" }],
+			},
+			idFor,
+		);
+		const recipients = chunks.filter((c) => c.chunkType === "recipient");
+		assert.strictEqual(recipients.length, 1);
+		assert.match(recipients[0].text, /bob@example\.com/);
+		assert.match(recipients[0].text, /carol@example\.com/);
+		assert.match(recipients[0].text, /dave@example\.com/);
+	});
+
+	it("emits an attachment chunk when attachments are present", () => {
+		const chunks = buildStructuredChunks(
+			{
+				...baseEnvelope,
+				attachments: [
+					{
+						filename: "invoice-q1-2026.pdf",
+						contentType: "application/pdf",
+						size: 245_000,
+					},
+					{
+						filename: "summary.xlsx",
+						contentType:
+							"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+						size: 89_000,
+					},
+				],
+			},
+			idFor,
+		);
+		const att = chunks.find((c) => c.chunkType === "attachment");
+		assert.ok(att);
+		assert.match(att.text, /invoice-q1-2026\.pdf/);
+		assert.match(att.text, /application\/pdf/);
+		assert.match(att.text, /summary\.xlsx/);
+	});
+
+	it("skips empty subject and missing recipients", () => {
+		const chunks = buildStructuredChunks(
+			{ ...baseEnvelope, to: [], subject: "" },
+			idFor,
+		);
+		const types = chunks.map((c) => c.chunkType);
+		assert.deepStrictEqual(types, ["sender"]);
+	});
+
+	it("uses deterministic chunk ids derived from the messageId", () => {
+		const chunks = buildStructuredChunks(baseEnvelope, idFor);
+		assert.ok(chunks.every((c) => c.chunkId.startsWith("msg-1::")));
+	});
+});
+
+describe("extractAttachmentFileTypes", () => {
+	it("dedupes and lowercases extensions and content subtypes", () => {
+		const types = extractAttachmentFileTypes([
+			{ filename: "INVOICE.PDF", contentType: "application/pdf", size: 100 },
+			{ filename: "summary.xlsx", contentType: "application/xlsx", size: 200 },
+			{ filename: "another.pdf", contentType: "application/pdf", size: 100 },
+		]);
+		assert.ok(types.includes("pdf"));
+		assert.ok(types.includes("xlsx"));
+		assert.strictEqual(new Set(types).size, types.length);
+	});
+});

package/src/chunking/structured.ts

@@ -0,0 +1,79 @@
+import type {
+	AttachmentChunkInput,
+	Chunk,
+	EnvelopeChunkAddress,
+	EnvelopeChunkInput,
+} from "../types.js";
+
+const formatAddress = (addr: EnvelopeChunkAddress): string => {
+	if (addr.name && addr.name.trim().length > 0) {
+		return `${addr.name} <${addr.email}>`;
+	}
+	return addr.email;
+};
+
+const formatAttachment = (att: AttachmentChunkInput): string => {
+	const filename = att.filename ?? "unnamed";
+	const sizeKb = Math.max(1, Math.round(att.size / 1024));
+	return `${filename} (${att.contentType}, ${sizeKb}KB)`;
+};
+
+export const buildStructuredChunks = (
+	envelope: EnvelopeChunkInput,
+	chunkIdFor: (suffix: string) => string,
+): Chunk[] => {
+	const chunks: Chunk[] = [];
+
+	chunks.push({
+		chunkId: chunkIdFor("sender"),
+		chunkType: "sender",
+		text: `From: ${formatAddress(envelope.from)}`,
+	});
+
+	const recipients = [...envelope.to, ...envelope.cc, ...envelope.bcc];
+	if (recipients.length > 0) {
+		chunks.push({
+			chunkId: chunkIdFor("recipient"),
+			chunkType: "recipient",
+			text: `To: ${recipients.map(formatAddress).join(", ")}`,
+		});
+	}
+
+	const subject = envelope.subject.trim();
+	if (subject.length > 0) {
+		chunks.push({
+			chunkId: chunkIdFor("subject"),
+			chunkType: "subject",
+			text: `Subject: ${subject}`,
+		});
+	}
+
+	if (envelope.attachments.length > 0) {
+		chunks.push({
+			chunkId: chunkIdFor("attachment"),
+			chunkType: "attachment",
+			text: `Attachments: ${envelope.attachments.map(formatAttachment).join(", ")}`,
+		});
+	}
+
+	return chunks;
+};
+
+export const extractAttachmentFileTypes = (
+	attachments: AttachmentChunkInput[],
+): string[] => {
+	const types = new Set<string>();
+	for (const att of attachments) {
+		if (att.filename) {
+			const dot = att.filename.lastIndexOf(".");
+			if (dot > 0 && dot < att.filename.length - 1) {
+				types.add(att.filename.slice(dot + 1).toLowerCase());
+			}
+		}
+		const slash = att.contentType.lastIndexOf("/");
+		if (slash > 0) {
+			types.add(att.contentType.slice(slash + 1).toLowerCase());
+		}
+	}
+	return Array.from(types);
+};

package/src/content-hash.test.ts

@@ -0,0 +1,27 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { computeContentHash } from "./content-hash.js";
+
+describe("computeContentHash", () => {
+	it("is stable for the same model id and text", () => {
+		const a = computeContentHash("model@1024", "hello world");
+		const b = computeContentHash("model@1024", "hello world");
+		assert.strictEqual(a, b);
+	});
+
+	it("changes when the text changes", () => {
+		const a = computeContentHash("model@1024", "hello world");
+		const b = computeContentHash("model@1024", "hello there");
+		assert.notStrictEqual(a, b);
+	});
+
+	it("changes when the embedding model/version id changes", () => {
+		const a = computeContentHash("model@1024", "hello world");
+		const b = computeContentHash("model@512", "hello world");
+		assert.notStrictEqual(a, b);
+	});
+
+	it("returns a hex sha256 digest", () => {
+		assert.match(computeContentHash("m", "x"), /^[0-9a-f]{64}$/);
+	});
+});

package/src/content-hash.ts

@@ -0,0 +1,10 @@
+import { createHash } from "node:crypto";
+
+/**
+ * Stable hash of an embeddable chunk. Folds in the embedding model/version id so
+ * the same text re-hashes differently after a model or dimension change, forcing
+ * a re-embed; under the same model, unchanged text hashes identically and the
+ * re-index skips the write.
+ */
+export const computeContentHash = (embeddingId: string, text: string): string =>
+	createHash("sha256").update(`${embeddingId}\n${text}`).digest("hex");

package/src/embeddings.test.ts

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { LocalEmbeddingService } from "./embeddings.js";
+
+describe("LocalEmbeddingService", () => {
+	it("keeps the historical embeddingId when dtype is unset", () => {
+		const service = new LocalEmbeddingService({
+			modelId: "Xenova/paraphrase-multilingual-MiniLM-L12-v2",
+			dimensions: 384,
+		});
+		assert.equal(
+			service.embeddingId,
+			"local:Xenova/paraphrase-multilingual-MiniLM-L12-v2@384",
+		);
+	});
+
+	it("includes dtype in the embeddingId so quantized vectors get their own content hashes", () => {
+		const service = new LocalEmbeddingService({
+			modelId: "Xenova/paraphrase-multilingual-MiniLM-L12-v2",
+			dimensions: 384,
+			dtype: "q8",
+		});
+		assert.equal(
+			service.embeddingId,
+			"local:Xenova/paraphrase-multilingual-MiniLM-L12-v2:q8@384",
+		);
+	});
+});

package/src/embeddings.ts

@@ -0,0 +1,149 @@
+import type {
+	DataType,
+	FeatureExtractionPipeline,
+	pipeline as PipelineFn,
+} from "@huggingface/transformers";
+import { runtimeImport } from "./backends/runtime-import.js";
+
+export interface EmbeddingService {
+	embed(texts: string[]): Promise<number[][]>;
+	readonly dimensions: number;
+	/**
+	 * Stable identifier for the embedding model and the config that affects its
+	 * output (model id + dimensions). Folded into each chunk's content hash so a
+	 * model or dimension change invalidates the hash and forces a re-embed, while
+	 * unchanged content under the same model stays a no-op.
+	 */
+	readonly embeddingId: string;
+}
+
+export interface DeterministicEmbeddingConfig {
+	dimensions?: number;
+}
+
+const hashString = (s: string, seed: number): number => {
+	let h = seed;
+	for (let i = 0; i < s.length; i++) {
+		h = (h * 31 + s.charCodeAt(i)) | 0;
+	}
+	return h;
+};
+
+const tokenize = (text: string): string[] => {
+	return text
+		.toLowerCase()
+		.replace(/[^a-z0-9@._\-+]+/g, " ")
+		.split(/\s+/)
+		.filter((t) => t.length > 0);
+};
+
+/**
+ * Deterministic bag-of-words hashing embedder. Used in tests so the SearchService
+ * can be exercised without calling Bedrock. Same input text always produces the
+ * same vector, and overlapping tokens produce non-zero cosine similarity.
+ */
+export class DeterministicEmbeddingService implements EmbeddingService {
+	readonly dimensions: number;
+	readonly embeddingId: string;
+
+	constructor(config: DeterministicEmbeddingConfig = {}) {
+		this.dimensions = config.dimensions ?? 64;
+		this.embeddingId = `deterministic@${this.dimensions}`;
+	}
+
+	embed = async (texts: string[]): Promise<number[][]> => {
+		return texts.map((t) => this.embedOne(t));
+	};
+
+	private embedOne(text: string): number[] {
+		const vector = new Array<number>(this.dimensions).fill(0);
+		const tokens = tokenize(text);
+		for (const token of tokens) {
+			const idx = Math.abs(hashString(token, 0x9e3779b1)) % this.dimensions;
+			const sign = hashString(token, 0x85ebca6b) & 1 ? 1 : -1;
+			vector[idx] += sign;
+		}
+		let norm = 0;
+		for (const v of vector) norm += v * v;
+		if (norm === 0) return vector;
+		const scale = 1 / Math.sqrt(norm);
+		return vector.map((v) => v * scale);
+	}
+}
+
+export const createDeterministicEmbeddingService = (
+	config?: DeterministicEmbeddingConfig,
+): EmbeddingService => new DeterministicEmbeddingService(config);
+
+export interface LocalEmbeddingConfig {
+	modelId?: string;
+	dimensions?: number;
+	/**
+	 * ONNX weight precision Transformers.js loads. Left unset it defaults to
+	 * `fp32` (the full-precision `model.onnx`); set to `q8` to load the
+	 * int8-quantized `model_quantized.onnx`, which the search-index-worker
+	 * container bakes to keep the image small. The bake step and this runtime
+	 * must pass the same value so they resolve the identical cached file.
+	 */
+	dtype?: DataType;
+}
+
+const DEFAULT_LOCAL_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+const DEFAULT_LOCAL_DIMENSIONS = 384;
+
+type TransformersModule = { pipeline: typeof PipelineFn };
+
+/**
+ * In-process CPU embedder backed by Transformers.js, used for local dev so the
+ * SearchService produces real semantic vectors without calling Bedrock. The
+ * model is downloaded once (cached on disk by `@huggingface/transformers`) and
+ * loaded lazily on first use; the heavy dependency is never imported in the
+ * production bundle (see runtime-import.ts).
+ */
+export class LocalEmbeddingService implements EmbeddingService {
+	readonly dimensions: number;
+	readonly embeddingId: string;
+	private modelId: string;
+	private dtype?: DataType;
+	private pipelinePromise: Promise<FeatureExtractionPipeline> | null = null;
+
+	constructor(config: LocalEmbeddingConfig = {}) {
+		this.modelId = config.modelId ?? DEFAULT_LOCAL_MODEL_ID;
+		this.dimensions = config.dimensions ?? DEFAULT_LOCAL_DIMENSIONS;
+		this.dtype = config.dtype;
+		// dtype is part of the embedding identity: quantized weights produce
+		// different vectors, and embeddingId feeds the content hash that gates
+		// re-embedding. Unset keeps the historical id so existing fp32 indexes
+		// are not invalidated.
+		this.embeddingId = this.dtype
+			? `local:${this.modelId}:${this.dtype}@${this.dimensions}`
+			: `local:${this.modelId}@${this.dimensions}`;
+	}
+
+	private getPipeline = async (): Promise<FeatureExtractionPipeline> => {
+		if (this.pipelinePromise) return this.pipelinePromise;
+		this.pipelinePromise = (async () => {
+			const { pipeline } = await runtimeImport<TransformersModule>(
+				"@huggingface/transformers",
+			);
+			return pipeline("feature-extraction", this.modelId, {
+				dtype: this.dtype,
+			});
+		})();
+		return this.pipelinePromise;
+	};
+
+	embed = async (texts: string[]): Promise<number[][]> => {
+		if (texts.length === 0) return [];
+		const extractor = await this.getPipeline();
+		const tensor = await extractor(texts, {
+			pooling: "mean",
+			normalize: true,
+		});
+		return tensor.tolist() as number[][];
+	};
+}
+
+export const createLocalEmbeddingService = (
+	config?: LocalEmbeddingConfig,
+): EmbeddingService => new LocalEmbeddingService(config);

package/src/from-env.test.ts

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import { buildEmbeddingServiceFromEnv } from "./from-env.js";
+
+const ENV_KEYS = [
+	"SEARCH_EMBEDDING_PROVIDER",
+	"SEARCH_EMBEDDING_MODEL_ID",
+	"SEARCH_EMBEDDING_DIMENSIONS",
+	"SEARCH_EMBEDDING_DTYPE",
+] as const;
+
+const saved = new Map<string, string | undefined>(
+	ENV_KEYS.map((key) => [key, process.env[key]]),
+);
+
+afterEach(() => {
+	for (const [key, value] of saved) {
+		if (value === undefined) delete process.env[key];
+		else process.env[key] = value;
+	}
+});
+
+describe("buildEmbeddingServiceFromEnv dtype handling", () => {
+	it("builds a local embedder without dtype in its id when SEARCH_EMBEDDING_DTYPE is unset", () => {
+		process.env.SEARCH_EMBEDDING_PROVIDER = "local";
+		process.env.SEARCH_EMBEDDING_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+		delete process.env.SEARCH_EMBEDDING_DTYPE;
+
+		const service = buildEmbeddingServiceFromEnv();
+
+		assert.equal(service.embeddingId, "local:Xenova/all-MiniLM-L6-v2@384");
+	});
+
+	it("threads SEARCH_EMBEDDING_DTYPE into the local embedder identity", () => {
+		process.env.SEARCH_EMBEDDING_PROVIDER = "local";
+		process.env.SEARCH_EMBEDDING_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+		process.env.SEARCH_EMBEDDING_DTYPE = "q8";
+
+		const service = buildEmbeddingServiceFromEnv();
+
+		assert.equal(service.embeddingId, "local:Xenova/all-MiniLM-L6-v2:q8@384");
+	});
+
+	it("rejects an unknown SEARCH_EMBEDDING_DTYPE loudly", () => {
+		process.env.SEARCH_EMBEDDING_PROVIDER = "local";
+		process.env.SEARCH_EMBEDDING_DTYPE = "int7";
+
+		assert.throws(
+			() => buildEmbeddingServiceFromEnv(),
+			/SEARCH_EMBEDDING_DTYPE must be one of/,
+		);
+	});
+
+	it("ignores SEARCH_EMBEDDING_DTYPE for non-local providers", () => {
+		delete process.env.SEARCH_EMBEDDING_PROVIDER;
+		process.env.SEARCH_EMBEDDING_DTYPE = "not-a-dtype";
+
+		const service = buildEmbeddingServiceFromEnv();
+
+		assert.equal(service.embeddingId, "deterministic@64");
+	});
+});