@vellumai/assistant 0.11.10 → 0.11.11-staging.1

package/src/config/input-modalities.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+
+import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
+
+/**
+ * Input modalities a profile can declare independently of the model catalog.
+ * Cataloged models keep today's flags; free-text / empty-catalog models use
+ * these overrides to say what the serving surface actually accepts.
+ */
+export const INPUT_MODALITIES = ["text", "image", "audio", "video"] as const;
+export type InputModality = (typeof INPUT_MODALITIES)[number];
+
+/**
+ * Per-modality policy + capability. Absent fields inherit catalog defaults
+ * (unknown models: unsupported, except text which is always supported).
+ *
+ * - `enabled`: whether this profile may use the modality.
+ * - `supported`: whether the model accepts the modality, overriding the catalog
+ *   when set.
+ */
+export const ModalityOverrideSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    supported: z.boolean().optional(),
+  })
+  .meta({ id: "ModalityOverride" });
+export type ModalityOverride = z.infer<typeof ModalityOverrideSchema>;
+
+export const InputModalitiesSchema = z
+  .object({
+    text: ModalityOverrideSchema.optional(),
+    image: ModalityOverrideSchema.optional(),
+    audio: ModalityOverrideSchema.optional(),
+    video: ModalityOverrideSchema.optional(),
+  })
+  .meta({ id: "InputModalities" });
+export type InputModalities = z.infer<typeof InputModalitiesSchema>;
+
+/**
+ * Catalog capability for a modality. Unknown models fail closed except text,
+ * which every chat profile can send.
+ */
+export function catalogSupportsModality(
+  modality: InputModality,
+  catalog: {
+    supportsVision?: boolean;
+    supportsAudioInput?: boolean;
+  } | undefined,
+): boolean {
+  if (modality === "text") {
+    return true;
+  }
+  if (modality === "image") {
+    return catalog?.supportsVision === true;
+  }
+  if (modality === "audio") {
+    return catalog?.supportsAudioInput === true;
+  }
+  return false;
+}
+
+export function catalogEntryFor(
+  provider: string,
+  model: string,
+): { supportsVision?: boolean; supportsAudioInput?: boolean } | undefined {
+  const catalogProvider = PROVIDER_CATALOG.find((p) => p.id === provider);
+  return catalogProvider?.models.find((m) => m.id === model);
+}
+
+/**
+ * Resolve whether a modality should be sent on the wire.
+ *
+ * Untouched (no override for that row) inherits `catalogSupported`, which may
+ * be `undefined` when the catalog does not know the model. An authored
+ * override is always a boolean: both `enabled` and `supported` must be true,
+ * with missing leaves defaulting to enabled=true and supported=catalog.
+ */
+export function resolveModalityOverride(
+  override: ModalityOverride | undefined,
+  catalogSupported: boolean | undefined,
+): boolean | undefined {
+  if (override == null) {
+    return catalogSupported;
+  }
+  const catalog = catalogSupported === true;
+  const enabled = override.enabled ?? true;
+  const supported = override.supported ?? catalog;
+  return enabled && supported;
+}
+
+export function modalitiesOf(
+  entry: { inputModalities?: InputModalities | null } | undefined,
+): InputModalities | undefined {
+  return entry?.inputModalities ?? undefined;
+}

package/src/config/schemas/heartbeat.ts

@@ -25,7 +25,7 @@ export const HeartbeatConfigSchema = z
       .nullable()
       .default(null)
       .describe(
-        "Timezone for cron expression evaluation, e.g. 'America/New_York'. Ignored when cronExpression is null.",
+        "Timezone for cron expression and active-hours evaluation, e.g. 'America/New_York'. When null, uses the user's configured or detected timezone, then the host clock.",
       ),
     activeHoursStart: z
       .number({ error: "heartbeat.activeHoursStart must be a number" })
