@vellumai/assistant 0.6.2 → 0.6.3

package/src/mcp/client.ts

@@ -35,6 +35,12 @@ export class McpClient {
     | null = null;
   private connected = false;
   private oauthProvider: McpOAuthProvider | null = null;
+  private _lastError: Error | null = null;
+
+  /** The last connection error, if any. Null when connected or not yet attempted. */
+  get lastError(): Error | null {
+    return this._lastError;
+  }
 
   get isConnected(): boolean {
     return this.connected;
@@ -46,6 +52,16 @@ export class McpClient {
       name: "vellum-assistant",
       version: "1.0.0",
     });
+
+    // Prevent SDK-internal transport errors (e.g. SSE reconnection auth
+    // failures) from surfacing as unhandled rejections that crash the daemon
+    // via the global unhandledRejection → shutdown handler.
+    this.client.onerror = (error) => {
+      log.warn(
+        { serverId: this.serverId, err: error },
+        "MCP SDK transport error (non-fatal)",
+      );
+    };
   }
 
   async connect(transportConfig: McpTransport): Promise<void> {
@@ -102,34 +118,24 @@ export class McpClient {
       }
       this.transport = null;
 
-      if (isHttpTransport) {
-        const isAuthError =
-          err instanceof UnauthorizedError ||
-          (err instanceof Error &&
-            /\b(401|403|unauthorized|forbidden)\b/i.test(err.message)) ||
-          (err != null &&
-            typeof err === "object" &&
-            "code" in err &&
-            (err.code === 401 || err.code === 403));
-
-        if (isAuthError) {
-          // Auth-related — user can run `assistant mcp auth <name>` to authenticate.
-          log.info(
-            { serverId: this.serverId, err },
-            "MCP server requires authentication",
-          );
-          return;
-        }
-
-        // Non-auth error (DNS, TLS, timeout, etc.) — log and re-throw
-        log.error(
+      if (isHttpTransport && isAuthRelatedError(err)) {
+        // Auth-related — user can run `assistant mcp auth <name>` to authenticate.
+        log.info(
           { serverId: this.serverId, err },
-          "MCP server connection failed",
+          "MCP server requires authentication",
         );
-        throw err;
+        return;
       }
 
-      throw err;
+      // Non-auth error (DNS, TLS, timeout, etc.) — log but never propagate
+      // an MCP connection failure to the caller.  The daemon must keep
+      // running even when individual MCP servers are unreachable.
+      this._lastError = err instanceof Error ? err : new Error(String(err));
+      log.error(
+        { serverId: this.serverId, err },
+        "MCP server connection failed",
+      );
+      return;
     }
 
     this.connected = true;
@@ -258,3 +264,32 @@ export class McpClient {
     }
   }
 }
+
+/**
+ * Returns true when `err` looks like an authentication / authorization failure
+ * from the MCP SDK or the remote server.  Used to distinguish "needs auth"
+ * from genuine transport failures so we can log guidance instead of crashing.
+ */
+function isAuthRelatedError(err: unknown): boolean {
+  if (err instanceof UnauthorizedError) return true;
+
+  if (
+    err instanceof Error &&
+    /\b(401|403|unauthorized|forbidden|authorizationCode is required|prepareTokenRequest)\b/i.test(
+      err.message,
+    )
+  ) {
+    return true;
+  }
+
+  if (
+    err != null &&
+    typeof err === "object" &&
+    "code" in err &&
+    (err.code === 401 || err.code === 403)
+  ) {
+    return true;
+  }
+
+  return false;
+}

package/src/memory/app-store.ts

@@ -64,6 +64,23 @@ export function isMultifileApp(app: AppDefinition): boolean {
   return app.formatVersion === 2;
 }
 
