@vellumai/assistant 0.4.51 → 0.4.53

package/src/config/schema.ts

@@ -232,12 +232,6 @@ export const AssistantConfigSchema = z
     imageGenModel: z
       .string({ error: "imageGenModel must be a string" })
       .default("gemini-2.5-flash-image"),
-    apiKeys: z
-      .record(
-        z.string(),
-        z.string({ error: "Each apiKeys value must be a string" }),
-      )
-      .default({} as Record<string, string>),
     webSearchProvider: z
       .enum(VALID_WEB_SEARCH_PROVIDERS, {
         error: `webSearchProvider must be one of: ${VALID_WEB_SEARCH_PROVIDERS.join(

package/src/config/schemas/channels.ts

@@ -34,6 +34,7 @@ export const WhatsAppConfigSchema = z.object({
 });
 
 export const TelegramConfigSchema = z.object({
+  botId: z.string({ error: "telegram.botId must be a string" }).default(""),
   botUsername: z
     .string({ error: "telegram.botUsername must be a string" })
     .default(""),

package/src/config/schemas/elevenlabs.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
 
-// Default ElevenLabs voice — "Rachel" (calm, warm, conversational).
+// Default ElevenLabs voice — "Amelia" (expressive, enthusiastic, British English).
 // Used by both in-app TTS and phone calls (via Twilio ConversationRelay).
 // Mirrored in: clients/macos/.../OpenAIVoiceService.swift (defaultVoiceId)
-export const DEFAULT_ELEVENLABS_VOICE_ID = "21m00Tcm4TlvDq8ikWAM";
+export const DEFAULT_ELEVENLABS_VOICE_ID = "ZF6FPAbjXT4488VcRRnw";
 
 export const ElevenLabsConfigSchema = z.object({
   voiceId: z

package/src/contacts/contact-store.ts

@@ -34,8 +34,8 @@ function parseContact(row: typeof contacts.$inferSelect): Contact {
     id: row.id,
     displayName: row.displayName,
     notes: row.notes,
-    lastInteraction: row.lastInteraction,
-    interactionCount: row.interactionCount,
+    lastInteraction: null,
+    interactionCount: 0,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
     role: row.role as Contact["role"],
@@ -63,6 +63,8 @@ function parseChannel(
     revokedReason: row.revokedReason,
     blockedReason: row.blockedReason,
     lastSeenAt: row.lastSeenAt,
+    interactionCount: row.interactionCount,
+    lastInteraction: row.lastInteraction,
     updatedAt: row.updatedAt,
     createdAt: row.createdAt,
   };
@@ -80,7 +82,15 @@ function getChannelsForContact(contactId: string): ContactChannel[] {
 }
 
 function withChannels(contact: Contact): ContactWithChannels {
-  return { ...contact, channels: getChannelsForContact(contact.id) };
+  const channels = getChannelsForContact(contact.id);
+  const interactionCount = channels.reduce(
+    (sum, ch) => sum + ch.interactionCount,
+    0,
+  );
+  const lastInteraction =
+    channels.reduce((max, ch) => Math.max(max, ch.lastInteraction ?? 0), 0) ||
+    null;
+  return { ...contact, interactionCount, lastInteraction, channels };
 }
 
 // ── Channel data type for syncChannels ───────────────────────────────
@@ -235,8 +245,6 @@ export function upsertContact(params: {
       id: contactId,
       displayName: params.displayName,
       notes: params.notes ?? null,
-      lastInteraction: null,
-      interactionCount: 0,
       role: params.role ?? "contact",
       contactType: params.contactType ?? "human",
       principalId: params.principalId ?? null,
@@ -488,7 +496,7 @@ export function searchContacts(params: {
       .from(contacts)
       .innerJoin(contactChannels, eq(contacts.id, contactChannels.contactId))
       .where(whereClause)
-      .orderBy(desc(contacts.updatedAt), desc(contacts.lastInteraction))
+      .orderBy(desc(contacts.updatedAt))
       .all();
 
     const contactIds = [...new Set(rows.map((r) => r.contactId))];
@@ -509,7 +517,7 @@ export function searchContacts(params: {
     .select()
     .from(contacts)
     .where(whereClause)
-    .orderBy(desc(contacts.updatedAt), desc(contacts.lastInteraction))
+    .orderBy(desc(contacts.updatedAt))
     .limit(limit)
     .all();
 
@@ -531,11 +539,7 @@ export function listContacts(
     .select()
     .from(contacts)
     .where(conditions.length === 1 ? conditions[0] : and(...conditions))
-    .orderBy(
-      sql`${contacts.role} = 'guardian' DESC`,
-      desc(contacts.updatedAt),
-      desc(contacts.lastInteraction),
-    )
+    .orderBy(sql`${contacts.role} = 'guardian' DESC`, desc(contacts.updatedAt))
     .limit(effectiveLimit)
     .all();
   return rows.map((r) => withChannels(parseContact(r)));
@@ -571,16 +575,8 @@ export function mergeContacts(
       .get();
     if (!merge) throw new Error(`Contact "${mergeId}" not found`);
 
-    // Resolve merged field values — pick the better/more recent value
-    const mergedInteractionCount =
-      keep.interactionCount + merge.interactionCount;
-    const mergedLastInteraction =
-      Math.max(keep.lastInteraction ?? 0, merge.lastInteraction ?? 0) || null;
-
     tx.update(contacts)
       .set({
-        interactionCount: mergedInteractionCount,
-        lastInteraction: mergedLastInteraction,
         notes: [keep.notes, merge.notes].filter(Boolean).join("\n") || null,
         updatedAt: now,
       })
@@ -934,19 +930,19 @@ export function updateChannelLastSeenById(channelId: string): void {
 }
 
 /**
- * Atomically increment interactionCount and set lastInteraction on a contact.
+ * Atomically increment interactionCount and set lastInteraction on a contact channel.
  * Optimized for the hot path — single UPDATE with no prior SELECT.
  */
-export function updateContactInteraction(contactId: string): void {
+export function updateChannelInteraction(channelId: string): void {
   const db = getDb();
   const now = Date.now();
-  db.update(contacts)
+  db.update(contactChannels)
     .set({
       lastInteraction: now,
-      interactionCount: sql`${contacts.interactionCount} + 1`,
+      interactionCount: sql`${contactChannels.interactionCount} + 1`,
       updatedAt: now,
     })
-    .where(eq(contacts.id, contactId))
+    .where(eq(contactChannels.id, channelId))
     .run();
 }
 

package/src/contacts/contacts-write.ts

@@ -16,9 +16,9 @@ import {
   findGuardianForChannel,
   getChannelById,
   getContactInternal,
+  updateChannelInteraction,
   updateChannelLastSeenById,
   updateChannelStatus,
-  updateContactInteraction,
   upsertContact,
 } from "./contact-store.js";
 import type {
@@ -287,13 +287,13 @@ export function touchChannelLastSeen(channelId: string): void {
 }
 
 /**
- * Increment the interaction count and update lastInteraction on a contact.
- * Expects a plain contact UUID (Contact.id).
+ * Track an interaction on the specific channel that received it.
+ * Swallows errors to avoid disrupting the inbound message hot path.
  */
-export function touchContactInteraction(contactId: string): void {
+export function touchContactInteraction(channelId: string): void {
   try {
-    updateContactInteraction(contactId);
+    updateChannelInteraction(channelId);
   } catch (err) {
-    log.warn({ err }, "Failed to update contact interaction stats");
+    log.warn({ err }, "Failed to update channel interaction stats");
   }
 }

package/src/contacts/types.ts

@@ -70,6 +70,8 @@ export interface ContactChannel {
   revokedReason: string | null;
   blockedReason: string | null;
   lastSeenAt: number | null;
+  interactionCount: number;
+  lastInteraction: number | null;
   updatedAt: number | null;
   createdAt: number;
 }

package/src/context/token-estimator.ts

@@ -1,4 +1,8 @@
-import type { ContentBlock, Message } from "../providers/types.js";
+import type {
+  ContentBlock,
+  Message,
+  ToolDefinition,
+} from "../providers/types.js";
 import { parseImageDimensions } from "./image-dimensions.js";
 
 const CHARS_PER_TOKEN = 4;
@@ -29,8 +33,17 @@ const ANTHROPIC_IMAGE_MAX_TOKENS = Math.ceil(
 const ANTHROPIC_PDF_TOKENS_PER_BYTE = 0.016;
 const ANTHROPIC_PDF_MIN_TOKENS = 1600; // At least one page
 
+// Anthropic wraps each tool definition in XML internally, adding overhead
+// beyond the raw JSON schema. Empirically measured at ~132 tokens/tool via
+// the countTokens API, but the overhead varies by schema complexity.
+// We use per-tool estimation (JSON schema size) plus a fixed XML-wrapping
+// overhead to approximate the actual cost.
+const TOOL_DEFINITION_OVERHEAD_TOKENS = 28;
+
 export interface TokenEstimatorOptions {
   providerName?: string;
+  /** Pre-computed tool token budget. When provided, added to the prompt total. */
+  toolTokenBudget?: number;
 }
 
 export function estimateTextTokens(text: string): number {
@@ -185,6 +198,25 @@ export function estimateMessagesTokens(
   return total;
 }
 
+/** Estimate token cost for a single tool definition. */
+export function estimateToolDefinitionTokens(tool: ToolDefinition): number {
+  return (
+    TOOL_DEFINITION_OVERHEAD_TOKENS +
+    estimateTextTokens(tool.name) +
+    estimateTextTokens(tool.description) +
+    estimateTextTokens(stableJson(tool.input_schema))
+  );
+}
+
+/** Estimate total token cost for an array of tool definitions. */
+export function estimateToolsTokens(tools: ToolDefinition[]): number {
+  let total = 0;
+  for (const tool of tools) {
+    total += estimateToolDefinitionTokens(tool);
+  }
+  return total;
+}
+
 export function estimatePromptTokens(
   messages: Message[],
   systemPrompt?: string,
@@ -193,7 +225,8 @@ export function estimatePromptTokens(
   const systemTokens = systemPrompt
     ? SYSTEM_PROMPT_OVERHEAD_TOKENS + estimateTextTokens(systemPrompt)
     : 0;
-  return systemTokens + estimateMessagesTokens(messages, options);
+  const toolTokens = options?.toolTokenBudget ?? 0;
+  return systemTokens + toolTokens + estimateMessagesTokens(messages, options);
 }
 
 function stableJson(value: unknown): string {

package/src/context/window-manager.ts

@@ -85,12 +85,15 @@ export interface ContextWindowManagerOptions {
   provider: Provider;
   systemPrompt: string | (() => string);
   config: ContextWindowConfig;
+  /** Pre-computed tool token budget to include in all estimations. */
+  toolTokenBudget?: number;
 }
 
 export class ContextWindowManager {
   private readonly provider: Provider;
   private readonly _systemPrompt: string | (() => string);
   private readonly config: ContextWindowConfig;
+  private readonly toolTokenBudget: number;
   /**
    * Cached resolved system prompt. Lazily populated on first access via the
    * `systemPrompt` getter and cleared after each compaction pass so the next
@@ -102,6 +105,7 @@ export class ContextWindowManager {
     this.provider = options.provider;
     this._systemPrompt = options.systemPrompt;
     this.config = options.config;
+    this.toolTokenBudget = options.toolTokenBudget ?? 0;
   }
 
   /** Lazily resolve and cache the system prompt for the duration of a compaction pass. */
@@ -132,6 +136,7 @@ export class ContextWindowManager {
     try {
       const estimated = estimatePromptTokens(messages, this.systemPrompt, {
         providerName: this.provider.name,
+        toolTokenBudget: this.toolTokenBudget,
       });
       const threshold = Math.floor(
         this.config.maxInputTokens * this.config.compactThreshold,
@@ -163,6 +168,7 @@ export class ContextWindowManager {
       options?.precomputedEstimate ??
       estimatePromptTokens(messages, this.systemPrompt, {
         providerName: this.provider.name,
+        toolTokenBudget: this.toolTokenBudget,
       });
     const thresholdTokens = Math.floor(
       this.config.maxInputTokens * this.config.compactThreshold,
@@ -245,6 +251,7 @@ export class ContextWindowManager {
       const estimatedAfterTruncation = didTruncate
         ? estimatePromptTokens(truncatedMessages, this.systemPrompt, {
             providerName: this.provider.name,
+            toolTokenBudget: this.toolTokenBudget,
           })
         : previousEstimatedInputTokens;
       return {
@@ -303,7 +310,10 @@ export class ContextWindowManager {
     const projectedInputTokens = estimatePromptTokens(
       projectedMessages,
       this.systemPrompt,
-      { providerName: this.provider.name },
+      {
+        providerName: this.provider.name,
+        toolTokenBudget: this.toolTokenBudget,
+      },
     );
     const projectedGainTokens = Math.max(
       0,
@@ -428,7 +438,10 @@ export class ContextWindowManager {
     const estimatedInputTokens = estimatePromptTokens(
       compactedMessages,
       this.systemPrompt,
-      { providerName: this.provider.name },
+      {
+        providerName: this.provider.name,
+        toolTokenBudget: this.toolTokenBudget,
+      },
     );
     log.info(
       {
@@ -502,6 +515,7 @@ export class ContextWindowManager {
       );
       return estimatePromptTokens(projectedMessages, this.systemPrompt, {
         providerName: this.provider.name,
+        toolTokenBudget: this.toolTokenBudget,
       });
     };
 

package/src/daemon/config-watcher.ts

@@ -20,6 +20,7 @@ import {
   resetAllowlist,
   validateAllowlistFile,
 } from "../security/secret-allowlist.js";
+import { handleBashSignal } from "../signals/bash.js";
 import { handleConfirmationSignal } from "../signals/confirm.js";
 import { handleMcpReloadSignal } from "../signals/mcp-reload.js";
 import { DebouncerMap } from "../util/debounce.js";
@@ -224,20 +225,37 @@ export class ConfigWatcher {
       // If we can't create it, watching will also fail — handled below.
     }
 
-    const signalHandlers: Record<string, () => void> = {
+    const exactSignalHandlers: Record<string, () => void> = {
       "mcp-reload": handleMcpReloadSignal,
       confirm: handleConfirmationSignal,
     };
 
+    const prefixSignalHandlers: Record<string, (filename: string) => void> = {
+      "bash.": handleBashSignal,
+    };
+
     try {
       const watcher = watch(signalsDir, (_eventType, filename) => {
         if (!filename) return;
         const file = String(filename);
-        if (!signalHandlers[file]) return;
-        this.debounceTimers.schedule(`signal:${file}`, () => {
-          log.info({ file }, "Signal file detected");
-          signalHandlers[file]();
-        });
+
+        if (exactSignalHandlers[file]) {
+          this.debounceTimers.schedule(`signal:${file}`, () => {
+            log.info({ file }, "Signal file detected");
+            exactSignalHandlers[file]();
+          });
+          return;
+        }
+
+        for (const [prefix, handler] of Object.entries(prefixSignalHandlers)) {
+          if (file.startsWith(prefix) && !file.endsWith(".result")) {
+            this.debounceTimers.schedule(`signal:${file}`, () => {
+              log.info({ file }, "Signal file detected");
+              handler(file);
+            });
+            return;
+          }
+        }
       });
       this.watchers.push(watcher);
       log.info({ dir: signalsDir }, "Watching signals directory");

package/src/daemon/context-overflow-reducer.ts

@@ -88,6 +88,8 @@ export interface ReducerConfig {
   contextWindow: ContextWindowConfig;
   /** Target token budget — the reducer tries to get below this. */
   targetTokens: number;
+  /** Pre-computed tool token budget to include in estimations. */
+  toolTokenBudget?: number;
 }
 
 /**
@@ -143,6 +145,7 @@ export async function reduceContextOverflow(
   // All tiers exhausted
   const estimatedTokens = estimatePromptTokens(messages, config.systemPrompt, {
     providerName: config.providerName,
+    toolTokenBudget: config.toolTokenBudget,
   });
   return {
     messages,
@@ -175,6 +178,7 @@ async function applyForcedCompaction(
     ? result.estimatedInputTokens
     : estimatePromptTokens(messages, config.systemPrompt, {
         providerName: config.providerName,
+        toolTokenBudget: config.toolTokenBudget,
       });
 
   const nextApplied: ReducerTier[] = [...applied, "forced_compaction"];
@@ -205,7 +209,10 @@ function applyToolResultTruncation(
   const estimatedTokens = estimatePromptTokens(
     nextMessages,
     config.systemPrompt,
-    { providerName: config.providerName },
+    {
+      providerName: config.providerName,
+      toolTokenBudget: config.toolTokenBudget,
+    },
   );
 
   const nextApplied: ReducerTier[] = [...applied, "tool_result_truncation"];
@@ -242,7 +249,10 @@ function applyMediaStubbing(
   const estimatedTokens = estimatePromptTokens(
     nextMessages,
     config.systemPrompt,
-    { providerName: config.providerName },
+    {
+      providerName: config.providerName,
+      toolTokenBudget: config.toolTokenBudget,
+    },
   );
 
   const nextApplied: ReducerTier[] = [...applied, "media_stubbing"];
@@ -271,6 +281,7 @@ function applyInjectionDowngrade(
   // mode, which the caller applies via applyRuntimeInjections().
   const estimatedTokens = estimatePromptTokens(messages, config.systemPrompt, {
     providerName: config.providerName,
+    toolTokenBudget: config.toolTokenBudget,
   });
 
   const nextApplied: ReducerTier[] = [...applied, "injection_downgrade"];

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

@@ -29,6 +29,29 @@ export function computeGatewayTarget(): string {
   return getGatewayInternalBaseUrl();
 }
 
+/**
+ * Read the current ingress config from the raw workspace config file.
+ * Extracted so it can be called from both the daemon message handler
+ * and the HTTP route handler.
+ */
+export function getIngressConfigResult(): {
+  enabled: boolean;
+  publicBaseUrl: string;
+  localGatewayTarget: string;
+  success: boolean;
+} {
+  const raw = loadRawConfig();
+  const ingress = (raw?.ingress ?? {}) as Record<string, unknown>;
+  const publicBaseUrl = (ingress.publicBaseUrl as string) ?? "";
+  const enabled = (ingress.enabled as boolean | undefined) ?? false;
+  return {
+    enabled,
+    publicBaseUrl,
+    localGatewayTarget: computeGatewayTarget(),
+    success: true,
+  };
+}
+
 /**
  * Best-effort Twilio webhook sync helper.
  *
@@ -80,16 +103,10 @@ export async function handleIngressConfig(
   const localGatewayTarget = computeGatewayTarget();
   try {
     if (msg.action === "get") {
-      const raw = loadRawConfig();
-      const ingress = (raw?.ingress ?? {}) as Record<string, unknown>;
-      const publicBaseUrl = (ingress.publicBaseUrl as string) ?? "";
-      const enabled = (ingress.enabled as boolean | undefined) ?? false;
+      const result = getIngressConfigResult();
       ctx.send({
         type: "ingress_config_response",
-        enabled,
-        publicBaseUrl,
-        localGatewayTarget,
-        success: true,
+        ...result,
       });
     } else if (msg.action === "set") {
       const value = (msg.publicBaseUrl ?? "").trim().replace(/\/+$/, "");

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

@@ -1,9 +1,11 @@
 import {
+  API_KEY_PROVIDERS,
   getConfig,
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
 import { initializeProviders } from "../../providers/registry.js";
+import { getSecureKeyAsync } from "../../security/secure-keys.js";
 import type {
   ImageGenModelSetRequest,
   ModelSetRequest,
@@ -26,11 +28,14 @@ export interface ModelInfo {
 }
 
 /** Return current model configuration. */
-export function getModelInfo(): ModelInfo {
+export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
-  const configured = Object.keys(config.apiKeys).filter(
-    (k) => !!config.apiKeys[k],
-  );
+  const configured: string[] = [];
+  for (const p of API_KEY_PROVIDERS) {
+    if (await getSecureKeyAsync(p)) {
+      configured.push(p);
+    }
+  }
   if (!configured.includes("ollama")) configured.push("ollama");
   return {
     model: config.model,
@@ -58,7 +63,10 @@ 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.
  */
-export function setModel(modelId: string, ctx: ModelSetContext): ModelInfo {
+export async function setModel(
+  modelId: string,
+  ctx: ModelSetContext,
+): 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.
@@ -68,17 +76,16 @@ export function setModel(modelId: string, ctx: ModelSetContext): ModelInfo {
     const providerAligned =
       !expectedProvider || current.provider === expectedProvider;
     if (modelId === current.model && providerAligned) {
-      return getModelInfo();
+      return await getModelInfo();
     }
   }
 
   // Validate API key before switching
   const provider = MODEL_TO_PROVIDER[modelId];
   if (provider && provider !== "ollama") {
-    const currentConfig = getConfig();
-    if (!currentConfig.apiKeys[provider]) {
+    if (!(await getSecureKeyAsync(provider))) {
       // Return current model_info so the client resyncs its optimistic state
-      return getModelInfo();
+      return await getModelInfo();
     }
   }
 
@@ -158,20 +165,20 @@ export function setImageGenModel(modelId: string, ctx: ModelSetContext): void {
 // HTTP handlers (delegate to shared logic)
 // ---------------------------------------------------------------------------
 
-export function handleModelGet(ctx: HandlerContext): void {
-  const info = getModelInfo();
+export async function handleModelGet(ctx: HandlerContext): Promise<void> {
+  const info = await getModelInfo();
   ctx.send({
     type: "model_info",
     ...info,
   });
 }
 
-export function handleModelSet(
+export async function handleModelSet(
   msg: ModelSetRequest,
   ctx: HandlerContext,
-): void {
+): Promise<void> {
   try {
-    const info = setModel(msg.model, ctx);
+    const info = await setModel(msg.model, ctx);
     ctx.send({ type: "model_info", ...info });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -193,4 +200,3 @@ export function handleImageGenModelSet(
     log.error({ err }, `Failed to set image gen model: ${message}`);
   }
 }
-