@@ -35,7 +35,7 @@ export const HeartbeatConfigSchema = z
       .nullable()
       .default(8)
       .describe(
-        "Hour of the day (0-23) when heartbeat checks begin, or null to disable active hours restriction",
+        "Hour of the day (0-23) in the heartbeat timezone when heartbeat checks begin, or null to disable active hours restriction",
       ),
     activeHoursEnd: z
       .number({ error: "heartbeat.activeHoursEnd must be a number" })
@@ -45,7 +45,7 @@ export const HeartbeatConfigSchema = z
       .nullable()
       .default(22)
       .describe(
-        "Hour of the day (0-23) when heartbeat checks stop, or null to disable active hours restriction",
+        "Hour of the day (0-23) in the heartbeat timezone when heartbeat checks stop, or null to disable active hours restriction",
       ),
     maxConsecutiveRuns: z
       .number({ error: "heartbeat.maxConsecutiveRuns must be a number" })

package/src/config/schemas/llm.ts

@@ -18,6 +18,7 @@ import {
   isBackupProfileKey,
   isDefaultProfileKey,
 } from "../default-profile-names.js";
+import { InputModalitiesSchema } from "../input-modalities.js";
 
 /**
  * Unified LLM configuration schema.
@@ -640,6 +641,13 @@ export const ProfileEntry = LLMConfigFragment.extend({
    * a model the checks can vouch for never needs it.
    */
   allowUnlisted: z.boolean().optional(),
