@malloy-publisher/server 0.0.231 → 0.0.233

package/src/service/connection_federation.spec.ts

@@ -0,0 +1,184 @@
+// Unit contract for the build-scoped credential primitives: the SQL a build
+// session issues to (a) RW-attach a destination DuckLake and (b) federate a
+// source warehouse for a native query-passthrough. `runSQL` is stubbed so no
+// live warehouse / catalog is touched — this pins the SQL *shape* (handles,
+// secret scoping, read-only-ness, escaping); live behavior is the measured
+// spike's job.
+import { DuckDBConnection } from "@malloydata/db-duckdb";
+import { describe, expect, it } from "bun:test";
+import * as sinon from "sinon";
+import type { components } from "../api";
+import {
+   attachDuckLakeReadWrite,
+   federateSourceForPassthrough,
+} from "./connection";
+
+/** A real in-memory DuckDB connection with runSQL stubbed to capture SQL. */
+function stubbedConnection(): { conn: DuckDBConnection; sql: string[] } {
+   const conn = new DuckDBConnection("build", ":memory:");
+   const sql: string[] = [];
+   sinon.stub(conn, "runSQL").callsFake(async (q: string) => {
+      sql.push(q);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return { rows: [], totalRows: 0, runStats: {} } as any;
+   });
+   return { conn, sql };
+}
+
+const SERVICE_ACCOUNT = JSON.stringify({
+   type: "service_account",
+   project_id: "sa-project",
+   private_key: "-----BEGIN PRIVATE KEY-----\nabc\n-----END PRIVATE KEY-----",
+   client_email: "svc@sa-project.iam.gserviceaccount.com",
+});
+
+describe("federateSourceForPassthrough", () => {
+   it("bigquery: creates a project-scoped SECRET and returns the project id as handle", async () => {
+      const { conn, sql } = stubbedConnection();
+      const result = await federateSourceForPassthrough(conn, "bigquery", {
+         name: "src_bq",
+         bigqueryConnection: {
+            defaultProjectId: "cfg-project",
+            serviceAccountKeyJson: SERVICE_ACCOUNT,
+         } as components["schemas"]["BigqueryConnection"],
+      });
+      expect(result).toEqual({ handle: "sa-project", sourceType: "bigquery" });
+      const secret = sql.find((s) => s.includes("CREATE OR REPLACE SECRET"));
+      expect(secret).toBeDefined();
+      expect(secret).toContain("TYPE BIGQUERY");
+      expect(secret).toContain("SCOPE 'bq://sa-project'");
+      expect(secret).toContain("SERVICE_ACCOUNT_JSON");
+      // Never ATTACH for a bigquery passthrough.
+      expect(sql.some((s) => s.includes("ATTACH"))).toBe(false);
+   });
+
+   it("snowflake: creates a SECRET and returns the secret name as handle (no ATTACH)", async () => {
+      const { conn, sql } = stubbedConnection();
+      const result = await federateSourceForPassthrough(conn, "snowflake", {
+         name: "src_sf",
+         snowflakeConnection: {
+            account: "acct",
+            username: "user",
+            password: "p'wd",
+            database: "DB",
+            warehouse: "WH",
+         } as components["schemas"]["SnowflakeConnection"],
+      });
+      expect(result.sourceType).toBe("snowflake");
+      expect(result.handle).toBe("secret_snowflake_src_sf");
+      const secret = sql.find((s) => s.includes("CREATE OR REPLACE SECRET"));
+      expect(secret).toContain("TYPE snowflake");
+      expect(secret).toContain("ACCOUNT 'acct'");
+      // Single quotes in a value are doubled (escapeSQL).
+      expect(secret).toContain("PASSWORD 'p''wd'");
+      expect(sql.some((s) => s.includes("ATTACH"))).toBe(false);
+   });
+
+   it("postgres: ATTACHes READ_ONLY and returns the alias as handle", async () => {
+      const { conn, sql } = stubbedConnection();
+      const result = await federateSourceForPassthrough(conn, "postgres", {
+         name: "src_pg",
+         postgresConnection: {
+            host: "h",
+            port: 5432,
+            databaseName: "d",
+            userName: "u",
+            password: "pw",
+         } as components["schemas"]["PostgresConnection"],
+      });
+      expect(result).toEqual({ handle: "src_pg", sourceType: "postgres" });
+      const attach = sql.find((s) => s.startsWith("ATTACH"));
+      expect(attach).toBeDefined();
+      // OR REPLACE for within-session idempotency (a re-attach of the identical
+      // source on one session is a no-op rebind). Cross-build/cross-tenant alias
+      // collisions are prevented upstream by each build running on its OWN
+      // private DuckDB instance (createIsolatedBuildSession); this is just
+      // belt-and-suspenders.
+      expect(attach).toStartWith("ATTACH OR REPLACE ");
+      // The ATTACH alias is dialect-quoted; the handle stays the raw name (it
+      // becomes the postgres_query string literal, which matches the catalog).
+      expect(attach).toContain('AS "src_pg" (TYPE postgres, READ_ONLY)');
+   });
+
+   it("postgres: re-federating the same source on one session is idempotent (no 'already exists')", async () => {
+      // Within one session, federating the same source twice must not throw:
+      // both attaches use OR REPLACE (a no-op rebind to the identical source).
+      // (A real DuckDB would raise "database ... already exists" on a plain
+      // re-ATTACH; here runSQL is stubbed, so we pin the SQL contract.)
+      const { conn, sql } = stubbedConnection();
+      const cfg = {
+         name: "src_pg",
+         postgresConnection: {
+            host: "h",
+            port: 5432,
+            databaseName: "d",
+            userName: "u",
+            password: "pw",
+         } as components["schemas"]["PostgresConnection"],
+      };
+      await federateSourceForPassthrough(conn, "postgres", cfg);
+      await federateSourceForPassthrough(conn, "postgres", cfg);
+      const attaches = sql.filter((s) => s.startsWith("ATTACH"));
+      expect(attaches).toHaveLength(2);
+      for (const a of attaches) expect(a).toStartWith("ATTACH OR REPLACE ");
+   });
+
+   it("postgres: dialect-quotes an alias that needs quoting (e.g. a hyphen)", async () => {
+      const { conn, sql } = stubbedConnection();
+      const result = await federateSourceForPassthrough(conn, "postgres", {
+         name: "my-pg",
+         postgresConnection: {
+            host: "h",
+            port: 5432,
+            databaseName: "d",
+            userName: "u",
+            password: "pw",
+         } as components["schemas"]["PostgresConnection"],
+      });
+      expect(result.handle).toBe("my-pg");
+      const attach = sql.find((s) => s.startsWith("ATTACH"));
+      expect(attach).toContain('AS "my-pg" (TYPE postgres, READ_ONLY)');
+   });
+
+   it("rejects a source type with no native passthrough", async () => {
+      const { conn } = stubbedConnection();
+      await expect(
+         federateSourceForPassthrough(conn, "mysql" as unknown as "postgres", {
+            name: "x",
+         }),
+      ).rejects.toThrow(/no native query-passthrough/i);
+   });
+
+   it("fails loud when the configured credentials are missing", async () => {
+      const { conn } = stubbedConnection();
+      await expect(
+         federateSourceForPassthrough(conn, "bigquery", { name: "x" }),
+      ).rejects.toThrow(/BigQuery connection configuration missing/i);
+   });
+});
+
+describe("attachDuckLakeReadWrite", () => {
+   const ducklakeConfig = {
+      catalog: {
+         postgresConnection: {
+            host: "cat-host",
+            port: 5432,
+            databaseName: "ducklake",
+            userName: "ducklake",
+            password: "secret",
+         },
+      },
+      storage: { bucketUrl: "gs://org-env-ducklake/prefix" },
+   } as unknown as components["schemas"]["DucklakeConnection"];
+
+   it("attaches read-write: no READ_ONLY, no AUTOMATIC_MIGRATION, keeps OVERRIDE_DATA_PATH", async () => {
+      const { conn, sql } = stubbedConnection();
+      await attachDuckLakeReadWrite(conn, "lake", ducklakeConfig);
+      const attach = sql.find((s) => s.includes("ATTACH OR REPLACE"));
+      expect(attach).toBeDefined();
+      expect(attach).toContain("OVERRIDE_DATA_PATH true");
+      expect(attach).not.toContain("READ_ONLY");
+      expect(attach).not.toContain("AUTOMATIC_MIGRATION");
+      expect(attach).toContain("AS lake");
+   });
+});