+/**
+ * Resolve the effective HTML for an app. For single-file apps this is
+ * `htmlDefinition` (the root index.html). For multifile apps it reads the
+ * compiled `dist/index.html` and inlines JS/CSS assets so the result is a
+ * self-contained HTML string suitable for `loadHTMLString`.
+ */
+export function resolveEffectiveAppHtml(app: AppDefinition): string {
+  if (!isMultifileApp(app)) return app.htmlDefinition;
+
+  const appDir = getAppDirPath(app.id);
+  const distIndex = join(appDir, "dist", "index.html");
+  if (existsSync(distIndex)) {
+    return inlineDistAssets(appDir, readFileSync(distIndex, "utf-8"));
+  }
+  return app.htmlDefinition;
+}
+
 /**
  * Inline dist assets (main.js, main.css) into the compiled HTML so it can be
  * delivered as a self-contained string via loadHTMLString/SSE without needing
@@ -75,7 +92,10 @@ export function inlineDistAssets(appDir: string, html: string): string {
   // Inline main.js
   const jsPath = join(distDir, "main.js");
   if (existsSync(jsPath)) {
-    const js = readFileSync(jsPath, "utf-8").replace(/<\/script>/g, "<\\/script>");
+    const js = readFileSync(jsPath, "utf-8").replace(
+      /<\/script>/g,
+      "<\\/script>",
+    );
     html = html.replace(
       /<script\s+type="module"\s+src="main\.js"\s*><\/script>/,
       () => `<script type="module">${js}</script>`,
@@ -818,6 +838,16 @@ export function listAppFiles(appId: string): string[] {
   return results.sort();
 }
 
+/**
+ * Check whether a file exists in the app directory.
+ * Path is validated to prevent traversal.
+ */
+export function appFileExists(appId: string, path: string): boolean {
+  validateId(appId);
+  const resolved = validateFilePath(appId, path);
+  return existsSync(resolved);
+}
+
 /**
  * Read a file from the app directory.
  * Path is validated to prevent traversal.

package/src/memory/conversation-crud.ts

@@ -170,6 +170,7 @@ export interface ConversationRow {
   originInterface: string | null;
   forkParentConversationId: string | null;
   forkParentMessageId: string | null;
+  hostAccess: number;
   isAutoTitle: number;
   scheduleJobId: string | null;
   lastMessageAt: number | null;
@@ -196,6 +197,7 @@ export const parseConversation = createRowMapper<
   originInterface: "originInterface",
   forkParentConversationId: "forkParentConversationId",
   forkParentMessageId: "forkParentMessageId",
+  hostAccess: "hostAccess",
   isAutoTitle: "isAutoTitle",
   scheduleJobId: "scheduleJobId",
   lastMessageAt: "lastMessageAt",
@@ -245,6 +247,7 @@ export function createConversation(
         source?: string;
         scheduleJobId?: string;
         groupId?: string;
+        hostAccess?: boolean;
       },
 ) {
   const db = getDb();
@@ -276,6 +279,7 @@ export function createConversation(
     contextSummary: null as string | null,
     contextCompactedMessageCount: 0,
     contextCompactedAt: null as number | null,
+    hostAccess: opts.hostAccess ? 1 : 0,
     conversationType,
     source,
     memoryScopeId,
@@ -388,6 +392,11 @@ export function getConversationMemoryScopeId(conversationId: string): string {
   return conv?.memoryScopeId ?? "default";
 }
 
+export function getConversationHostAccess(conversationId: string): boolean {
+  const conv = getConversation(conversationId);
+  return conv?.hostAccess === 1;
+}
+
 /**
  * Fetch group_id for a conversation via raw SQL. group_id is NOT in the
  * Drizzle schema (raw-query-only pattern), so ConversationRow doesn't
@@ -1123,6 +1132,20 @@ export function updateConversationContextWindow(
     .run();
 }
 
+export function updateConversationHostAccess(
+  id: string,
+  hostAccess: boolean,
+): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({
+      hostAccess: hostAccess ? 1 : 0,
+      updatedAt: Date.now(),
+    })
+    .where(eq(conversations.id, id))
+    .run();
+}
+
 /**
  * Delete all conversations, messages, and related data (tool invocations,
  * memory segments, etc.) from the daemon database.

package/src/memory/conversation-starters-cadence.ts

@@ -0,0 +1,76 @@
+/**
+ * Cadence logic for conversation starters generation.
+ *
+ * Decides whether a new generation job should be enqueued based on how many
+ * active memory items have accumulated since the last generation.
+ */
+
+import { and, eq, inArray, sql } from "drizzle-orm";
+
+import { getLogger } from "../util/logger.js";
+import { getDb } from "./db.js";
+import { enqueueMemoryJob } from "./jobs-store.js";
+import { rawGet } from "./raw-query.js";
+import { memoryCheckpoints, memoryJobs } from "./schema.js";
+
+const log = getLogger("conversation-starters-cadence");
+
+/**
+ * Check whether enough new memory items have accumulated to justify
+ * generating a fresh batch of conversation starters.
+ */
+export function maybeEnqueueConversationStartersJob(scopeId: string): void {
+  const db = getDb();
+
+  // Count total active memory items
+  const countRow = rawGet<{ c: number }>(
+    `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
+    scopeId,
+  );
+  const totalActive = countRow?.c ?? 0;
+  if (totalActive === 0) return;
+
+  // Read checkpoint: item count at last generation (scoped so each scope tracks independently)
+  const checkpointKey = `conversation_starters:item_count_at_last_gen:${scopeId}`;
+  const checkpoint = db
+    .select({ value: memoryCheckpoints.value })
+    .from(memoryCheckpoints)
+    .where(eq(memoryCheckpoints.key, checkpointKey))
+    .get();
+  const parsedLastCount = checkpoint ? parseInt(checkpoint.value, 10) : 0;
+  const lastCount = Number.isFinite(parsedLastCount) ? parsedLastCount : 0;
+
+  // Cadence formula
+  let threshold: number;
+  if (totalActive <= 10) {
+    threshold = 1;
+  } else if (totalActive <= 50) {
+    threshold = 5;
+  } else {
+    threshold = 10;
+  }
+
+  const checkpointAhead = totalActive < lastCount;
+  const delta = Math.max(0, totalActive - lastCount);
+  if (!checkpointAhead && delta < threshold) return;
+
+  // Dedup: don't enqueue if a pending/running job for this scope already exists
+  const existing = db
+    .select({ id: memoryJobs.id })
+    .from(memoryJobs)
+    .where(
+      and(
+        eq(memoryJobs.type, "generate_conversation_starters"),
+        inArray(memoryJobs.status, ["pending", "running"]),
+        sql`json_extract(${memoryJobs.payload}, '$.scopeId') = ${scopeId}`,
+      ),
+    )
+    .get();
+  if (existing) return;
+
+  enqueueMemoryJob("generate_conversation_starters", { scopeId });
+  log.info(
+    { totalActive, lastCount, delta, threshold, scopeId, checkpointAhead },
+    "Enqueued conversation starters generation job",
+  );
+}

package/src/memory/conversation-title-service.ts

@@ -284,10 +284,13 @@ export function queueRegenerateConversationTitle(
  */
 function buildTitleSystemPrompt(): string {
   return [
-    "You generate short conversation titles. Output ONLY the title text — no explanation, no quotes, no markdown, no preamble.",
+    "You generate ultra-concise conversation titles. Output ONLY the title text — no explanation, no quotes, no markdown, no preamble.",
     "",
     "Rules:",
-    "- Summarize the TOPIC the user is asking about",
+    "- 2–6 words. Titles longer than 6 words are unacceptable — ruthlessly compress",
+    "- Summarize the TOPIC, not the request or instructions",
+    "- Noun phrases are ideal (e.g. 'Auth Middleware Rewrite', 'Docker Volume Mounts')",
+    "- Do NOT echo back what the user asked you to do",
     "- Do NOT respond to the conversation content",
     "- Do NOT assess feasibility or comment on capabilities",
   ].join("\n");

package/src/memory/db-init.ts

@@ -58,6 +58,7 @@ import {
   migrateContactsRolePrincipal,
   migrateContactsUserFileColumn,
   migrateConversationForkLineage,
+  migrateConversationHostAccess,
   migrateConversationsLastMessageAt,
   migrateConversationsThreadTypeIndex,
   migrateCreateConversationGraphMemoryState,
@@ -110,9 +111,14 @@ import {
   migrateOAuthProvidersBehaviorColumns,
   migrateOAuthProvidersDisplayMetadata,
   migrateOAuthProvidersFeatureFlag,
+  migrateOAuthProvidersLogoUrl,
   migrateOAuthProvidersManagedServiceConfigKey,
   migrateOAuthProvidersPingConfig,
   migrateOAuthProvidersPingUrl,
+  migrateOAuthProvidersRefreshUrl,
+  migrateOAuthProvidersRevoke,
+  migrateOAuthProvidersScopeSeparator,
+  migrateOAuthProvidersTokenAuthMethodDefault,
   migrateReminderRoutingIntent,
   migrateRemindersToSchedules,
   migrateRenameConversationTypeColumn,
@@ -352,6 +358,12 @@ export function initializeDb(): void {
     migrateScheduleReuseConversation,
     migrateMemoryRecallLogsQueryContext,
     migrateLlmRequestLogsCreatedAtIndex,
+    migrateOAuthProvidersScopeSeparator,
+    migrateOAuthProvidersRefreshUrl,
+    migrateOAuthProvidersRevoke,
+    migrateOAuthProvidersTokenAuthMethodDefault,
+    migrateConversationHostAccess,
+    migrateOAuthProvidersLogoUrl,
   ];
 
   // Run each migration step, catching and logging individual failures so one

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

@@ -0,0 +1,75 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import type { AssistantConfig } from "../config/types.js";
+import {
+  clearEmbeddingBackendCache,
+  resetLocalEmbeddingFailureState,
+  selectEmbeddingBackend,
+} from "./embedding-backend.js";
+
+const LOCAL_CONFIG = {
+  memory: {
+    embeddings: {
+      provider: "local",
+      localModel: "BAAI/bge-small-en-v1.5",
+    },
+  },
+} as unknown as AssistantConfig;
+
+describe("embedding backend cache invalidation", () => {
+  afterEach(() => {
+    clearEmbeddingBackendCache();
+  });
+
+  test("clearEmbeddingBackendCache disposes cached backends before clearing", async () => {
+    const firstSelection = await selectEmbeddingBackend(LOCAL_CONFIG);
+    expect(firstSelection.backend).not.toBeNull();
+
+    const dispose = mock();
+    (firstSelection.backend as { dispose?: () => void }).dispose = dispose;
+
+    clearEmbeddingBackendCache();
+
+    expect(dispose).toHaveBeenCalledTimes(1);
+
+    const secondSelection = await selectEmbeddingBackend(LOCAL_CONFIG);
+    expect(secondSelection.backend).not.toBe(firstSelection.backend);
+  });
+
+  test("resetLocalEmbeddingFailureState preserves live cached backends", async () => {
+    const firstSelection = await selectEmbeddingBackend(LOCAL_CONFIG);
+    expect(firstSelection.backend).not.toBeNull();
+
+    const dispose = mock();
+    (firstSelection.backend as { dispose?: () => void }).dispose = dispose;
+
+    resetLocalEmbeddingFailureState();
+
+    expect(dispose).not.toHaveBeenCalled();
+
+    const secondSelection = await selectEmbeddingBackend(LOCAL_CONFIG);
+    expect(secondSelection.backend).toBe(firstSelection.backend);
+  });
+
+  test("resetLocalEmbeddingFailureState clears poisoned local backend retry state", async () => {
+    const firstSelection = await selectEmbeddingBackend(LOCAL_CONFIG);
+    expect(firstSelection.backend).not.toBeNull();
+
+    const poisonedInitPromise = Promise.reject(new Error("poisoned"));
+    poisonedInitPromise.catch(() => {});
+
+    const backend = firstSelection.backend as unknown as {
+      delegate: unknown;
+      initPromise: Promise<unknown> | null;
+    };
+    backend.delegate = null;
+    backend.initPromise = poisonedInitPromise;
+
+    resetLocalEmbeddingFailureState();
+
+    expect(backend.initPromise).toBeNull();
+
+    const secondSelection = await selectEmbeddingBackend(LOCAL_CONFIG);
+    expect(secondSelection.backend).toBe(firstSelection.backend);
+  });
+});

package/src/memory/embedding-backend.ts

@@ -1,7 +1,10 @@
 import { createHash } from "node:crypto";
 
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getOllamaBaseUrlEnv } from "../config/env.js";
 import type { AssistantConfig } from "../config/types.js";
+import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
+import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
 import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
 import { GeminiEmbeddingBackend } from "./embedding-gemini.js";
@@ -67,6 +70,16 @@ class LazyLocalEmbeddingBackend implements EmbeddingBackend {
     }
   }
 
+  dispose(): void {
+    this.delegate?.dispose?.();
+  }
+
+  resetForRetry(): void {
+    if (!this.delegate) {
+      this.initPromise = null;
+    }
+  }
+
   private async getDelegate(): Promise<EmbeddingBackend> {
     if (this.delegate) return this.delegate;
     if (!this.initPromise) {
@@ -176,12 +189,32 @@ function putInVectorCache(
 
 /** Clear cached embedding backends and the in-memory vector cache. */
 export function clearEmbeddingBackendCache(): void {
+  for (const backend of new Set(backendCache.values())) {
+    try {
+      backend.dispose?.();
+    } catch (err) {
+      log.warn(
+        { err, provider: backend.provider, model: backend.model },
+        "Failed to dispose embedding backend during cache clear",
+      );
+    }
+  }
   backendCache.clear();
   vectorCache.clear();
   vectorCacheBytes = 0;
   localBackendBroken = false;
 }
 
+/** Reset the sticky local-backend failure flag without evicting live backends. */
+export function resetLocalEmbeddingFailureState(): void {
+  localBackendBroken = false;
+  for (const backend of new Set(backendCache.values())) {
+    if (backend instanceof LazyLocalEmbeddingBackend) {
+      backend.resetForRetry();
+    }
+  }
+}
+
 function cacheKey(provider: string, model: string, extras?: string[]): string {
   if (extras && extras.length > 0) {
     return `${provider}:${model}:${extras.join(":")}`;
@@ -243,6 +276,7 @@ export interface EmbeddingBackend {
     inputs: EmbeddingInput[],
     options?: EmbeddingRequestOptions,
   ): Promise<number[][]>;
+  dispose?(): void;
 }
 
 export interface EmbeddingBackendSelection {
@@ -280,6 +314,44 @@ export async function selectEmbeddingBackend(
     };
   }
 
+  // When the managed-gemini-embeddings-enabled flag is on AND managed proxy
+  // prerequisites are satisfied, insert managed-proxy Gemini at the front of
+  // the auto chain so platform assistants use Vellum-managed Gemini embeddings.
+  if (
+    (requested === "auto" || requested === "gemini") &&
+    isAssistantFeatureFlagEnabled("managed-gemini-embeddings-enabled", config)
+  ) {
+    const proxyCtx = await resolveManagedProxyContext();
+    if (proxyCtx.enabled) {
+      const meta = MANAGED_PROVIDER_META["gemini"];
+      if (meta?.managed && meta.proxyPath) {
+        const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
+        const managedModel = config.memory.embeddings.geminiModel;
+        const managedDimensions =
+          config.memory.embeddings.geminiDimensions ?? 3072;
+        const extras = geminiCacheExtras(config);
+        return {
+          backend: getCachedOrCreate(
+            "gemini",
+            managedModel,
+            () =>
+              new GeminiEmbeddingBackend(
+                proxyCtx.assistantApiKey,
+                managedModel,
+                {
+                  taskType: config.memory.embeddings.geminiTaskType,
+                  dimensions: managedDimensions,
+                  managedBaseUrl,
+                },
+              ),
+            [...extras, "managed"],
+          ),
+          reason: null,
+        };
+      }
+    }
+  }
+
   // Auto order: local → openai → gemini → ollama
   const order: EmbeddingProviderName[] =
     requested === "auto"
@@ -329,11 +401,18 @@ export async function selectEmbeddingBackend(
       case "gemini": {
         const geminiKey = await getProviderKeyAsync("gemini");
         if (!geminiKey) {
-          const cached = getCached(
-            "gemini",
-            config.memory.embeddings.geminiModel,
-            geminiCacheExtras(config),
-          );
+          // Check managed cache variant first so a warm managed backend
+          // survives transient proxy-context blips, then non-managed.
+          const cached =
+            getCached("gemini", config.memory.embeddings.geminiModel, [
+              ...geminiCacheExtras(config),
+              "managed",
+            ]) ??
+            getCached(
+              "gemini",
+              config.memory.embeddings.geminiModel,
+              geminiCacheExtras(config),
+            );
           if (cached) return { backend: cached, reason: null };
           continue;
         }
@@ -614,6 +693,53 @@ async function selectFallbackBackends(
               geminiCacheExtras(config),
             ),
           );
+        } else if (
+          isAssistantFeatureFlagEnabled(
+            "managed-gemini-embeddings-enabled",
+            config,
+          )
+        ) {
+          // Try managed proxy Gemini as fallback when no direct key exists.
+          const proxyCtx = await resolveManagedProxyContext();
+          const meta = MANAGED_PROVIDER_META["gemini"];
+          if (proxyCtx.enabled && meta?.managed && meta.proxyPath) {
+            const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
+            const managedModel = config.memory.embeddings.geminiModel;
+            const managedDimensions =
+              config.memory.embeddings.geminiDimensions ?? 3072;
+            const extras = geminiCacheExtras(config);
+            backends.push(
+              getCachedOrCreate(
+                "gemini",
+                managedModel,
+                () =>
+                  new GeminiEmbeddingBackend(
+                    proxyCtx.assistantApiKey,
+                    managedModel,
+                    {
+                      taskType: config.memory.embeddings.geminiTaskType,
+                      dimensions: managedDimensions,
+                      managedBaseUrl,
+                    },
+                  ),
+                [...extras, "managed"],
+              ),
+            );
+          } else {
+            // Check managed cache variant first, then non-managed, so a warm
+            // managed backend survives transient proxy-context blips.
+            const cached =
+              getCached("gemini", config.memory.embeddings.geminiModel, [
+                ...geminiCacheExtras(config),
+                "managed",
+              ]) ??
+              getCached(
+                "gemini",
+                config.memory.embeddings.geminiModel,
+                geminiCacheExtras(config),
+              );
+            if (cached) backends.push(cached);
+          }
         } else {
           // Preserve cached backend on transient credential-store failures.
           const cached = getCached(

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

@@ -253,4 +253,58 @@ describe("GeminiEmbeddingBackend", () => {
       expect(result[1]).toEqual([0.2, 0.4]);
     });
   });
+
+  describe("managed proxy transport", () => {
+    test("routes through managed proxy base URL when managedBaseUrl is set", async () => {
+      const backend = new GeminiEmbeddingBackend(
+        "ast-managed-key",
+        "gemini-embedding-2-preview",
+        {
+          managedBaseUrl:
+            "https://platform.example.com/v1/runtime-proxy/gemini",
+        },
+      );
+      await backend.embed(["hello"]);
+
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(
+        "https://platform.example.com/v1/runtime-proxy/gemini/v1beta/models/gemini-embedding-2-preview:embedContent",
+      );
+      // Should NOT have key= query param
+      expect(url).not.toContain("key=");
+      // Should have Bearer auth header
+      const headers = init.headers as Record<string, string>;
+      expect(headers["Authorization"]).toBe("Bearer ast-managed-key");
+    });
+
+    test("uses direct Google API URL when managedBaseUrl is not set", async () => {
+      const backend = new GeminiEmbeddingBackend("direct-key", "test-model");
+      await backend.embed(["hello"]);
+
+      const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
+      expect(url).toContain("generativelanguage.googleapis.com");
+      expect(url).toContain("key=direct-key");
+      // Should NOT have Authorization header
+      const headers = init.headers as Record<string, string>;
+      expect(headers["Authorization"]).toBeUndefined();
+    });
+
+    test("includes outputDimensionality with managed proxy", async () => {
+      const backend = new GeminiEmbeddingBackend(
+        "ast-managed-key",
+        "gemini-embedding-2-preview",
+        {
+          managedBaseUrl:
+            "https://platform.example.com/v1/runtime-proxy/gemini",
+          dimensions: 3072,
+        },
+      );
+      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(3072);
+    });
+  });
 });