+  /**
+   * Per-profile input-modality policy and capability overrides. Absent
+   * inherits the model catalog (unknown models fail closed at send time).
+   * `.nullable()` matches `label` so edit-mode PATCH can send `null` to
+   * clear a previously stored override.
+   */
+  inputModalities: InputModalitiesSchema.nullable().optional(),
   /**
    * Absent means active. `.nullable()` matches `label` so the PUT route's
    * "send `null` to clear" sentinel works for status too — a managed
@@ -1040,13 +1048,15 @@ export const LLMSchema = z
     // --- Mix profile validation --------------------------------------------
     // Config keys a mix profile must NOT also set (a mix only references other
     // profiles + metadata). Derived from the fragment shape plus the
-    // ProfileEntry-only `provider_connection` and `fallbackProfile` (a mix
-    // carries no config of its own, so it has no route to fall back from) so
-    // it can't drift if a new config field is added to `LLMConfigFragment`.
+    // ProfileEntry-only `provider_connection`, `fallbackProfile` (a mix
+    // carries no config of its own, so it has no route to fall back from),
+    // and `inputModalities` so it can't drift if a new config field is added
+    // to `LLMConfigFragment`.
     const MIX_DISALLOWED_CONFIG_KEYS = [
       ...Object.keys(LLMConfigFragment.shape),
       "provider_connection",
       "fallbackProfile",
+      "inputModalities",
     ];
     const mixProfileNames = new Set(
       Object.entries(config.profiles ?? {})

package/src/config/schemas/memory-storage.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  MemoryEmbeddingsConfigSchema,
+  VALID_MEMORY_EMBEDDING_PROVIDERS,
+} from "./memory-storage.js";
+
+describe("MemoryEmbeddingsConfigSchema", () => {
+  test("includes custom in the provider enum", () => {
+    expect(VALID_MEMORY_EMBEDDING_PROVIDERS).toContain("custom");
+  });
+
+  test("accepts a custom OpenAI-compatible endpoint", () => {
+    const parsed = MemoryEmbeddingsConfigSchema.parse({
+      provider: "custom",
+      baseUrl: "https://gateway.example.com/v1",
+      customModel: "text-embedding-3-small",
+      customDimensions: 1536,
+    });
+    expect(parsed.provider).toBe("custom");
+    expect(parsed.baseUrl).toBe("https://gateway.example.com/v1");
+    expect(parsed.customModel).toBe("text-embedding-3-small");
+    expect(parsed.customDimensions).toBe(1536);
+  });
+
+  test("defaults customModel when it is omitted", () => {
+    const parsed = MemoryEmbeddingsConfigSchema.parse({
+      provider: "custom",
+      baseUrl: "http://127.0.0.1:4000/v1",
+    });
+    expect(parsed.customModel).toBe("text-embedding-3-small");
+  });
+
+  test("rejects an unknown provider", () => {
+    expect(() =>
+      MemoryEmbeddingsConfigSchema.parse({ provider: "portkey" }),
+    ).toThrow(/must be one of/);
+  });
+});

package/src/config/schemas/memory-storage.ts

@@ -6,6 +6,7 @@ export const VALID_MEMORY_EMBEDDING_PROVIDERS = [
   "openai",
   "gemini",
   "ollama",
+  "custom",
 ] as const;
 
 const VALID_QDRANT_QUANTIZATION = ["scalar", "none"] as const;
@@ -67,6 +68,26 @@ export const MemoryEmbeddingsConfigSchema = z
       .string({ error: "memory.embeddings.ollamaModel must be a string" })
       .default("nomic-embed-text")
       .describe("Model name for the Ollama embedding provider"),
+    customModel: z
+      .string({ error: "memory.embeddings.customModel must be a string" })
+      .default("text-embedding-3-small")
+      .describe(
+        "Model name for a custom OpenAI-compatible embeddings endpoint",
+      ),
+    baseUrl: z
+      .string({ error: "memory.embeddings.baseUrl must be a string" })
+      .optional()
+      .describe(
+        "Base URL of a custom OpenAI-compatible embeddings endpoint, including the /v1 prefix (for example https://gateway.example.com/v1). Required when provider is 'custom'.",
+      ),
+    customDimensions: z
+      .number({ error: "memory.embeddings.customDimensions must be a number" })
+      .int("memory.embeddings.customDimensions must be an integer")
+      .positive("memory.embeddings.customDimensions must be a positive integer")
+      .optional()
+      .describe(
+        "Output dimensionality requested from a custom embeddings endpoint when the model supports it",
+      ),
   })
   .describe("Embedding generation configuration for semantic memory search");
 

package/src/context/token-estimator.ts

@@ -2,8 +2,8 @@ import {
   estimateGeminiAudioTokens,
   normalizeGeminiAudioMime,
 } from "../providers/gemini/inline-media.js";
+import { requestSupportsInlineAudio } from "../providers/inline-audio-support.js";
 import { mediaSourceByteLength } from "../providers/media-resolve.js";
-import { modelSupportsAudioInput } from "../providers/model-catalog.js";
 import {
   estimateOpenAICompatAudioTokens,
   isOpenAICompatInlineAudio,
@@ -159,7 +159,7 @@ function estimateFileDataTokens(
   // receive eligible audio inline as `input_audio` parts, billed by duration.
   if (
     options?.model !== undefined &&
-    modelSupportsAudioInput(options.model) &&
+    requestSupportsInlineAudio(options.model) &&
     isOpenAICompatInlineAudio(block.source.media_type, byteLength)
   ) {
     return estimateOpenAICompatAudioTokens(byteLength);

package/src/daemon/__tests__/embedding-reconcile.test.ts

@@ -97,6 +97,9 @@ function makeDeps(opts: {
     recreateCollectionsAtDim: mock(async () => {}),
     ensureCollections: mock(async () => {}),
     enqueueReembed: mock(() => {}),
+    customEmbeddingSpaceIdentity: mock(() => null),
+    readCustomEmbeddingSpace: mock(() => null),
+    writeCustomEmbeddingSpace: mock(() => {}),
   };
 }
 
@@ -289,6 +292,77 @@ describe("reconcileEmbeddingIdentity", () => {
     expect(deps.enqueueReembed).toHaveBeenCalledTimes(0);
   });
 
+  test("noop records a first-seen custom endpoint without re-embedding", async () => {
+    const deps = makeDeps({
+      decision: { kind: "noop" },
+      committedDim: 1536,
+      probeDim: 1536,
+    });
+    deps.customEmbeddingSpaceIdentity = mock(
+      () => "custom\0text-embedding-3-small\0url=http://127.0.0.1:4000/v1",
+    );
+
+    const outcome = await reconcileEmbeddingIdentity(
+      fakeConfig("custom"),
+      deps,
+    );
+
+    expect(outcome).toEqual({ action: "noop", dim: 1536 });
+    expect(deps.enqueueReembed).toHaveBeenCalledTimes(0);
+    expect(deps.writeCustomEmbeddingSpace).toHaveBeenCalledWith(
+      "custom\0text-embedding-3-small\0url=http://127.0.0.1:4000/v1",
+    );
+    expect(deps.recreateCollectionsAtDim).toHaveBeenCalledTimes(0);
+  });
+
+  test("noop reembeds when the custom endpoint changes at the same dimension", async () => {
+    const deps = makeDeps({
+      decision: { kind: "noop" },
+      committedDim: 1536,
+      probeDim: 1536,
+    });
+    deps.customEmbeddingSpaceIdentity = mock(
+      () => "custom\0text-embedding-3-small\0url=http://127.0.0.1:4001/v1",
+    );
+    deps.readCustomEmbeddingSpace = mock(
+      () => "custom\0text-embedding-3-small\0url=http://127.0.0.1:4000/v1",
+    );
+
+    const outcome = await reconcileEmbeddingIdentity(
+      fakeConfig("custom"),
+      deps,
+    );
+
+    expect(outcome).toEqual({ action: "reembed-space", dim: 1536 });
+    expect(deps.enqueueReembed).toHaveBeenCalledTimes(1);
+    expect(deps.writeCustomEmbeddingSpace).toHaveBeenCalledWith(
+      "custom\0text-embedding-3-small\0url=http://127.0.0.1:4001/v1",
+    );
+    expect(deps.recreateCollectionsAtDim).toHaveBeenCalledTimes(0);
+    expect(deps.persistVectorSize).toHaveBeenCalledTimes(0);
+  });
+
+  test("noop does not reembed when the custom endpoint is unchanged", async () => {
+    const identity =
+      "custom\0text-embedding-3-small\0url=http://127.0.0.1:4000/v1";
+    const deps = makeDeps({
+      decision: { kind: "noop" },
+      committedDim: 1536,
+      probeDim: 1536,
+    });
+    deps.customEmbeddingSpaceIdentity = mock(() => identity);
+    deps.readCustomEmbeddingSpace = mock(() => identity);
+
+    const outcome = await reconcileEmbeddingIdentity(
+      fakeConfig("custom"),
+      deps,
+    );
+
+    expect(outcome).toEqual({ action: "noop", dim: 1536 });
+    expect(deps.enqueueReembed).toHaveBeenCalledTimes(0);
+    expect(deps.writeCustomEmbeddingSpace).toHaveBeenCalledTimes(0);
+  });
+
   test("passes committed + probe dims and configured provider into the decision", async () => {
     const deps = makeDeps({
       decision: { kind: "noop" },
@@ -409,6 +483,9 @@ function driveBranch(
     })),
     readConceptPageCollectionDim: mock(async () => committedDim),
     decideEmbeddingReconcile: mock(() => decision),
+    customEmbeddingSpaceIdentity: mock(() => null),
+    readCustomEmbeddingSpace: mock(() => null),
+    writeCustomEmbeddingSpace: mock(() => {}),
   };
 }
 

package/src/daemon/__tests__/lifecycle-embedding-reconcile.test.ts

@@ -56,6 +56,9 @@ function throwingDeps(): ReconcileDeps {
     }),
     ensureCollections: mock(async () => {}),
     enqueueReembed: mock(() => {}),
+    customEmbeddingSpaceIdentity: mock(() => null),
+    readCustomEmbeddingSpace: mock(() => null),
+    writeCustomEmbeddingSpace: mock(() => {}),
   };
 }
 

package/src/daemon/conversation-error.ts

@@ -27,6 +27,7 @@ import {
 import {
   INSUFFICIENT_CREDITS_PATTERNS,
   isChatTemplateFailureError,
+  isModelNotFoundError,
   isVisionNotSupportedError,
 } from "../util/provider-error-patterns.js";
 
@@ -429,6 +430,11 @@ function classifyCore(
       return contextTooLargeClassification();
     }
     if (error.statusCode === 401 || error.statusCode === 403) {
+      // OpenCode (and similar OpenAI-compat endpoints) return 401 for an
+      // unknown model id. That must not read as a rejected key.
+      if (isModelNotFoundError(message)) {
+        return modelNotFoundClassification();
+      }
       // Managed routes through the assistant API key; if that credential is
       // stale, the user cannot fix it from model settings. Everything else is
       // a credential the user owns, so the copy names which one to update and
@@ -675,13 +681,7 @@ function reasonToClassification(
         errorCategory: "provider_network_error",
       };
     case "model_not_found":
-      return {
-        code: "PROVIDER_API",
-        userMessage:
-          "The selected model wasn't found by the provider. Switch models in Settings → Models & Services.",
-        retryable: false,
-        errorCategory: "provider_model_not_found",
-      };
+      return modelNotFoundClassification();
     case "model_restricted": {
       const detail = extractProviderDetail(args.message);
       const prefix = "This model isn't available on your current provider plan";
@@ -890,6 +890,19 @@ function providerServerErrorClassification(): Omit<
   };
 }
 
+function modelNotFoundClassification(): Omit<
+  ClassifiedConversationError,
+  "debugDetails"
+> {
+  return {
+    code: "PROVIDER_API",
+    userMessage:
+      "The selected model wasn't found by the provider. Switch models in Settings → Models & Services.",
+    retryable: false,
+    errorCategory: "provider_model_not_found",
+  };
+}
+
 function contextTooLargeClassification(): Omit<
   ClassifiedConversationError,
   "debugDetails"

package/src/daemon/embedding-reconcile.ts

@@ -25,6 +25,15 @@ import {
   isMemoryV3Live,
 } from "../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../config/types.js";
+import {
+  deleteMemoryCheckpoint,
+  getMemoryCheckpoint,
+  setMemoryCheckpoint,
+} from "../persistence/checkpoints.js";
+import {
+  CUSTOM_EMBEDDING_SPACE_CHECKPOINT,
+  customEmbeddingSpaceIdentity,
+} from "../persistence/embeddings/embedding-backend.js";
 import {
   probeBackendDimension,
   readConceptPageCollectionDim,
@@ -50,6 +59,7 @@ export type ReconcileOutcome =
   | { action: "noop"; dim: number | null }
   | { action: "commit-fresh"; dim: number }
   | { action: "migrate"; fromDim: number; toDim: number }
+  | { action: "reembed-space"; dim: number }
   | { action: "defer-degraded"; reason: string };
 
 /**
@@ -72,6 +82,12 @@ export interface ReconcileDeps {
   ensureCollections: (dim: number) => Promise<void>;
   /** Enqueue the reembed jobs that repopulate the (re)created collections. */
   enqueueReembed: () => void;
