@vellumai/assistant 0.5.1 → 0.5.2

package/src/daemon/conversation-surfaces.ts

@@ -1,6 +1,11 @@
 import { v4 as uuid } from "uuid";
 
-import { getApp, getAppPreview, updateApp } from "../memory/app-store.js";
+import {
+  getApp,
+  getAppPreview,
+  resolveAppDir,
+  updateApp,
+} from "../memory/app-store.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { isPlainObject } from "../util/object.js";
@@ -187,6 +192,7 @@ export interface SurfaceConversationContext {
     }
   >;
   surfaceUndoStacks: Map<string, string[]>;
+  accumulatedSurfaceState: Map<string, Record<string, unknown>>;
   /** Request IDs that originated from surface action button clicks (not regular user messages). */
   surfaceActionRequestIds: Set<string>;
   currentTurnSurfaces: Array<{
@@ -346,6 +352,39 @@ function handleDocumentContentChanged(
   }
 }
 
+/**
+ * Handle state_update action from a dynamic page.
+ * Accumulates state via shallow merge without triggering an LLM turn.
+ */
+function handleStateUpdate(
+  ctx: SurfaceConversationContext,
+  surfaceId: string,
+  data?: Record<string, unknown>,
+): void {
+  if (!data) {
+    log.debug({ surfaceId }, "state_update action called with no data");
+    return;
+  }
+
+  const surfaceState = ctx.surfaceState.get(surfaceId);
+  if (!surfaceState || surfaceState.surfaceType !== "dynamic_page") {
+    log.warn(
+      { surfaceId, surfaceType: surfaceState?.surfaceType },
+      "state_update action received for non-dynamic_page surface",
+    );
+    return;
+  }
+
+  const existing = ctx.accumulatedSurfaceState.get(surfaceId) ?? {};
+  const merged = { ...existing, ...data };
+  ctx.accumulatedSurfaceState.set(surfaceId, merged);
+
+  log.debug(
+    { surfaceId, accumulatedState: merged },
+    "Accumulated surface state updated",
+  );
+}
+
 export function pushUndoState(
   surfaceUndoStacks: Map<string, string[]>,
   surfaceId: string,
@@ -543,17 +582,60 @@ export function handleSurfaceAction(
   const pending = ctx.pendingSurfaceActions.get(surfaceId);
 
   // When surfaces are restored from history (e.g. onboarding cards), there is
-  // no in-memory pendingSurfaceActions entry.  For relay_prompt / agent_prompt
-  // actions the client already sends the full payload (including { prompt }),
-  // so we can handle them without stored state.
+  // no in-memory pendingSurfaceActions entry.  Handle non-terminal actions
+  // directly, and forward custom/relay actions to the LLM.
   if (!pending) {
+    // Non-terminal actions don't need stored state — handle directly.
+    if (actionId === "selection_changed") {
+      log.debug(
+        { surfaceId, data },
+        "Selection changed (history-restored, not forwarding)",
+      );
+      return;
+    }
+    if (actionId === "content_changed") {
+      log.debug(
+        { surfaceId },
+        "Content changed (history-restored, no surface state — skipping)",
+      );
+      return;
+    }
+    if (actionId === "state_update") {
+      if (data) {
+        const existing = ctx.accumulatedSurfaceState.get(surfaceId) ?? {};
+        ctx.accumulatedSurfaceState.set(surfaceId, { ...existing, ...data });
+      }
+      log.debug(
+        { surfaceId, data },
+        "Silent state accumulated (history-restored)",
+      );
+      return;
+    }
+
+    // Determine message content from the action.
     const isRelay = actionId === "relay_prompt" || actionId === "agent_prompt";
     const prompt =
       isRelay && typeof data?.prompt === "string" ? data.prompt.trim() : "";
 
-    if (!prompt) {
-      log.warn({ surfaceId, actionId }, "No pending surface action found");
-      return;
+    let content: string;
+    let displayContent: string | undefined;
+    if (prompt) {
+      content = prompt;
+    } else {
+      // Custom action from an app (e.g. sendAction('answer_selected', {...}))
+      const summary = actionId
+        .replace(/_/g, " ")
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+      content = `[User action on app: ${summary}]`;
+      if (data && Object.keys(data).length > 0) {
+        content += `\n\nAction data: ${JSON.stringify(data)}`;
+      }
+      const accState = ctx.accumulatedSurfaceState.get(surfaceId);
+      if (accState && Object.keys(accState).length > 0) {
+        content += `\n\nAccumulated surface state: ${JSON.stringify(accState)}`;
+        ctx.accumulatedSurfaceState.delete(surfaceId);
+      }
+      displayContent = summary;
     }
 
     const requestId = uuid();
@@ -567,11 +649,15 @@ export function handleSurfaceAction(
     });
 
     const result = ctx.enqueueMessage(
-      prompt,
+      content,
       [],
       onEvent,
       requestId,
       surfaceId,
+      undefined,
+      undefined,
+      undefined,
+      displayContent,
     );
 
     if (result.rejected) {
@@ -581,16 +667,18 @@ export function handleSurfaceAction(
 
     // Echo the prompt to the client so it appears in the chat UI.
     // Deferred until after rejection check to avoid ghost messages.
-    ctx.sendToClient({
-      type: "user_message_echo",
-      text: prompt,
-      conversationId: ctx.conversationId,
-    });
+    if (prompt) {
+      ctx.sendToClient({
+        type: "user_message_echo",
+        text: prompt,
+        conversationId: ctx.conversationId,
+      });
+    }
 
     if (result.queued) {
       log.info(
         { surfaceId, actionId, requestId },
-        "Relay prompt queued (conversation busy, history-restored)",
+        "Surface action queued (conversation busy, history-restored)",
       );
       return;
     }
@@ -598,22 +686,31 @@ export function handleSurfaceAction(
     // Conversation is idle — process the message immediately.
     log.info(
       { surfaceId, actionId, requestId },
-      "Processing relay prompt immediately (history-restored)",
+      "Processing surface action immediately (history-restored)",
     );
     ctx
-      .processMessage(prompt, [], onEvent, requestId, surfaceId)
+      .processMessage(
+        content,
+        [],
+        onEvent,
+        requestId,
+        surfaceId,
+        undefined,
+        undefined,
+        displayContent,
+      )
       .catch((err) => {
         const message = err instanceof Error ? err.message : String(err);
         log.error(
           { err, surfaceId, actionId },
-          "Failed to process history-restored relay prompt",
+          "Failed to process history-restored surface action",
         );
         onEvent(
           buildConversationErrorMessage(ctx.conversationId, {
             code: "CONVERSATION_PROCESSING_FAILED",
             userMessage: `Something went wrong: ${message}`,
             retryable: false,
-            debugDetails: `History-restored relay prompt processing failed: ${message}`,
+            debugDetails: `History-restored surface action processing failed: ${message}`,
             errorCategory: "processing_failed",
           }),
         );
@@ -637,6 +734,14 @@ export function handleSurfaceAction(
     handleDocumentContentChanged(ctx, surfaceId, data);
     return;
   }
+
+  // state_update is a silent accumulation action — merge data into accumulated
+  // state without triggering an LLM turn.
+  if (actionId === "state_update") {
+    handleStateUpdate(ctx, surfaceId, data);
+    return;
+  }
+
   // Merge stored action-level data (from ui_show definition) with client-sent
   // data. This is critical for relay_prompt buttons: the client only sends the
   // actionId, but the prompt payload lives in the action definition's data.
@@ -694,6 +799,10 @@ export function handleSurfaceAction(
       selectedIds,
     );
   }
+  const accumulatedState = ctx.accumulatedSurfaceState.get(surfaceId);
+  if (accumulatedState && Object.keys(accumulatedState).length > 0) {
+    fallbackContent += `\n\nAccumulated surface state: ${JSON.stringify(accumulatedState)}`;
+  }
   // When a relay_prompt button also carries selection data (e.g. list/table
   // surface with a canned prompt + user-selected rows), append the selection
   // context so the LLM sees both the prompt and the user's selections.
@@ -707,6 +816,11 @@ export function handleSurfaceAction(
       );
     }
   }
+  // When prompt is truthy, fallbackContent (which includes accumulated state)
+  // is discarded. Re-append accumulated state so the LLM sees it.
+  if (prompt && accumulatedState && Object.keys(accumulatedState).length > 0) {
+    content += `\n\nAccumulated surface state: ${JSON.stringify(accumulatedState)}`;
+  }
   // Show the user plain-text instead of raw JSON action data.
   const displayContent = prompt
     ? undefined
@@ -743,6 +857,12 @@ export function handleSurfaceAction(
     return;
   }
 
+  // One-shot: clear accumulated state now that the message has been accepted.
+  // Deferred until after rejection check so state is preserved for retry on rejection.
+  if (accumulatedState && Object.keys(accumulatedState).length > 0) {
+    ctx.accumulatedSurfaceState.delete(surfaceId);
+  }
+
   // Echo the user's prompt to the client so it appears in the chat UI.
   // Deferred until after rejection check to avoid ghost messages.
   if (shouldRelayPrompt && prompt) {
@@ -811,7 +931,7 @@ export function handleSurfaceAction(
 }
 
 /**
- * After an app_update, refresh any active surface that displays the updated app.
+ * After an app_refresh, refresh any active surface that displays the updated app.
  */
 export function refreshSurfacesForApp(
   ctx: SurfaceConversationContext,
@@ -860,7 +980,7 @@ export function refreshSurfacesForApp(
     refreshed = true;
     log.info(
       { conversationId: ctx.conversationId, surfaceId, appId },
-      "Auto-refreshed surface after app_update",
+      "Auto-refreshed surface after app_refresh",
     );
   }
   return refreshed;
@@ -1201,6 +1321,7 @@ export async function surfaceProxyResolver(
     ctx.surfaceState.delete(surfaceId);
     ctx.surfaceUndoStacks.delete(surfaceId);
     ctx.lastSurfaceAction.delete(surfaceId);
+    ctx.accumulatedSurfaceState.delete(surfaceId);
     return {
       content: lastAction ? "Surface completed" : "Surface dismissed",
       isError: false,
@@ -1219,9 +1340,11 @@ export async function surfaceProxyResolver(
     const defaultPreview = { title: app.name, subtitle: app.description };
 
     const storedPreview = getAppPreview(app.id);
+    const { dirName } = resolveAppDir(app.id);
     const surfaceData: DynamicPageSurfaceData = {
       html: app.htmlDefinition,
       appId: app.id,
+      dirName,
       preview: {
         ...defaultPreview,
         ...preview,

package/src/daemon/conversation-tool-setup.ts

@@ -560,8 +560,6 @@ export interface SkillProjectionContext {
   };
   /** True when no client is connected (HTTP-only). */
   readonly hasNoClient?: boolean;
-  /** True when the conversation has user-uploaded attachments. */
-  hasAttachments?: boolean;
 }
 
 // ── Conditional tool sets ────────────────────────────────────────────
@@ -573,7 +571,6 @@ const HOST_TOOL_NAMES = new Set([
   "host_file_edit",
   "host_bash",
 ]);
-const ASSET_TOOL_NAMES = new Set(["asset_search", "asset_materialize"]);
 const CLIENT_CAPABILITY_TOOL_NAMES = new Set(["app_open"]);
 const PLATFORM_TOOL_NAMES = new Set(["request_system_permission"]);
 
@@ -597,9 +594,6 @@ export function isToolActiveForContext(
     // unchecked host command execution on the daemon host.
     return !ctx.hasNoClient;
   }
-  if (ASSET_TOOL_NAMES.has(name)) {
-    return ctx.hasAttachments ?? false;
-  }
   if (CLIENT_CAPABILITY_TOOL_NAMES.has(name)) {
     return !ctx.hasNoClient;
   }

package/src/daemon/conversation-workspace.ts

@@ -1,3 +1,7 @@
+import { join } from "node:path";
+
+import { getConversation } from "../memory/conversation-crud.js";
+import { resolveConversationDirectoryPaths } from "../memory/conversation-directories.js";
 import { renderWorkspaceTopLevelContext } from "../workspace/top-level-renderer.js";
 import { scanTopLevelDirectories } from "../workspace/top-level-scanner.js";
 
@@ -5,6 +9,7 @@ import { scanTopLevelDirectories } from "../workspace/top-level-scanner.js";
  * Subset of Conversation state that workspace context helpers need.
  */
 export interface WorkspaceConversationContext {
+  conversationId: string;
   workingDir: string;
   workspaceTopLevelContext: string | null;
   workspaceTopLevelDirty: boolean;
@@ -17,6 +22,21 @@ export function refreshWorkspaceTopLevelContextIfNeeded(
   if (!ctx.workspaceTopLevelDirty && ctx.workspaceTopLevelContext != null)
     return;
   const snapshot = scanTopLevelDirectories(ctx.workingDir);
-  ctx.workspaceTopLevelContext = renderWorkspaceTopLevelContext(snapshot);
+  const conversation = getConversation(ctx.conversationId);
+  let currentConversationPath: string | null = null;
+  if (conversation && typeof conversation.createdAt === "number") {
+    const { resolvedDirName } = resolveConversationDirectoryPaths(
+      conversation.id,
+      conversation.createdAt,
+      join(ctx.workingDir, "conversations"),
+    );
+    currentConversationPath = `conversations/${resolvedDirName}/`;
+  }
+  ctx.workspaceTopLevelContext = renderWorkspaceTopLevelContext(snapshot, {
+    currentConversationPath,
+    currentConversationAttachmentsPath: currentConversationPath
+      ? `${currentConversationPath}attachments/`
+      : null,
+  });
   ctx.workspaceTopLevelDirty = false;
 }

package/src/daemon/conversation.ts

@@ -38,6 +38,7 @@ import {
 import { registerToolTraceListener } from "../events/tool-trace-listener.js";
 import { getHookManager } from "../hooks/manager.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
+import { getMessages } from "../memory/conversation-crud.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import { patternMatchesCandidate } from "../permissions/trust-store.js";
@@ -81,7 +82,6 @@ import type {
   ChannelCapabilities,
   TrustContext,
 } from "./conversation-runtime-assembly.js";
-import { messagesContainAttachments } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import {
   createSurfaceMutex,
@@ -164,7 +164,6 @@ export class Conversation {
   /** @internal */ contextCompactedAt: number | null = null;
   /** @internal */ currentRequestId?: string;
   /** @internal */ hasNoClient = false;
-  /** @internal */ hasAttachments = false;
   /** @internal */ headlessLock = false;
   /** @internal */ taskRunId?: string;
   /** @internal */ callSessionId?: string;
@@ -200,6 +199,10 @@ export class Conversation {
     { surfaceType: SurfaceType; data: SurfaceData; title?: string }
   >();
   /** @internal */ surfaceUndoStacks = new Map<string, string[]>();
+  /** @internal */ accumulatedSurfaceState = new Map<
+    string,
+    Record<string, unknown>
+  >();
   /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{
     surfaceId: string;
@@ -379,13 +382,35 @@ export class Conversation {
 
   async loadFromDb(): Promise<void> {
     await loadFromDbImpl(this);
-    // Scan loaded history for attachment content blocks so that asset
-    // tools are available when resuming a conversation that already had
-    // attachments. One-way: once true it stays true for the conversation.
-    // Also picks up the hasAttachments flag set by loadFromDbImpl which
-    // scans compacted (sliced-off) messages that aren't in this.messages.
-    if (!this.hasAttachments && messagesContainAttachments(this.messages)) {
-      this.hasAttachments = true;
+    this.restoreSurfaceStateFromHistory();
+  }
+
+  /**
+   * Scan ALL persisted messages (including compacted ones) for ui_surface
+   * content blocks and populate surfaceState so findConversationBySurfaceId
+   * works for surfaces restored from history (e.g. after daemon restart).
+   */
+  private restoreSurfaceStateFromHistory(): void {
+    const dbMessages = getMessages(this.conversationId);
+    for (const row of dbMessages) {
+      try {
+        const content = JSON.parse(row.content);
+        if (!Array.isArray(content)) continue;
+        for (const block of content) {
+          if (
+            block.type === "ui_surface" &&
+            typeof block.surfaceId === "string"
+          ) {
+            this.surfaceState.set(block.surfaceId, {
+              surfaceType: (block.surfaceType ?? "dynamic_page") as SurfaceType,
+              data: (block.data ?? {}) as SurfaceData,
+              title: block.title as string | undefined,
+            });
+          }
+        }
+      } catch {
+        // Content isn't valid JSON — skip
+      }
     }
   }
 
@@ -606,6 +631,18 @@ export class Conversation {
       "Resuming after approval",
     );
 
+    // Sync the canonical guardian request status so stale "pending" DB
+    // records don't get matched by later guardian reply routing. Best-effort:
+    // CAS may harmlessly fail if the canonical decision primitive already
+    // resolved the request (e.g. channel approval path).
+    try {
+      resolveCanonicalGuardianRequest(requestId, "pending", {
+        status: resolvedState,
+      });
+    } catch {
+      // Canonical request tracking should not break the primary approval flow.
+    }
+
     // Cascade to other pending confirmations that match this decision
     this.cascadePendingApprovals(requestId, decision, selectedPattern);
   }
@@ -648,10 +685,11 @@ export class Conversation {
       // Consume from pending-interactions tracker
       pendingInteractions.resolve(candidateId);
 
-      // Resolve via handleConfirmationResponse which emits events.
-      // Use simple "allow"/"deny" so the permission-checker won't save
-      // duplicate rules or re-activate temporary modes. Recursion
-      // terminates because allow/deny exit cascadePendingApprovals early.
+      // Resolve via handleConfirmationResponse which emits events and
+      // syncs canonical status. Use simple "allow"/"deny" so the
+      // permission-checker won't save duplicate rules or re-activate
+      // temporary modes. Recursion terminates because allow/deny exit
+      // cascadePendingApprovals early.
       this.handleConfirmationResponse(
         candidateId,
         cascadeResult.allow ? "allow" : "deny",
@@ -663,17 +701,6 @@ export class Conversation {
           causedByRequestId: primaryRequestId,
         },
       );
-
-      // Sync the canonical guardian request status for the cascaded request.
-      // Best-effort: canonical request tracking should not break the cascade flow.
-      try {
-        const targetStatus = cascadeResult.allow ? "approved" : "denied";
-        resolveCanonicalGuardianRequest(candidateId, "pending", {
-          status: targetStatus,
-        });
-      } catch {
-        // Ignore — canonical request tracking is best-effort
-      }
     }
   }
 
@@ -880,11 +907,6 @@ export class Conversation {
     if (!this.processing) {
       await this.ensureActorScopedHistory();
     }
-    // One-way flag: once an attachment arrives, asset tools stay available
-    // for the remainder of the conversation.
-    if (!this.hasAttachments && attachments.length > 0) {
-      this.hasAttachments = true;
-    }
     return persistUserMessageImpl(
       this,
       content,

package/src/daemon/first-greeting.ts

@@ -0,0 +1,35 @@
+import { existsSync } from "node:fs";
+
+import { getWorkspacePromptPath } from "../util/platform.js";
+
+/**
+ * The canned assistant response for the wake-up greeting on a fresh workspace.
+ * Warm, non-presumptuous greeting that communicates "I'm new," "I improve over
+ * time," "I'm ready to be useful," and "you're in control."
+ */
+export const CANNED_FIRST_GREETING =
+  "Hey. I'm brand new, no name, no memories, nothing yet. The more we work together, the more context and memory I build, and the better I get. But let's not wait around. Throw a question at me, give me a task, or ask what I can do.";
+
+/**
+ * Returns `true` when all of the following are true:
+ * - `conversationMessageCount === 0` (no prior messages in this conversation)
+ * - BOOTSTRAP.md exists at the workspace prompt path
+ * - The trimmed content matches the macOS wake-up greeting (case-insensitive)
+ */
+export function isWakeUpGreeting(
+  content: string,
+  conversationMessageCount: number,
+): boolean {
+  if (conversationMessageCount !== 0) return false;
+  if (!existsSync(getWorkspacePromptPath("BOOTSTRAP.md"))) return false;
+  return content.trim().toLowerCase() === "wake up, my friend.";
+}
+
+/**
+ * Returns the canned first-greeting string. Simple getter that exists to keep
+ * the call site consistent and allow future flexibility (e.g., locale-aware
+ * greetings) without changing the API.
+ */
+export function getCannedFirstGreeting(): string {
+  return CANNED_FIRST_GREETING;
+}

package/src/daemon/handlers/config-embeddings.ts

@@ -0,0 +1,148 @@
+import {
+  getConfig,
+  loadRawConfig,
+  saveRawConfig,
+} from "../../config/loader.js";
+import { setMemoryEmbeddingField } from "../../config/raw-config-utils.js";
+import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
+import {
+  clearEmbeddingBackendCache,
+  getMemoryBackendStatus,
+} from "../../memory/embedding-backend.js";
+import type { ModelSetContext } from "./config-model.js";
+import { CONFIG_RELOAD_DEBOUNCE_MS, log } from "./shared.js";
+
+// ---------------------------------------------------------------------------
+// Embedding provider catalog
+// ---------------------------------------------------------------------------
+
+const EMBEDDING_PROVIDER_CATALOG = [
+  {
+    id: "auto",
+    displayName: "Auto (Best Available)",
+    defaultModel: "",
+    requiresKey: false,
+  },
+  {
+    id: "local",
+    displayName: "Local (In-Process)",
+    defaultModel: "Xenova/bge-small-en-v1.5",
+    requiresKey: false,
+  },
+  {
+    id: "openai",
+    displayName: "OpenAI",
+    defaultModel: "text-embedding-3-small",
+    requiresKey: true,
+  },
+  {
+    id: "gemini",
+    displayName: "Gemini",
+    defaultModel: "gemini-embedding-2-preview",
+    requiresKey: true,
+  },
+  {
+    id: "ollama",
+    displayName: "Ollama",
+    defaultModel: "nomic-embed-text",
+    requiresKey: false,
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Provider-specific model field names
+// ---------------------------------------------------------------------------
+
+const PROVIDER_MODEL_FIELD: Record<string, string> = {
+  local: "localModel",
+  openai: "openaiModel",
+  gemini: "geminiModel",
+  ollama: "ollamaModel",
+};
+
+// ---------------------------------------------------------------------------
+// GET — return current embedding config + resolved status
+// ---------------------------------------------------------------------------
+
+export async function getEmbeddingConfigInfo(): Promise<{
+  provider: string;
+  model: string | null;
+  activeProvider: string | null;
+  activeModel: string | null;
+  availableProviders: typeof EMBEDDING_PROVIDER_CATALOG;
+  status: { enabled: boolean; degraded: boolean; reason: string | null };
+}> {
+  const config = getConfig();
+  const embeddingConfig = config.memory.embeddings;
+  const backendStatus = await getMemoryBackendStatus(config);
+
+  // Derive the provider-specific model from config
+  const fieldName = PROVIDER_MODEL_FIELD[embeddingConfig.provider];
+  const model = fieldName
+    ? (embeddingConfig as Record<string, unknown>)[fieldName]
+    : null;
+
+  return {
+    provider: embeddingConfig.provider,
+    model: typeof model === "string" ? model : null,
+    activeProvider: backendStatus.provider,
+    activeModel: backendStatus.model,
+    availableProviders: EMBEDDING_PROVIDER_CATALOG,
+    status: {
+      enabled: backendStatus.enabled,
+      degraded: backendStatus.degraded,
+      reason: backendStatus.reason,
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// PUT — persist embedding provider/model to config
+// ---------------------------------------------------------------------------
+
+export async function setEmbeddingConfig(
+  provider: string,
+  model: string | undefined,
+  ctx: ModelSetContext,
+): Promise<ReturnType<typeof getEmbeddingConfigInfo>> {
+  const validProviders = new Set<string>(VALID_MEMORY_EMBEDDING_PROVIDERS);
+  if (!validProviders.has(provider)) {
+    throw new Error(
+      `Invalid embedding provider "${provider}". Valid providers: ${[...validProviders].join(", ")}`,
+    );
+  }
+
+  const raw = loadRawConfig();
+  setMemoryEmbeddingField(raw, "provider", provider);
+
+  if (model !== undefined) {
+    const fieldName = PROVIDER_MODEL_FIELD[provider];
+    if (fieldName) {
+      setMemoryEmbeddingField(raw, fieldName, model);
+    }
+  }
+
+  // Suppress the file watcher callback — we handle the reload ourselves.
+  const wasSuppressed = ctx.suppressConfigReload;
+  ctx.setSuppressConfigReload(true);
+  try {
+    saveRawConfig(raw);
+  } catch (err) {
+    ctx.setSuppressConfigReload(wasSuppressed);
+    throw err;
+  }
+  ctx.debounceTimers.schedule(
+    "__suppress_reset__",
+    () => {
+      ctx.setSuppressConfigReload(false);
+    },
+    CONFIG_RELOAD_DEBOUNCE_MS,
+  );
+
+  clearEmbeddingBackendCache();
+  ctx.updateConfigFingerprint();
+
+  log.info({ provider, model }, "Embedding config updated");
+
+  return getEmbeddingConfigInfo();
+}