@vellumai/assistant 0.4.43 → 0.4.45

package/src/memory/embedding-backend.ts

@@ -6,6 +6,20 @@ import { getLogger } from "../util/logger.js";
 import { GeminiEmbeddingBackend } from "./embedding-gemini.js";
 import { OllamaEmbeddingBackend } from "./embedding-ollama.js";
 import { OpenAIEmbeddingBackend } from "./embedding-openai.js";
+import {
+  type EmbeddingInput,
+  embeddingInputContentHash,
+  type MultimodalEmbeddingInput,
+  normalizeEmbeddingInput,
+  type TextEmbeddingInput,
+} from "./embedding-types.js";
+
+export type {
+  EmbeddingInput,
+  MultimodalEmbeddingInput,
+  TextEmbeddingInput,
+};
+export { embeddingInputContentHash, normalizeEmbeddingInput };
 
 const log = getLogger("memory-embeddings");
 
@@ -34,12 +48,12 @@ class LazyLocalEmbeddingBackend implements EmbeddingBackend {
   }
 
   async embed(
-    texts: string[],
+    inputs: EmbeddingInput[],
     options?: EmbeddingRequestOptions,
   ): Promise<number[][]> {
     const backend = await this.getDelegate();
     try {
-      return await backend.embed(texts, options);
+      return await backend.embed(inputs, options);
     } catch (err) {
       // The onnxruntime-node failure surfaces here during the first embed() call
       // (via LocalEmbeddingBackend.initialize()). Mark broken so auto mode stops
@@ -103,18 +117,26 @@ function estimateEntryBytes(key: string, vector: number[]): number {
   return key.length * 2 + vector.length * 8;
 }
 
-function vectorCacheKey(provider: string, model: string, text: string): string {
+function vectorCacheKey(
+  provider: string,
+  model: string,
+  input: EmbeddingInput,
+  extras?: string[],
+): string {
+  const contentHash = embeddingInputContentHash(input);
+  const suffix = extras && extras.length > 0 ? `\0${extras.join("\0")}` : "";
   return createHash("sha256")
-    .update(`${provider}\0${model}\0${text}`)
+    .update(`${provider}\0${model}\0${contentHash}${suffix}`)
     .digest("hex");
 }
 
 function getFromVectorCache(
   provider: string,
   model: string,
-  text: string,
+  input: EmbeddingInput,
+  extras?: string[],
 ): number[] | undefined {
-  const key = vectorCacheKey(provider, model, text);
+  const key = vectorCacheKey(provider, model, input, extras);
   const v = vectorCache.get(key);
   if (v !== undefined) {
     // LRU refresh: move to end of insertion order
@@ -127,10 +149,11 @@ function getFromVectorCache(
 function putInVectorCache(
   provider: string,
   model: string,
-  text: string,
+  input: EmbeddingInput,
   vector: number[],
+  extras?: string[],
 ): void {
-  const key = vectorCacheKey(provider, model, text);
+  const key = vectorCacheKey(provider, model, input, extras);
   // If replacing an existing entry, subtract its old cost first
   const existing = vectorCache.get(key);
   if (existing !== undefined) {
@@ -161,7 +184,10 @@ export function clearEmbeddingBackendCache(): void {
   localBackendBroken = false;
 }
 
-function cacheKey(provider: string, model: string): string {
+function cacheKey(provider: string, model: string, extras?: string[]): string {
+  if (extras && extras.length > 0) {
+    return `${provider}:${model}:${extras.join(":")}`;
+  }
   return `${provider}:${model}`;
 }
 
@@ -169,8 +195,9 @@ function getCachedOrCreate<T extends EmbeddingBackend>(
   provider: string,
   model: string,
   create: () => T,
+  extras?: string[],
 ): T {
-  const key = cacheKey(provider, model);
+  const key = cacheKey(provider, model, extras);
   const existing = backendCache.get(key);
   if (existing) return existing as T;
   const instance = create();
@@ -178,6 +205,17 @@ function getCachedOrCreate<T extends EmbeddingBackend>(
   return instance;
 }
 
+function geminiCacheExtras(config: AssistantConfig): string[] {
+  const extras: string[] = [];
+  if (config.memory.embeddings.geminiTaskType) {
+    extras.push(`task=${config.memory.embeddings.geminiTaskType}`);
+  }
+  if (config.memory.embeddings.geminiDimensions != null) {
+    extras.push(`dim=${config.memory.embeddings.geminiDimensions}`);
+  }
+  return extras;
+}
+
 export type EmbeddingProviderName = "local" | "openai" | "gemini" | "ollama";
 
 export interface EmbeddingRequestOptions {
@@ -188,7 +226,7 @@ export interface EmbeddingBackend {
   readonly provider: EmbeddingProviderName;
   readonly model: string;
   embed(
-    texts: string[],
+    inputs: EmbeddingInput[],
     options?: EmbeddingRequestOptions,
   ): Promise<number[][]>;
 }
@@ -272,7 +310,12 @@ export function selectEmbeddingBackend(
               new GeminiEmbeddingBackend(
                 config.apiKeys.gemini,
                 config.memory.embeddings.geminiModel,
+                {
+                  taskType: config.memory.embeddings.geminiTaskType,
+                  dimensions: config.memory.embeddings.geminiDimensions,
+                },
               ),
+            geminiCacheExtras(config),
           ),
           reason: null,
         };
@@ -336,7 +379,7 @@ export function getMemoryBackendStatus(config: AssistantConfig): {
 
 export async function embedWithBackend(
   config: AssistantConfig,
-  texts: string[],
+  inputs: EmbeddingInput[],
   options?: EmbeddingRequestOptions,
 ): Promise<{
   provider: EmbeddingProviderName;
@@ -354,15 +397,22 @@ export async function embedWithBackend(
   const { provider: primaryProvider, model: primaryModel } = selection.backend;
 
   // ── Build fallback backends list (needed for embed fallback) ──
+  // In auto mode, build a fallback chain from all configured backends
+  // (excluding the primary). This lets multimodal inputs fall through
+  // to Gemini even when the primary is local or openai.
   const fallbacks: EmbeddingBackend[] =
     config.memory.embeddings.provider === "auto" &&
-    selection.backend.provider === "local"
-      ? selectFallbackBackends(config, "local")
+    selection.backend.provider !== "gemini"
+      ? selectFallbackBackends(config, selection.backend.provider)
       : [];
 
+  // ── Compute provider-specific vector cache extras ───────────────
+  const vectorExtras =
+    primaryProvider === "gemini" ? geminiCacheExtras(config) : undefined;
+
   // ── In-memory cache check (primary provider only) ──────────────
-  const cached: (number[] | null)[] = texts.map((t) => {
-    const v = getFromVectorCache(primaryProvider, primaryModel, t);
+  const cached: (number[] | null)[] = inputs.map((input) => {
+    const v = getFromVectorCache(primaryProvider, primaryModel, input, vectorExtras);
     if (v && v.length === expectedDim) return v;
     return null;
   });
@@ -378,23 +428,33 @@ export async function embedWithBackend(
     };
   }
 
-  // ── Embed uncached texts ────────────────────────────────────────
+  // ── Embed uncached inputs ───────────────────────────────────────
   const backends: EmbeddingBackend[] = [selection.backend, ...fallbacks];
 
   let lastErr: unknown;
+  let anyBackendAttempted = false;
   for (const backend of backends) {
     const isPrimary = backend === selection.backend;
-    // For the primary backend, only embed uncached texts and merge with cached.
-    // For fallback backends, embed ALL texts since the cache was keyed to the primary.
-    const textsToEmbed = isPrimary
-      ? uncachedIndices.map((i) => texts[i])
-      : texts;
+    // For the primary backend, only embed uncached inputs and merge with cached.
+    // For fallback backends, embed ALL inputs since the cache was keyed to the primary.
+    const inputsToEmbed = isPrimary
+      ? uncachedIndices.map((i) => inputs[i])
+      : inputs;
+
+    // Skip text-only backends for multimodal inputs
+    const hasNonText = inputsToEmbed.some(
+      (i) => typeof i !== "string" && normalizeEmbeddingInput(i).type !== "text",
+    );
+    if (backend.provider !== "gemini" && hasNonText) {
+      continue;
+    }
 
     try {
-      const vectors = await backend.embed(textsToEmbed, options);
-      if (vectors.length !== textsToEmbed.length) {
+      anyBackendAttempted = true;
+      const vectors = await backend.embed(inputsToEmbed, options);
+      if (vectors.length !== inputsToEmbed.length) {
         throw new Error(
-          `Embedding backend returned ${vectors.length} vectors for ${textsToEmbed.length} texts`,
+          `Embedding backend returned ${vectors.length} vectors for ${inputsToEmbed.length} inputs`,
         );
       }
       for (const vec of vectors) {
@@ -406,12 +466,15 @@ export async function embedWithBackend(
       }
 
       // Populate cache with freshly embedded vectors
-      for (let i = 0; i < textsToEmbed.length; i++) {
+      const backendExtras =
+        backend.provider === "gemini" ? geminiCacheExtras(config) : undefined;
+      for (let i = 0; i < inputsToEmbed.length; i++) {
         putInVectorCache(
           backend.provider,
           backend.model,
-          textsToEmbed[i],
+          inputsToEmbed[i],
           vectors[i],
+          backendExtras,
         );
       }
 
@@ -437,6 +500,16 @@ export async function embedWithBackend(
       }
     }
   }
+  if (!anyBackendAttempted) {
+    const hasMultimodal = inputs.some(
+      (i) => typeof i !== "string" && normalizeEmbeddingInput(i).type !== "text",
+    );
+    if (hasMultimodal) {
+      throw new Error(
+        "No available embedding backend supports multimodal inputs. Gemini API key is required for image/audio/video embeddings.",
+      );
+    }
+  }
   throw lastErr;
 }
 
@@ -478,7 +551,12 @@ function selectFallbackBackends(
                 new GeminiEmbeddingBackend(
                   config.apiKeys.gemini,
                   config.memory.embeddings.geminiModel,
+                  {
+                    taskType: config.memory.embeddings.geminiTaskType,
+                    dimensions: config.memory.embeddings.geminiDimensions,
+                  },
                 ),
+              geminiCacheExtras(config),
             ),
           );
         }
@@ -505,6 +583,30 @@ function selectFallbackBackends(
   return backends;
 }
 
+/**
+ * Returns true when the embedding pipeline can handle multimodal inputs
+ * (images, audio, video). Today only Gemini supports multimodal.
+ *
+ * In auto mode, the primary backend is usually local or OpenAI, but
+ * embedWithBackend builds a fallback chain that includes Gemini when
+ * available. We check both the primary and fallback backends so that
+ * multimodal jobs are still enqueued when Gemini is reachable via fallback.
+ */
+export function selectedBackendSupportsMultimodal(
+  config: AssistantConfig,
+): boolean {
+  const { backend } = selectEmbeddingBackend(config);
+  if (!backend) return false;
+  if (backend.provider === "gemini") return true;
+
+  // In auto mode, check if Gemini is available as a fallback backend.
+  if (config.memory.embeddings.provider === "auto") {
+    const fallbacks = selectFallbackBackends(config, backend.provider);
+    return fallbacks.some((fb) => fb.provider === "gemini");
+  }
+  return false;
+}
+
 function isOllamaConfigured(config: AssistantConfig): boolean {
   return (
     config.provider === "ollama" ||

package/src/memory/embedding-gemini.test.ts

@@ -0,0 +1,256 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { GeminiEmbeddingBackend } from "./embedding-gemini.js";
+
+function makeSuccessResponse(values: number[]) {
+  return new Response(JSON.stringify({ embedding: { values } }), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+describe("GeminiEmbeddingBackend", () => {
+  const originalFetch = globalThis.fetch;
+  let mockFetch: ReturnType<typeof mock>;
+
+  beforeEach(() => {
+    mockFetch = mock(() => Promise.resolve(makeSuccessResponse([0.1, 0.2, 0.3])));
+    globalThis.fetch = mockFetch as unknown as typeof fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  describe("text inputs", () => {
+    test("sends text as parts: [{ text }]", async () => {
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await backend.embed(["hello world"]);
+
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      expect(url).toContain("models/test-model:embedContent");
+      expect(url).toContain("key=test-key");
+
+      const body = JSON.parse(init.body as string);
+      expect(body.model).toBe("models/test-model");
+      expect(body.content).toEqual({ parts: [{ text: "hello world" }] });
+    });
+
+    test("handles TextEmbeddingInput objects", async () => {
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await backend.embed([{ type: "text", text: "structured text" }]);
+
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.content).toEqual({ parts: [{ text: "structured text" }] });
+    });
+  });
+
+  describe("image inputs", () => {
+    test("sends image as inline_data with base64", async () => {
+      const imageData = Buffer.from("fake-png-data");
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await backend.embed([
+        { type: "image", data: imageData, mimeType: "image/png" },
+      ]);
+
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.content).toEqual({
+        parts: [
+          {
+            inline_data: {
+              mime_type: "image/png",
+              data: imageData.toString("base64"),
+            },
+          },
+        ],
+      });
+    });
+  });
+
+  describe("audio inputs", () => {
+    test("sends audio as inline_data with base64", async () => {
+      const audioData = Buffer.from("fake-audio-data");
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await backend.embed([
+        { type: "audio", data: audioData, mimeType: "audio/mp3" },
+      ]);
+
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.content).toEqual({
+        parts: [
+          {
+            inline_data: {
+              mime_type: "audio/mp3",
+              data: audioData.toString("base64"),
+            },
+          },
+        ],
+      });
+    });
+  });
+
+  describe("video inputs", () => {
+    test("sends video as inline_data with base64", async () => {
+      const videoData = Buffer.from("fake-video-data");
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await backend.embed([
+        { type: "video", data: videoData, mimeType: "video/mp4" },
+      ]);
+
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.content).toEqual({
+        parts: [
+          {
+            inline_data: {
+              mime_type: "video/mp4",
+              data: videoData.toString("base64"),
+            },
+          },
+        ],
+      });
+    });
+  });
+
+  describe("taskType and outputDimensionality", () => {
+    test("includes taskType in request body when configured", async () => {
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model", {
+        taskType: "RETRIEVAL_DOCUMENT",
+      });
+      await backend.embed(["hello"]);
+
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.taskType).toBe("RETRIEVAL_DOCUMENT");
+    });
+
+    test("includes outputDimensionality in request body when dimensions configured", async () => {
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model", {
+        dimensions: 256,
+      });
+      await backend.embed(["hello"]);
+
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.outputDimensionality).toBe(256);
+    });
+
+    test("includes both taskType and outputDimensionality when both configured", async () => {
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model", {
+        taskType: "SEMANTIC_SIMILARITY",
+        dimensions: 512,
+      });
+      await backend.embed(["hello"]);
+
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.taskType).toBe("SEMANTIC_SIMILARITY");
+      expect(body.outputDimensionality).toBe(512);
+    });
+
+    test("omits taskType when not configured", async () => {
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await backend.embed(["hello"]);
+
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.taskType).toBeUndefined();
+    });
+
+    test("omits outputDimensionality when not configured", async () => {
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await backend.embed(["hello"]);
+
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.outputDimensionality).toBeUndefined();
+    });
+
+    test("omits both when options is undefined", async () => {
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await backend.embed(["hello"]);
+
+      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      const body = JSON.parse(init.body as string);
+      expect(body.taskType).toBeUndefined();
+      expect(body.outputDimensionality).toBeUndefined();
+      expect(Object.keys(body)).toEqual(["model", "content"]);
+    });
+  });
+
+  describe("error handling", () => {
+    test("throws on non-OK response", async () => {
+      mockFetch = mock(() =>
+        Promise.resolve(
+          new Response("Internal Server Error", { status: 500 }),
+        ),
+      );
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await expect(backend.embed(["hello"])).rejects.toThrow(
+        "Gemini embeddings request failed (500): Internal Server Error",
+      );
+    });
+
+    test("throws when response is missing embedding values", async () => {
+      mockFetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify({}), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          }),
+        ),
+      );
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await expect(backend.embed(["hello"])).rejects.toThrow(
+        "Gemini embeddings response missing vector values",
+      );
+    });
+
+    test("throws when embedding values array is empty", async () => {
+      mockFetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify({ embedding: { values: [] } }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          }),
+        ),
+      );
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      await expect(backend.embed(["hello"])).rejects.toThrow(
+        "Gemini embeddings response missing vector values",
+      );
+    });
+  });
+
+  describe("multiple inputs", () => {
+    test("embeds multiple inputs sequentially", async () => {
+      let callCount = 0;
+      mockFetch = mock(() => {
+        callCount++;
+        return Promise.resolve(
+          makeSuccessResponse([0.1 * callCount, 0.2 * callCount]),
+        );
+      });
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      const backend = new GeminiEmbeddingBackend("test-key", "test-model");
+      const result = await backend.embed(["hello", "world"]);
+
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual([0.1, 0.2]);
+      expect(result[1]).toEqual([0.2, 0.4]);
+    });
+  });
+});