+  /** Identity of the configured custom embeddings endpoint, or null. */
+  customEmbeddingSpaceIdentity: (config: AssistantConfig) => string | null;
+  /** Last custom embedding space recorded for the populated collections. */
+  readCustomEmbeddingSpace: () => string | null;
+  /** Persist (or clear) the custom embedding space identity. */
+  writeCustomEmbeddingSpace: (identity: string | null) => void;
 }
 
 /**
@@ -201,9 +217,38 @@ export function defaultDeps(config: AssistantConfig): ReconcileDeps {
       }
     },
     enqueueReembed: () => defaultEnqueueReembed(config),
+    customEmbeddingSpaceIdentity,
+    readCustomEmbeddingSpace: () =>
+      getMemoryCheckpoint(CUSTOM_EMBEDDING_SPACE_CHECKPOINT),
+    writeCustomEmbeddingSpace: (identity) => {
+      if (identity == null) {
+        deleteMemoryCheckpoint(CUSTOM_EMBEDDING_SPACE_CHECKPOINT);
+      } else {
+        setMemoryCheckpoint(CUSTOM_EMBEDDING_SPACE_CHECKPOINT, identity);
+      }
+    },
   };
 }
 
+function syncCustomEmbeddingSpace(
+  config: AssistantConfig,
+  deps: ReconcileDeps,
+  opts: { reembedOnChange: boolean },
+): "unchanged" | "recorded" | "reembed" {
+  const current = deps.customEmbeddingSpaceIdentity(config);
+  const stored = deps.readCustomEmbeddingSpace();
+  if (current === stored) {
+    return "unchanged";
+  }
+  if (opts.reembedOnChange && current != null && stored != null) {
+    deps.enqueueReembed();
+    deps.writeCustomEmbeddingSpace(current);
+    return "reembed";
+  }
+  deps.writeCustomEmbeddingSpace(current);
+  return "recorded";
+}
+
 /**
  * Reconcile the committed Qdrant collection dimension against a live probe of
  * the configured embedding backend, then execute the resulting action:
@@ -211,12 +256,18 @@ export function defaultDeps(config: AssistantConfig): ReconcileDeps {
  *  - `noop` — committed dimension already matches (or auto-mode declines to
  *    thrash); no writes, no destructive calls. Also returned immediately when
  *    `memory.enabled === false`, before any probe/read/persist/enqueue.
+ *    When the custom embeddings endpoint identity changed at the same
+ *    dimension, this becomes `reembed-space` instead: enqueue a reembed
+ *    without recreating collections.
  *  - `commit-fresh` — fresh install adopts the reachable backend's dimension:
  *    commit the dim, ensure the collections EXIST at it (create-if-absent, never
  *    destroy), and enqueue a reembed.
  *  - `migrate` — deliberate provider intent with a confirmed probe: commit the
  *    new dim, then destroy + recreate the collections (the only destructive
  *    path) and enqueue a reembed.
+ *  - `reembed-space`: committed dimension already matches, but the custom
+ *    embeddings endpoint (base URL / model / requested dimensions) changed.
+ *    Enqueue a reembed so query and document vectors stay in one space.
  *  - `defer-degraded` — backend unreachable, OR the committed dimension could
  *    not be read (Qdrant unreachable / existing collection unreadable): no
  *    write, no destructive call; warn and leave the collections untouched.
@@ -284,14 +335,25 @@ export async function reconcileEmbeddingIdentity(
   });
 
   switch (action.kind) {
-    case "noop":
+    case "noop": {
+      const spaceOutcome = syncCustomEmbeddingSpace(config, deps, {
+        reembedOnChange: true,
+      });
+      if (spaceOutcome === "reembed" && committedDim != null) {
+        log.info(
+          "Custom embedding endpoint changed at the committed dimension; enqueued reembed",
+        );
+        return { action: "reembed-space", dim: committedDim };
+      }
       return { action: "noop", dim: committedDim };
+    }
 
     case "commit-fresh": {
       deps.setInMemoryVectorSize(action.dim);
       deps.persistVectorSize(action.dim);
       await deps.ensureCollections(action.dim);
       deps.enqueueReembed();
+      syncCustomEmbeddingSpace(config, deps, { reembedOnChange: false });
       log.info(
         { dim: action.dim },
         "Committed fresh embedding dimension and ensured collections",
@@ -324,6 +386,7 @@ export async function reconcileEmbeddingIdentity(
         throw err;
       }
       deps.enqueueReembed();
+      syncCustomEmbeddingSpace(config, deps, { reembedOnChange: false });
       log.warn(
         { fromDim: action.fromDim, toDim: action.toDim },
         "Migrated embedding dimension: recreated collections and enqueued reembed",

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

@@ -50,6 +50,12 @@ const EMBEDDING_PROVIDER_CATALOG = [
     defaultModel: "nomic-embed-text",
     requiresKey: false,
   },
+  {
+    id: "custom",
+    displayName: "Custom (OpenAI-compatible)",
+    defaultModel: "text-embedding-3-small",
+    requiresKey: false,
+  },
 ];
 
 // ---------------------------------------------------------------------------
@@ -61,6 +67,7 @@ const PROVIDER_MODEL_FIELD: Record<string, string> = {
   openai: "openaiModel",
   gemini: "geminiModel",
   ollama: "ollamaModel",
+  custom: "customModel",
 };
 
 // ---------------------------------------------------------------------------
@@ -70,6 +77,8 @@ const PROVIDER_MODEL_FIELD: Record<string, string> = {
 export async function getEmbeddingConfigInfo(): Promise<{
   provider: string;
   model: string | null;
+  baseUrl: string | null;
+  dimensions: number | null;
   activeProvider: string | null;
   activeModel: string | null;
   availableProviders: typeof EMBEDDING_PROVIDER_CATALOG;
@@ -88,6 +97,8 @@ export async function getEmbeddingConfigInfo(): Promise<{
   return {
     provider: embeddingConfig.provider,
     model: typeof model === "string" ? model : null,
+    baseUrl: embeddingConfig.baseUrl ?? null,
+    dimensions: embeddingConfig.customDimensions ?? null,
     activeProvider: backendStatus.provider,
     activeModel: backendStatus.model,
     availableProviders: EMBEDDING_PROVIDER_CATALOG,
@@ -107,6 +118,10 @@ export async function setEmbeddingConfig(
   provider: string,
   model: string | undefined,
   ctx: ModelSetContext,
+  extras?: {
+    baseUrl?: string;
+    dimensions?: number | null;
+  },
 ): Promise<ReturnType<typeof getEmbeddingConfigInfo>> {
   const validProviders = new Set<string>(VALID_MEMORY_EMBEDDING_PROVIDERS);
   if (!validProviders.has(provider)) {
@@ -130,6 +145,22 @@ export async function setEmbeddingConfig(
     }
   }
 
+  if (extras?.baseUrl !== undefined) {
+    if (extras.baseUrl === "") {
+      deleteMemoryEmbeddingField(raw, "baseUrl");
+    } else {
+      setMemoryEmbeddingField(raw, "baseUrl", extras.baseUrl);
+    }
+  }
+
+  if (extras?.dimensions !== undefined) {
+    if (extras.dimensions === null) {
+      deleteMemoryEmbeddingField(raw, "customDimensions");
+    } else {
+      setMemoryEmbeddingField(raw, "customDimensions", extras.dimensions);
+    }
+  }
+
   // Suppress the file watcher callback — we handle the reload ourselves.
   const wasSuppressed = ctx.suppressConfigReload;
   ctx.setSuppressConfigReload(true);

package/src/daemon/host-app-control-proxy.ts

@@ -398,6 +398,8 @@ export class HostAppControlProxy extends HostProxyBase<
         signal,
         undefined,
         resolvedTargetClientId,
+        undefined,
+        sourceActorPrincipalId,
       );
       if (input.tool === "start") {
         if (payload.state === "running") {

package/src/daemon/host-bash-proxy.ts

@@ -152,6 +152,7 @@ export class HostBashProxy extends HostProxyBase<
         extraFields,
         resolvedTargetClientId,
         proxyTimeoutMs,
+        sourceActorPrincipalId,
       );
       return formatShellOutput(
         payload.stdout,

package/src/daemon/host-cu-proxy.ts

@@ -23,6 +23,7 @@ import {
   assistantEventHub,
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
+import { snapshotHostProxyActorPrincipalId } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { POINT_AT_PROXY_TOOL } from "../tools/computer-use/skill-proxy-bridge.js";
 import type { ToolExecutionResult } from "../tools/types.js";
@@ -356,12 +357,11 @@ export class HostCuProxy {
         conversationId,
         kind: "host_cu",
         targetClientId: resolvedTargetClientId,
-        targetActorPrincipalId:
-          resolvedTargetClientId != null
-            ? assistantEventHub.getActorPrincipalIdForClient(
-                resolvedTargetClientId,
-              )
-            : undefined,
+        targetActorPrincipalId: snapshotHostProxyActorPrincipalId({
+          hub: assistantEventHub,
+          targetClientId: resolvedTargetClientId,
+          sourceActorPrincipalId,
+        }),
         rpcResolve: resolve as (v: unknown) => void,
         rpcReject: reject,
         timer,