@vellumai/assistant 0.5.1 → 0.5.3

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

@@ -0,0 +1,156 @@
+import {
+  getConfig,
+  loadRawConfig,
+  saveRawConfig,
+} from "../../config/loader.js";
+import {
+  deleteMemoryEmbeddingField,
+  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) {
+      if (model === "") {
+        // Empty string means "clear override — use schema default"
+        deleteMemoryEmbeddingField(raw, fieldName);
+      } else {
+        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();
+}

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

@@ -4,12 +4,18 @@ import {
   saveRawConfig,
 } from "../../config/loader.js";
 import { setServiceField } from "../../config/raw-config-utils.js";
+import { VALID_INFERENCE_PROVIDERS } from "../../config/schemas/services.js";
+import type { ProviderCatalogEntry } from "../../providers/model-catalog.js";
+import {
+  isModelInCatalog,
+  PROVIDER_CATALOG,
+} from "../../providers/model-catalog.js";
+import { getProviderDefaultModel } from "../../providers/model-intents.js";
 import {
   getConfiguredProviders,
   isProviderAvailable,
 } from "../../providers/provider-availability.js";
 import { initializeProviders } from "../../providers/registry.js";
-import { MODEL_TO_PROVIDER } from "../conversation-slash.js";
 import type {
   ImageGenModelSetRequest,
   ModelSetRequest,
@@ -20,6 +26,13 @@ import {
   log,
 } from "./shared.js";
 
+/** Reverse lookup: model ID → provider, derived from PROVIDER_CATALOG. */
+export const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
+  PROVIDER_CATALOG.flatMap((provider) =>
+    provider.models.map(({ id }) => [id, provider.id]),
+  ),
+);
+
 // ---------------------------------------------------------------------------
 // Shared business logic (transport-agnostic)
 // ---------------------------------------------------------------------------
@@ -28,15 +41,21 @@ export interface ModelInfo {
   model: string;
   provider: string;
   configuredProviders?: string[];
+  availableModels?: Array<{ id: string; displayName: string }>;
+  allProviders?: ProviderCatalogEntry[];
 }
 
 /** Return current model configuration. */
 export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
+  const provider = config.services.inference.provider;
+
   return {
     model: config.services.inference.model,
-    provider: config.services.inference.provider,
+    provider,
     configuredProviders: await getConfiguredProviders(),
+    availableModels: PROVIDER_CATALOG.find((p) => p.id === provider)?.models,
+    allProviders: PROVIDER_CATALOG,
   };
 }
 