package/src/service/duckdb_instance_isolation.spec.ts

@@ -0,0 +1,137 @@
+import { DuckDBConnection } from "@malloydata/db-duckdb";
+import { afterEach, describe, expect, it } from "bun:test";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+/**
+ * Pins the DuckDB instance-isolation contract that same-named connections depend
+ * on for multi-tenant safety.
+ *
+ * `@malloydata/db-duckdb` pools DuckDB instances in a process-global cache keyed
+ * by a share key that deliberately EXCLUDES the connection name, and it caches a
+ * `:memory:` primary like any other. Meanwhile the DuckLake attach aliases by
+ * connection name (`ATTACH OR REPLACE … AS <name>`). Put those together and two
+ * same-named connections that land on ONE pooled instance clobber each other's
+ * attach: one ends up reading the other's database.
+ *
+ * `createIsolatedBuildSession` prevents that by giving every build session a
+ * unique `workingDirectory`, relying on it participating in the share key. That
+ * is an upstream implementation detail, so nothing here asserted it — and the
+ * failure mode is silent: no error, just the wrong data. This spec asserts the
+ * behaviour instead of the mechanism, so it holds however upstream achieves it.
+ *
+ * Deliberately NOT asserted: the converse (same name AND same working directory
+ * DO share an instance). That is the pooling artifact, not a property we want; if
+ * upstream ever made pooling connection-aware, asserting it would fail on an
+ * improvement.
+ *
+ * Each connection creates and populates its OWN attached store rather than
+ * reopening a pre-seeded file. Handing a file from one connection to another
+ * requires the first to have released its OS lock, and `close()` is refcount-only
+ * — which fails outright under Windows' mandatory locking. Attaching a store the
+ * connection itself owns avoids the handoff, and matches how a DuckLake
+ * destination is actually used.
+ */
+describe("DuckDB instance isolation", () => {
+   const tempDirs: string[] = [];
+   const openConnections: DuckDBConnection[] = [];
+
+   const tempDir = async (label: string): Promise<string> => {
+      const dir = await fs.mkdtemp(
+         path.join(os.tmpdir(), `duckdb-iso-${label}-`),
+      );
+      tempDirs.push(dir);
+      return dir;
+   };
+
+   afterEach(async () => {
+      for (const connection of openConnections) {
+         await connection.close().catch(() => undefined);
+      }
+      openConnections.length = 0;
+      for (const dir of tempDirs) {
+         // Best-effort: a still-locked file must not fail the test.
+         await fs
+            .rm(dir, { recursive: true, force: true })
+            .catch(() => undefined);
+      }
+      tempDirs.length = 0;
+   });
+
+   /**
+    * A connection with the given name and its own working directory, which
+    * attaches its own private store under `alias` and writes one distinguishing
+    * value into it.
+    */
+   const connectionWithOwnStore = async (
+      name: string,
+      label: string,
+      alias: string,
+      value: number,
+   ): Promise<DuckDBConnection> => {
+      const sessionDir = await tempDir(`session-${label}`);
+      const connection = new DuckDBConnection(name, ":memory:", sessionDir);
+      openConnections.push(connection);
+      const storeDir = await tempDir(`store-${label}`);
+      const storeFile = path.join(storeDir, `${label}.duckdb`);
+      // OR REPLACE mirrors the DuckLake attach: on a shared instance the second
+      // caller silently replaces the first caller's alias.
+      await connection.runSQL(`ATTACH OR REPLACE '${storeFile}' AS ${alias};`);
+      await connection.runSQL(
+         `CREATE OR REPLACE TABLE ${alias}.t AS SELECT ${value} AS x;`,
+      );
+      return connection;
+   };
+
+   const readValue = async (
+      connection: DuckDBConnection,
+      alias: string,
+   ): Promise<number> => {
+      const result = await connection.runSQL(`SELECT x FROM ${alias}.t;`);
+      return Number(Object.values(result.rows[0])[0]);
+   };
+
+   it("keeps same-named connections apart when their working directories differ", async () => {
+      // Identical connection NAME and identical `:memory:` primary — only the
+      // working directory differs. That is exactly the shape a build session
+      // uses, and the only thing standing between it and a shared instance.
+      //
+      // ORDERING IS LOAD-BEARING FOR THIS TEST. The instance cache is consulted
+      // inside an async `init()`, so constructing both connections before either
+      // is used lets both race past the cache miss and each create a private
+      // instance — isolation for the wrong reason, and a test that could never
+      // fail. Each helper call fully initializes its connection (the ATTACH
+      // forces it) before the next is built, so a shared share key really would
+      // hand back the cached instance. Verified: with identical working
+      // directories this ordering yields 2 for both connections — the clobber.
+      const a = await connectionWithOwnStore("store", "a", "lake", 1);
+      const b = await connectionWithOwnStore("store", "b", "lake", 2);
+
+      expect(await readValue(a, "lake")).toBe(1);
+      expect(await readValue(b, "lake")).toBe(2);
+   });
+
+   it("keeps a build-session-shaped connection apart from a long-lived one", async () => {
+      // The pairing the build-session comment calls out specifically: a transient
+      // build session overlapping a long-lived serve connection. Same name, same
+      // alias, both `:memory:` — distinct only by working directory.
+      const serve = await connectionWithOwnStore(
+         "credible",
+         "serve",
+         "lake",
+         10,
+      );
+      const build = await connectionWithOwnStore(
+         "credible",
+         "build",
+         "lake",
+         20,
+      );
+
+      // The serve connection must still see its own store after the build
+      // session attaches a different one under the same alias.
+      expect(await readValue(serve, "lake")).toBe(10);
+      expect(await readValue(build, "lake")).toBe(20);
+   });
+});