package/src/memory/embedding-gemini.ts

@@ -1,7 +1,13 @@
 import type {
   EmbeddingBackend,
+  EmbeddingInput,
   EmbeddingRequestOptions,
 } from "./embedding-backend.js";
+import type {
+  EmbeddingTaskType,
+  MultimodalEmbeddingInput,
+} from "./embedding-types.js";
+import { normalizeEmbeddingInput } from "./embedding-types.js";
 
 interface GeminiEmbedResponse {
   embedding?: {
@@ -13,46 +19,59 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
   readonly provider = "gemini" as const;
   readonly model: string;
   private readonly apiKey: string;
+  private readonly taskType?: EmbeddingTaskType;
+  private readonly dimensions?: number;
 
-  constructor(apiKey: string, model: string) {
+  constructor(
+    apiKey: string,
+    model: string,
+    options?: { taskType?: EmbeddingTaskType; dimensions?: number },
+  ) {
     this.apiKey = apiKey;
     this.model = model;
+    this.taskType = options?.taskType;
+    this.dimensions = options?.dimensions;
   }
 
   async embed(
-    texts: string[],
+    inputs: EmbeddingInput[],
     options?: EmbeddingRequestOptions,
   ): Promise<number[][]> {
     const vectors: number[][] = [];
-    for (const text of texts) {
-      const values = await this.embedSingle(text, options);
+    for (const input of inputs) {
+      const values = await this.embedSingle(input, options);
       vectors.push(values);
     }
     return vectors;
   }
 
   private async embedSingle(
-    text: string,
+    input: EmbeddingInput,
     options?: EmbeddingRequestOptions,
   ): Promise<number[]> {
+    const normalized = normalizeEmbeddingInput(input);
+    const parts = this.buildParts(normalized);
+
+    const body: Record<string, unknown> = {
+      model: `models/${this.model}`,
+      content: { parts },
+    };
+    if (this.taskType) body.taskType = this.taskType;
+    if (this.dimensions) body.outputDimensionality = this.dimensions;
+
     const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(
       this.model,
     )}:embedContent?key=${encodeURIComponent(this.apiKey)}`;
     const response = await fetch(url, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: `models/${this.model}`,
-        content: {
-          parts: [{ text }],
-        },
-      }),
+      body: JSON.stringify(body),
       signal: options?.signal,
     });
     if (!response.ok) {
-      const body = await response.text();
+      const responseBody = await response.text();
       throw new Error(
-        `Gemini embeddings request failed (${response.status}): ${body}`,
+        `Gemini embeddings request failed (${response.status}): ${responseBody}`,
       );
     }
     const payload = (await response.json()) as GeminiEmbedResponse;
@@ -62,4 +81,19 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     }
     return values;
   }
+
+  private buildParts(input: MultimodalEmbeddingInput): unknown[] {
+    if (input.type === "text") {
+      return [{ text: input.text }];
+    }
+    // Image, audio, video: use inline_data with base64
+    return [
+      {
+        inline_data: {
+          mime_type: input.mimeType,
+          data: input.data.toString("base64"),
+        },
+      },
+    ];
+  }
 }

package/src/memory/embedding-local.ts

@@ -6,9 +6,11 @@ import { getEmbeddingModelsDir, getRootDir } from "../util/platform.js";
 import { PromiseGuard } from "../util/promise-guard.js";
 import type {
   EmbeddingBackend,
+  EmbeddingInput,
   EmbeddingRequestOptions,
 } from "./embedding-backend.js";
 import { EmbeddingRuntimeManager } from "./embedding-runtime-manager.js";
+import { normalizeEmbeddingInput } from "./embedding-types.js";
 
 const log = getLogger("memory-embedding-local");
 
@@ -56,10 +58,20 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
   }
 
   async embed(
-    texts: string[],
+    inputs: EmbeddingInput[],
     options?: EmbeddingRequestOptions,
   ): Promise<number[][]> {
-    if (texts.length === 0) return [];
+    if (inputs.length === 0) return [];
+
+    const texts = inputs.map((i) => {
+      const n = normalizeEmbeddingInput(i);
+      if (n.type !== "text") {
+        throw new Error(
+          "Local embedding backend only supports text inputs",
+        );
+      }
+      return n.text;
+    });
     if (options?.signal?.aborted)
       throw new DOMException("Aborted", "AbortError");