@@ -58,28 +77,52 @@ export interface ModelSetContext {
 /**
  * Set the active model. Returns the resulting ModelInfo, or throws on failure.
  * The caller is responsible for sending the response to the client.
+ *
+ * When `explicitProvider` is supplied, it takes precedence over automatic
+ * provider inference from the model ID. If the provider changes and the
+ * current model doesn't belong to the new provider's catalog, the model
+ * is auto-reset to the provider's default.
  */
 export async function setModel(
   modelId: string,
   ctx: ModelSetContext,
+  explicitProvider?: string,
 ): Promise<ModelInfo> {
-  // If the requested model is already the current model AND the provider
-  // is already aligned with what MODEL_TO_PROVIDER expects, skip expensive
-  // reinitialization but still return model_info so the client confirms.
-  {
-    const current = getConfig();
-    const expectedProvider = MODEL_TO_PROVIDER[modelId];
-    const providerAligned =
-      !expectedProvider ||
-      current.services.inference.provider === expectedProvider;
-    if (modelId === current.services.inference.model && providerAligned) {
-      return await getModelInfo();
-    }
+  const validProviders = new Set<string>(VALID_INFERENCE_PROVIDERS);
+
+  // Validate explicit provider against allowlist
+  if (explicitProvider && !validProviders.has(explicitProvider)) {
+    throw new Error(
+      `Invalid provider "${explicitProvider}". Valid providers: ${[...validProviders].join(", ")}`,
+    );
+  }
+
+  // Resolve provider: explicit > MODEL_TO_PROVIDER lookup > current
+  const current = getConfig();
+  const resolvedProvider =
+    explicitProvider ??
+    MODEL_TO_PROVIDER[modelId] ??
+    current.services.inference.provider;
+
+  // Auto-reset model when provider changes and current modelId doesn't
+  // belong to the new provider's catalog.
+  if (
+    resolvedProvider !== current.services.inference.provider &&
+    !isModelInCatalog(resolvedProvider, modelId)
+  ) {
+    modelId = getProviderDefaultModel(resolvedProvider);
+  }
+
+  // No-op guard: skip expensive reinitialization when nothing changed
+  if (
+    modelId === current.services.inference.model &&
+    resolvedProvider === current.services.inference.provider
+  ) {
+    return await getModelInfo();
   }
 
   // Validate provider availability (secure key, env var, or managed proxy) before switching
-  const provider = MODEL_TO_PROVIDER[modelId];
-  if (provider && !(await isProviderAvailable(provider))) {
+  if (!(await isProviderAvailable(resolvedProvider))) {
     // Return current model_info so the client resyncs its optimistic state
     return await getModelInfo();
   }
@@ -87,10 +130,7 @@ export async function setModel(
   // Use raw config to avoid persisting env-var API keys to disk
   const raw = loadRawConfig();
   setServiceField(raw, "inference", "model", modelId);
-  // Infer provider from model ID to keep provider and model in sync
-  if (provider) {
-    setServiceField(raw, "inference", "provider", provider);
-  }
+  setServiceField(raw, "inference", "provider", resolvedProvider);
 
   // Suppress the file watcher callback — setModel already does
   // the full reload sequence; a redundant watcher-triggered reload
@@ -128,11 +168,7 @@ export async function setModel(
 
   ctx.updateConfigFingerprint();
 
-  return {
-    model: config.services.inference.model,
-    provider: config.services.inference.provider,
-    configuredProviders: await getConfiguredProviders(),
-  };
+  return await getModelInfo();
 }
 
 /**
@@ -179,7 +215,7 @@ export async function handleModelSet(
   ctx: HandlerContext,
 ): Promise<void> {
   try {
-    const info = await setModel(msg.model, ctx);
+    const info = await setModel(msg.model, ctx, msg.provider);
     ctx.send({ type: "model_info", ...info });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);

package/src/daemon/handlers/conversations.ts

@@ -9,7 +9,6 @@ import { getConfig } from "../../config/loader.js";
 import {
   createCanonicalGuardianRequest,
   generateCanonicalRequestCode,
-  resolveCanonicalGuardianRequest,
 } from "../../memory/canonical-guardian-store.js";
 import {
   batchSetDisplayOrders,
@@ -50,27 +49,6 @@ import {
   pendingStandaloneSecrets,
 } from "./shared.js";
 
-export function syncCanonicalStatusFromConfirmationDecision(
-  requestId: string,
-  decision: ConfirmationResponse["decision"],
-): void {
-  const targetStatus =
-    decision === "deny" || decision === "always_deny"
-      ? ("denied" as const)
-      : ("approved" as const);
-
-  try {
-    resolveCanonicalGuardianRequest(requestId, "pending", {
-      status: targetStatus,
-    });
-  } catch (err) {
-    log.debug(
-      { err, requestId, targetStatus },
-      "Failed to resolve canonical request from local confirmation response",
-    );
-  }
-}
-
 export function makeEventSender(params: {
   ctx: HandlerContext;
   conversation: Conversation;
@@ -165,7 +143,6 @@ export function handleConfirmationResponse(
         undefined,
         { source: "button" },
       );
-      syncCanonicalStatusFromConfirmationDecision(msg.requestId, msg.decision);
       pendingInteractions.resolve(msg.requestId);
       return;
     }

package/src/daemon/handlers/identity.ts

@@ -1,3 +1,12 @@
+/**
+ * Returns true when the value is a template placeholder that should be treated
+ * as empty/unset. Placeholders follow the pattern `_(…)_`, e.g.
+ * `_(not yet chosen)_` or `_(not yet established)_`.
+ */
+export function isTemplatePlaceholder(value: string): boolean {
+  return value.startsWith("_(") && value.endsWith(")_");
+}
+
 export interface IdentityFields {
   name: string;
   role: string;
@@ -14,7 +23,9 @@ export function parseIdentityFields(content: string): IdentityFields {
     const lower = trimmed.toLowerCase();
     const extract = (prefix: string): string | null => {
       if (!lower.startsWith(prefix)) return null;
-      return trimmed.split(":**").pop()?.trim() ?? null;
+      const value = trimmed.split(":**").pop()?.trim() ?? null;
+      if (value && isTemplatePlaceholder(value)) return null;
+      return value;
     };
 
     const name = extract("- **name:**");

package/src/daemon/handlers/recording.ts

@@ -4,10 +4,10 @@ import * as path from "node:path";
 import { v4 as uuid } from "uuid";
 
 import {
-  linkAttachmentToMessage,
-  uploadFileBackedAttachment,
+  attachFileBackedAttachmentToMessage,
 } from "../../memory/attachments-store.js";
-import { addMessage } from "../../memory/conversation-crud.js";
+import { addMessage, getConversation } from "../../memory/conversation-crud.js";
+import { syncMessageToDisk } from "../../memory/conversation-disk-view.js";
 import type { RecordingOptions, RecordingStatus } from "../message-protocol.js";
 import { type HandlerContext, log } from "./shared.js";
 
@@ -616,23 +616,6 @@ export async function finalizeAndPublishRecording(params: {
     const ext = filename.split(".").pop()?.toLowerCase();
     const mimeType = (ext && RECORDING_MIME_TYPES.get(ext)) || "video/mp4";
 
-    // Store as file-backed attachment (avoids reading large files into memory)
-    const attachment = uploadFileBackedAttachment(
-      filename,
-      mimeType,
-      resolvedPath,
-      sizeBytes,
-    );
-    log.info(
-      {
-        recordingId,
-        attachmentId: attachment.id,
-        sizeBytes,
-        filePath: resolvedPath,
-      },
-      "Created attachment for standalone recording",
-    );
-
     // Always create a new assistant message for the recording attachment.
     // Reusing the last assistant message would attach the recording to an
     // unrelated older message after reload.
@@ -648,12 +631,34 @@ export async function finalizeAndPublishRecording(params: {
       "Created assistant message for recording attachment",
     );
 
-    linkAttachmentToMessage(messageId, attachment.id, 0);
+    const attachment = attachFileBackedAttachmentToMessage(
+      messageId,
+      0,
+      filename,
+      mimeType,
+      resolvedPath,
+      sizeBytes,
+    );
+    log.info(
+      {
+        recordingId,
+        attachmentId: attachment.id,
+        sizeBytes,
+        filePath: resolvedPath,
+      },
+      "Created attachment for standalone recording",
+    );
     log.info(
       { recordingId, messageId, attachmentId: attachment.id },
       "Linked recording attachment to assistant message",
     );
 
+    // Sync the recording message (with attachment) to the disk view
+    const convForDisk = getConversation(conversationId);
+    if (convForDisk) {
+      syncMessageToDisk(conversationId, messageId, convForDisk.createdAt);
+    }
+
     // Skip server-side thumbnail generation for recordings — the client
     // generates thumbnails natively from the local file path using
     // AVAssetImageGenerator, which is faster and doesn't depend on ffmpeg.

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

@@ -10,6 +10,7 @@
 import { v4 as uuid } from "uuid";
 
 import { escapeAxTreeContent } from "../agent/loop.js";
+import { loadConfig } from "../config/loader.js";
 import type { ContentBlock } from "../providers/types.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -23,7 +24,6 @@ const log = getLogger("host-cu-proxy");
 // ---------------------------------------------------------------------------
 
 const REQUEST_TIMEOUT_SEC = 60;
-const MAX_STEPS = 50;
 const MAX_HISTORY_ENTRIES = 10;
 const LOOP_DETECTION_WINDOW = 3;
 const CONSECUTIVE_UNCHANGED_WARNING_THRESHOLD = 2;
@@ -79,7 +79,7 @@ export class HostCuProxy {
   constructor(
     sendToClient: (msg: ServerMessage) => void,
     onInternalResolve?: (requestId: string) => void,
-    maxSteps = MAX_STEPS,
+    maxSteps = loadConfig().maxStepsPerSession,
   ) {
     this.sendToClient = sendToClient;
     this.onInternalResolve = onInternalResolve;