package/src/service/embedding_provider.spec.ts

@@ -0,0 +1,329 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import {
+   EmbeddingProvider,
+   MAX_EMBED_BATCH_SIZE,
+   MAX_EMBED_INPUT_CHARS,
+   _clearEmbeddingProviderForTests,
+   embeddingConfigured,
+   getEmbeddingProvider,
+   prepareEmbeddingInput,
+} from "./embedding_provider";
+import { EmbeddingConfig } from "../config";
+
+const CONFIG: EmbeddingConfig = {
+   apiKey: "test-key",
+   model: "test-model",
+   baseUrl: "https://embeddings.example.com/v1",
+};
+
+interface CapturedRequest {
+   url: string;
+   body: Record<string, unknown>;
+   authorization: string | undefined;
+}
+
+/** A fetch stub that records requests and answers with unit vectors. */
+function stubFetch(
+   captured: CapturedRequest[],
+   respond?: (inputs: string[]) => Response,
+): typeof fetch {
+   return (async (url: RequestInfo | URL, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+      captured.push({
+         url: String(url),
+         body,
+         authorization: (init?.headers as Record<string, string>)?.[
+            "Authorization"
+         ],
+      });
+      const inputs = body.input as string[];
+      if (respond) return respond(inputs);
+      return new Response(
+         JSON.stringify({
+            data: inputs.map((_, index) => ({ index, embedding: [index, 1] })),
+         }),
+         { status: 200 },
+      );
+   }) as typeof fetch;
+}
+
+describe("prepareEmbeddingInput", () => {
+   it("collapses whitespace and newlines", () => {
+      expect(prepareEmbeddingInput("a\nb\t c  d")).toBe("a b c d");
+   });
+
+   it("caps input length", () => {
+      const long = "x".repeat(MAX_EMBED_INPUT_CHARS + 500);
+      expect(prepareEmbeddingInput(long).length).toBe(MAX_EMBED_INPUT_CHARS);
+   });
+
+   it("never returns an empty string (providers 400 on empty inputs)", () => {
+      expect(prepareEmbeddingInput("")).toBe("-");
+      expect(prepareEmbeddingInput("   ")).toBe("-");
+      expect(prepareEmbeddingInput("\n\t")).toBe("-");
+   });
+});
+
+describe("EmbeddingProvider", () => {
+   it("embeds a batch and returns vectors in input order", async () => {
+      const captured: CapturedRequest[] = [];
+      const provider = new EmbeddingProvider(CONFIG, stubFetch(captured));
+      const vectors = await provider.embedBatch(["a", "b"], 1000);
+      expect(vectors).toEqual([
+         [0, 1],
+         [1, 1],
+      ]);
+      expect(captured).toHaveLength(1);
+      expect(captured[0].url).toBe(
+         "https://embeddings.example.com/v1/embeddings",
+      );
+      expect(captured[0].body.model).toBe("test-model");
+      expect(captured[0].authorization).toBe("Bearer test-key");
+   });
+
+   it("places vectors by the response's index fields, not response order", async () => {
+      const captured: CapturedRequest[] = [];
+      const provider = new EmbeddingProvider(
+         CONFIG,
+         stubFetch(
+            captured,
+            () =>
+               new Response(
+                  JSON.stringify({
+                     data: [
+                        { index: 1, embedding: [2, 2] },
+                        { index: 0, embedding: [1, 1] },
+                     ],
+                  }),
+                  { status: 200 },
+               ),
+         ),
+      );
+      const vectors = await provider.embedBatch(["a", "b"], 1000);
+      expect(vectors).toEqual([
+         [1, 1],
+         [2, 2],
+      ]);
+   });
+
+   it("splits large inputs into batches", async () => {
+      const captured: CapturedRequest[] = [];
+      const provider = new EmbeddingProvider(CONFIG, stubFetch(captured));
+      const texts = Array.from(
+         { length: MAX_EMBED_BATCH_SIZE + 1 },
+         (_, i) => `t${i}`,
+      );
+      const vectors = await provider.embedBatch(texts, 1000);
+      expect(vectors).toHaveLength(texts.length);
+      expect(captured).toHaveLength(2);
+      expect((captured[0].body.input as string[]).length).toBe(
+         MAX_EMBED_BATCH_SIZE,
+      );
+      expect((captured[1].body.input as string[]).length).toBe(1);
+   });
+
+   it("sends the dimensions param only when configured", async () => {
+      const captured: CapturedRequest[] = [];
+      const without = new EmbeddingProvider(CONFIG, stubFetch(captured));
+      await without.embedBatch(["a"], 1000);
+      expect(captured[0].body.dimensions).toBeUndefined();
+
+      const withDims = new EmbeddingProvider(
+         { ...CONFIG, dimensions: 512 },
+         stubFetch(captured),
+      );
+      await withDims.embedBatch(["a"], 1000);
+      expect(captured[1].body.dimensions).toBe(512);
+   });
+
+   it("reports HTTP failures with a truncated body and no header echo", async () => {
+      const provider = new EmbeddingProvider(
+         CONFIG,
+         stubFetch(
+            [],
+            () => new Response("boom ".repeat(100), { status: 429 }),
+         ),
+      );
+      const err = await provider.embedBatch(["a"], 1000).then(
+         () => undefined,
+         (e: Error) => e,
+      );
+      expect(err).toBeDefined();
+      expect(err!.message).toContain("(429)");
+      expect(err!.message.length).toBeLessThan(400);
+      expect(err!.message).not.toContain("test-key");
+   });
+
+   it("drops auth-failure bodies entirely (they can reflect the key)", async () => {
+      const provider = new EmbeddingProvider(
+         CONFIG,
+         stubFetch(
+            [],
+            () =>
+               new Response("Incorrect API key provided: test-key", {
+                  status: 401,
+               }),
+         ),
+      );
+      const err = await provider.embedBatch(["a"], 1000).then(
+         () => undefined,
+         (e: Error) => e,
+      );
+      expect(err!.message).toContain("(401)");
+      expect(err!.message).toContain("authentication failed");
+      expect(err!.message).not.toContain("test-key");
+   });
+
+   it("scrubs literal key occurrences from non-auth error bodies", async () => {
+      const provider = new EmbeddingProvider(
+         CONFIG,
+         stubFetch(
+            [],
+            () =>
+               new Response(
+                  "proxy error while forwarding token test-key upstream",
+                  {
+                     status: 502,
+                  },
+               ),
+         ),
+      );
+      const err = await provider.embedBatch(["a"], 1000).then(
+         () => undefined,
+         (e: Error) => e,
+      );
+      expect(err!.message).toContain("(502)");
+      expect(err!.message).toContain("[REDACTED]");
+      expect(err!.message).not.toContain("test-key");
+   });
+
+   it("names a timeout in the failure message", async () => {
+      const timeoutFetch = (async () => {
+         const error = new Error("The operation timed out");
+         error.name = "TimeoutError";
+         throw error;
+      }) as unknown as typeof fetch;
+      const provider = new EmbeddingProvider(CONFIG, timeoutFetch);
+      const err = await provider.embedBatch(["a"], 1234).then(
+         () => undefined,
+         (e: Error) => e,
+      );
+      expect(err!.message).toContain("timed out after 1234ms");
+   });
+
+   it("rejects a response with the wrong number of embeddings", async () => {
+      const provider = new EmbeddingProvider(
+         CONFIG,
+         stubFetch(
+            [],
+            () =>
+               new Response(
+                  JSON.stringify({ data: [{ index: 0, embedding: [1] }] }),
+                  { status: 200 },
+               ),
+         ),
+      );
+      await expect(provider.embedBatch(["a", "b"], 1000)).rejects.toThrow(
+         "malformed",
+      );
+   });
+
+   it("rejects a vector with non-finite or non-numeric contents", async () => {
+      const provider = new EmbeddingProvider(
+         CONFIG,
+         stubFetch(
+            [],
+            () =>
+               new Response(
+                  JSON.stringify({
+                     data: [{ index: 0, embedding: [1, null, "x"] }],
+                  }),
+                  { status: 200 },
+               ),
+         ),
+      );
+      await expect(provider.embedBatch(["a"], 1000)).rejects.toThrow(
+         "malformed",
+      );
+   });
+});
+
+describe("getEmbeddingProvider / embeddingConfigured", () => {
+   const ENV_KEYS = [
+      "EMBEDDING_API_KEY",
+      "EMBEDDING_MODEL",
+      "EMBEDDING_API_BASE",
+      "EMBEDDING_DIMENSIONS",
+   ];
+   const saved: Record<string, string | undefined> = {};
+
+   beforeEach(() => {
+      for (const key of ENV_KEYS) {
+         saved[key] = process.env[key];
+         delete process.env[key];
+      }
+      _clearEmbeddingProviderForTests();
+   });
+
+   afterEach(() => {
+      for (const key of ENV_KEYS) {
+         if (saved[key] === undefined) delete process.env[key];
+         else process.env[key] = saved[key];
+      }
+      _clearEmbeddingProviderForTests();
+   });
+
+   it("returns null (feature off) without EMBEDDING_API_KEY", () => {
+      expect(getEmbeddingProvider()).toBeNull();
+      expect(embeddingConfigured()).toBe(false);
+   });
+
+   it("ignores an ambient OPENAI_API_KEY", () => {
+      const before = process.env.OPENAI_API_KEY;
+      process.env.OPENAI_API_KEY = "ambient";
+      try {
+         expect(getEmbeddingProvider()).toBeNull();
+         expect(embeddingConfigured()).toBe(false);
+      } finally {
+         if (before === undefined) delete process.env.OPENAI_API_KEY;
+         else process.env.OPENAI_API_KEY = before;
+      }
+   });
+
+   it("builds a provider with defaults when the key is set", () => {
+      process.env.EMBEDDING_API_KEY = "k";
+      const provider = getEmbeddingProvider();
+      expect(provider).not.toBeNull();
+      expect(provider!.model).toBe("text-embedding-3-small");
+      expect(embeddingConfigured()).toBe(true);
+   });
+
+   it("rebuilds the provider when the configuration changes", () => {
+      process.env.EMBEDDING_API_KEY = "k";
+      const first = getEmbeddingProvider();
+      expect(getEmbeddingProvider()).toBe(first);
+      process.env.EMBEDDING_MODEL = "other-model";
+      const second = getEmbeddingProvider();
+      expect(second).not.toBe(first);
+      expect(second!.model).toBe("other-model");
+   });
+
+   it("does not stick to null after the key appears", () => {
+      expect(getEmbeddingProvider()).toBeNull();
+      process.env.EMBEDDING_API_KEY = "k";
+      expect(getEmbeddingProvider()).not.toBeNull();
+   });
+
+   it("throws on a malformed base URL but still reports configured", () => {
+      process.env.EMBEDDING_API_KEY = "k";
+      process.env.EMBEDDING_API_BASE = "not a url";
+      expect(() => getEmbeddingProvider()).toThrow("EMBEDDING_API_BASE");
+      expect(embeddingConfigured()).toBe(true);
+   });
+
+   it("throws on a malformed EMBEDDING_DIMENSIONS", () => {
+      process.env.EMBEDDING_API_KEY = "k";
+      process.env.EMBEDDING_DIMENSIONS = "lots";
+      expect(() => getEmbeddingProvider()).toThrow("EMBEDDING_DIMENSIONS");
+   });
+});