@vellumai/assistant 0.3.15 → 0.3.18

package/src/daemon/handlers/config.ts

@@ -31,6 +31,7 @@ export { handleTelegramConfig, summarizeTelegramError } from './config-telegram.
 export { handleEnvVarsRequest, handleToolNamesList,handleToolPermissionSimulate } from './config-tools.js';
 export { handleAcceptStarterBundle,handleAddTrustRule, handleRemoveTrustRule, handleTrustRulesList, handleUpdateTrustRule } from './config-trust.js';
 export { handleTwilioConfig } from './config-twilio.js';
+export { broadcastClientSettingsUpdate, handleVoiceConfigUpdate, normalizeActivationKey } from './config-voice.js';
 
 // Assemble the combined dispatch map from domain-specific handler groups
 import { channelHandlers } from './config-channels.js';
@@ -46,6 +47,7 @@ import { telegramHandlers } from './config-telegram.js';
 import { toolHandlers } from './config-tools.js';
 import { trustHandlers } from './config-trust.js';
 import { twilioHandlers } from './config-twilio.js';
+import { voiceHandlers } from './config-voice.js';
 
 export const configHandlers = {
   ...modelHandlers,
@@ -61,4 +63,5 @@ export const configHandlers = {
   ...toolHandlers,
   ...parentalControlHandlers,
   ...heartbeatHandlers,
+  ...voiceHandlers,
 };

package/src/daemon/handlers/identity.ts

@@ -6,6 +6,45 @@ import { fileURLToPath } from 'node:url';
 import { getWorkspacePromptPath, readLockfile } from '../../util/platform.js';
 import { defineHandlers, type HandlerContext,log } from './shared.js';
 
+export interface IdentityFields {
+  name: string;
+  role: string;
+  personality: string;
+  emoji: string;
+  home: string;
+}
+
+/** Parse the core identity fields from IDENTITY.md content. */
+export function parseIdentityFields(content: string): IdentityFields {
+  const fields: Record<string, string> = {};
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    const lower = trimmed.toLowerCase();
+    const extract = (prefix: string): string | null => {
+      if (!lower.startsWith(prefix)) return null;
+      return trimmed.split(':**').pop()?.trim() ?? null;
+    };
+
+    const name = extract('- **name:**');
+    if (name) { fields.name = name; continue; }
+    const role = extract('- **role:**');
+    if (role) { fields.role = role; continue; }
+    const personality = extract('- **personality:**') ?? extract('- **vibe:**');
+    if (personality) { fields.personality = personality; continue; }
+    const emoji = extract('- **emoji:**');
+    if (emoji) { fields.emoji = emoji; continue; }
+    const home = extract('- **home:**');
+    if (home) { fields.home = home; continue; }
+  }
+  return {
+    name: fields.name ?? '',
+    role: fields.role ?? '',
+    personality: fields.personality ?? '',
+    emoji: fields.emoji ?? '',
+    home: fields.home ?? '',
+  };
+}
+
 function handleIdentityGet(socket: net.Socket, ctx: HandlerContext): void {
   const identityPath = getWorkspacePromptPath('IDENTITY.md');
 
@@ -24,26 +63,7 @@ function handleIdentityGet(socket: net.Socket, ctx: HandlerContext): void {
 
   try {
     const content = readFileSync(identityPath, 'utf-8');
-    const fields: Record<string, string> = {};
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      const lower = trimmed.toLowerCase();
-      const extract = (prefix: string): string | null => {
-        if (!lower.startsWith(prefix)) return null;
-        return trimmed.split(':**').pop()?.trim() ?? null;
-      };
-
-      const name = extract('- **name:**');
-      if (name) { fields.name = name; continue; }
-      const role = extract('- **role:**');
-      if (role) { fields.role = role; continue; }
-      const personality = extract('- **personality:**') ?? extract('- **vibe:**');
-      if (personality) { fields.personality = personality; continue; }
-      const emoji = extract('- **emoji:**');
-      if (emoji) { fields.emoji = emoji; continue; }
-      const home = extract('- **home:**');
-      if (home) { fields.home = home; continue; }
-    }
+    const fields = parseIdentityFields(content);
 
     // Read version from package.json
     let version: string | undefined;
@@ -90,11 +110,11 @@ function handleIdentityGet(socket: net.Socket, ctx: HandlerContext): void {
     ctx.send(socket, {
       type: 'identity_get_response',
       found: true,
-      name: fields.name ?? '',
-      role: fields.role ?? '',
-      personality: fields.personality ?? '',
-      emoji: fields.emoji ?? '',
-      home: fields.home ?? '',
+      name: fields.name,
+      role: fields.role,
+      personality: fields.personality,
+      emoji: fields.emoji,
+      home: fields.home,
       version,
       assistantId,
       createdAt,

package/src/daemon/handlers/misc.ts

@@ -81,13 +81,22 @@ export async function handleTaskSubmit(
         const conversation = conversationStore.createConversation(msg.task || 'Screen Recording');
         ctx.socketToSession.set(socket, conversation.id);
         const recordingId = handleRecordingStart(conversation.id, { promptForSource: true }, socket, ctx);
+        const responseText = recordingId ? 'Starting screen recording.' : 'A recording is already active.';
         ctx.send(socket, { type: 'task_routed', sessionId: conversation.id, interactionType: 'text_qa' });
         ctx.send(socket, {
           type: 'assistant_text_delta',
-          text: recordingId ? 'Starting screen recording.' : 'A recording is already active.',
+          text: responseText,
           sessionId: conversation.id,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: conversation.id });
+        await conversationStore.addMessage(conversation.id, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+        await conversationStore.addMessage(conversation.id, 'assistant', JSON.stringify([{ type: 'text', text: responseText }]));
+        // Sync in-memory session if one exists for this conversation
+        const startSession = ctx.sessions.get(conversation.id);
+        if (startSession && !startSession.isProcessing()) {
+          startSession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+          startSession.messages.push({ role: 'assistant', content: [{ type: 'text', text: responseText }] });
+        }
         if (!recordingId) ctx.socketToSession.delete(socket);
         return;
       } else if (action === 'stop') {
@@ -98,13 +107,21 @@ export async function handleTaskSubmit(
           ctx.socketToSession.set(socket, activeSessionId);
         }
         const stopped = handleRecordingStop(activeSessionId, ctx) !== undefined;
+        const responseText = stopped ? 'Stopping the recording.' : 'No active recording to stop.';
         ctx.send(socket, { type: 'task_routed', sessionId: activeSessionId, interactionType: 'text_qa' });
         ctx.send(socket, {
           type: 'assistant_text_delta',
-          text: stopped ? 'Stopping the recording.' : 'No active recording to stop.',
+          text: responseText,
           sessionId: activeSessionId,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: activeSessionId });
+        await conversationStore.addMessage(activeSessionId, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+        await conversationStore.addMessage(activeSessionId, 'assistant', JSON.stringify([{ type: 'text', text: responseText }]));
+        const stopSession = ctx.sessions.get(activeSessionId);
+        if (stopSession && !stopSession.isProcessing()) {
+          stopSession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+          stopSession.messages.push({ role: 'assistant', content: [{ type: 'text', text: responseText }] });
+        }
         return;
       } else if (action === 'restart') {
         let activeSessionId = ctx.socketToSession.get(socket);
@@ -121,6 +138,13 @@ export async function handleTaskSubmit(
           sessionId: activeSessionId,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: activeSessionId });
+        await conversationStore.addMessage(activeSessionId, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+        await conversationStore.addMessage(activeSessionId, 'assistant', JSON.stringify([{ type: 'text', text: restartResult.responseText }]));
+        const restartSession = ctx.sessions.get(activeSessionId);
+        if (restartSession && !restartSession.isProcessing()) {
+          restartSession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+          restartSession.messages.push({ role: 'assistant', content: [{ type: 'text', text: restartResult.responseText }] });
+        }
         return;
       } else if (action === 'pause') {
         let activeSessionId = ctx.socketToSession.get(socket);
@@ -130,13 +154,21 @@ export async function handleTaskSubmit(
           ctx.socketToSession.set(socket, activeSessionId);
         }
         const paused = handleRecordingPause(activeSessionId, ctx) !== undefined;
+        const responseText = paused ? 'Pausing the recording.' : 'No active recording to pause.';
         ctx.send(socket, { type: 'task_routed', sessionId: activeSessionId, interactionType: 'text_qa' });
         ctx.send(socket, {
           type: 'assistant_text_delta',
-          text: paused ? 'Pausing the recording.' : 'No active recording to pause.',
+          text: responseText,
           sessionId: activeSessionId,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: activeSessionId });
+        await conversationStore.addMessage(activeSessionId, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+        await conversationStore.addMessage(activeSessionId, 'assistant', JSON.stringify([{ type: 'text', text: responseText }]));
+        const pauseSession = ctx.sessions.get(activeSessionId);
+        if (pauseSession && !pauseSession.isProcessing()) {
+          pauseSession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+          pauseSession.messages.push({ role: 'assistant', content: [{ type: 'text', text: responseText }] });
+        }
         return;
       } else if (action === 'resume') {
         let activeSessionId = ctx.socketToSession.get(socket);
@@ -146,13 +178,21 @@ export async function handleTaskSubmit(
           ctx.socketToSession.set(socket, activeSessionId);
         }
         const resumed = handleRecordingResume(activeSessionId, ctx) !== undefined;
+        const responseText = resumed ? 'Resuming the recording.' : 'No active recording to resume.';
         ctx.send(socket, { type: 'task_routed', sessionId: activeSessionId, interactionType: 'text_qa' });
         ctx.send(socket, {
           type: 'assistant_text_delta',
-          text: resumed ? 'Resuming the recording.' : 'No active recording to resume.',
+          text: responseText,
           sessionId: activeSessionId,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: activeSessionId });
+        await conversationStore.addMessage(activeSessionId, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+        await conversationStore.addMessage(activeSessionId, 'assistant', JSON.stringify([{ type: 'text', text: responseText }]));
+        const resumeSession = ctx.sessions.get(activeSessionId);
+        if (resumeSession && !resumeSession.isProcessing()) {
+          resumeSession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+          resumeSession.messages.push({ role: 'assistant', content: [{ type: 'text', text: responseText }] });
+        }
         return;
       } else {
         // Unrecognized action — fall through to normal text handling so the
@@ -165,6 +205,7 @@ export async function handleTaskSubmit(
     let pendingRecordingStart = false;
     let pendingRecordingStop = false;
     let pendingRecordingRestart: 'restart_with_remainder' | 'start_and_stop_with_remainder' | false = false;
+    let originalTaskBeforeStrip: string | undefined;
     if (config.daemon.standaloneRecording) {
       const name = getAssistantName();
       const dynamicNames = [name].filter(Boolean) as string[];
@@ -184,6 +225,13 @@ export async function handleTaskSubmit(
         ctx.send(socket, { type: 'task_routed', sessionId: conversation.id, interactionType: 'text_qa' });
         ctx.send(socket, { type: 'assistant_text_delta', text: execResult.responseText!, sessionId: conversation.id });
         ctx.send(socket, { type: 'message_complete', sessionId: conversation.id });
+        await conversationStore.addMessage(conversation.id, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+        await conversationStore.addMessage(conversation.id, 'assistant', JSON.stringify([{ type: 'text', text: execResult.responseText! }]));
+        const startOnlySession = ctx.sessions.get(conversation.id);
+        if (startOnlySession && !startOnlySession.isProcessing()) {
+          startOnlySession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+          startOnlySession.messages.push({ role: 'assistant', content: [{ type: 'text', text: execResult.responseText! }] });
+        }
 
         // If recording rejected, unbind socket
         if (execResult.recordingStarted === false) {
@@ -212,6 +260,13 @@ export async function handleTaskSubmit(
         ctx.send(socket, { type: 'task_routed', sessionId: activeSessionId, interactionType: 'text_qa' });
         ctx.send(socket, { type: 'assistant_text_delta', text: execResult.responseText!, sessionId: activeSessionId });
         ctx.send(socket, { type: 'message_complete', sessionId: activeSessionId });
+        await conversationStore.addMessage(activeSessionId, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+        await conversationStore.addMessage(activeSessionId, 'assistant', JSON.stringify([{ type: 'text', text: execResult.responseText! }]));
+        const stopOnlySession = ctx.sessions.get(activeSessionId);
+        if (stopOnlySession && !stopOnlySession.isProcessing()) {
+          stopOnlySession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+          stopOnlySession.messages.push({ role: 'assistant', content: [{ type: 'text', text: execResult.responseText! }] });
+        }
         return;
       }
 
@@ -233,6 +288,13 @@ export async function handleTaskSubmit(
         ctx.send(socket, { type: 'task_routed', sessionId: activeSessionId, interactionType: 'text_qa' });
         ctx.send(socket, { type: 'assistant_text_delta', text: execResult.responseText!, sessionId: activeSessionId });
         ctx.send(socket, { type: 'message_complete', sessionId: activeSessionId });
+        await conversationStore.addMessage(activeSessionId, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+        await conversationStore.addMessage(activeSessionId, 'assistant', JSON.stringify([{ type: 'text', text: execResult.responseText! }]));
+        const startStopOnlySession = ctx.sessions.get(activeSessionId);
+        if (startStopOnlySession && !startStopOnlySession.isProcessing()) {
+          startStopOnlySession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+          startStopOnlySession.messages.push({ role: 'assistant', content: [{ type: 'text', text: execResult.responseText! }] });
+        }
         return;
       }
 
@@ -255,6 +317,13 @@ export async function handleTaskSubmit(
         ctx.send(socket, { type: 'task_routed', sessionId: activeSessionId, interactionType: 'text_qa' });
         ctx.send(socket, { type: 'assistant_text_delta', text: execResult.responseText!, sessionId: activeSessionId });
         ctx.send(socket, { type: 'message_complete', sessionId: activeSessionId });
+        await conversationStore.addMessage(activeSessionId, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+        await conversationStore.addMessage(activeSessionId, 'assistant', JSON.stringify([{ type: 'text', text: execResult.responseText! }]));
+        const handledSession = ctx.sessions.get(activeSessionId);
+        if (handledSession && !handledSession.isProcessing()) {
+          handledSession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+          handledSession.messages.push({ role: 'assistant', content: [{ type: 'text', text: execResult.responseText! }] });
+        }
         return;
       }
 
@@ -276,6 +345,8 @@ export async function handleTaskSubmit(
           pendingRecordingStart = intentResult.kind === 'start_with_remainder';
           pendingRecordingRestart = intentResult.kind === 'restart_with_remainder' ? 'restart_with_remainder' : false;
         }
+        // Preserve the original text so the DB stores the full message
+        originalTaskBeforeStrip = msg.task;
         (msg as { task: string }).task = intentResult.remainder;
         rlog.info({ remaining: intentResult.remainder }, 'Recording intent deferred, continuing with remaining text');
       }
@@ -318,6 +389,13 @@ export async function handleTaskSubmit(
                 sessionId: activeSessionId,
               });
               ctx.send(socket, { type: 'message_complete', sessionId: activeSessionId });
+              await conversationStore.addMessage(activeSessionId, 'user', JSON.stringify([{ type: 'text', text: msg.task || '' }]));
+              await conversationStore.addMessage(activeSessionId, 'assistant', JSON.stringify([{ type: 'text', text: execResult.responseText! }]));
+              const fallbackSession = ctx.sessions.get(activeSessionId);
+              if (fallbackSession && !fallbackSession.isProcessing()) {
+                fallbackSession.messages.push({ role: 'user', content: [{ type: 'text', text: msg.task || '' }] });
+                fallbackSession.messages.push({ role: 'assistant', content: [{ type: 'text', text: execResult.responseText! }] });
+              }
 
               // If recording was rejected (e.g. already active), unbind the
               // socket so it doesn't stay bound to an orphaned conversation.
@@ -409,7 +487,7 @@ export async function handleTaskSubmit(
       // Start streaming immediately — client doesn't need to send user_message
       session.processMessage(msg.task, msg.attachments ?? [], (event) => {
         ctx.send(socket, event);
-      }, requestId).catch((err) => {
+      }, requestId, undefined, undefined, undefined, originalTaskBeforeStrip).catch((err) => {
         const message = err instanceof Error ? err.message : String(err);
         rlog.error({ err }, 'Error processing task_submit text QA');
         ctx.send(socket, { type: 'error', message: `Failed to process message: ${message}` });

package/src/daemon/handlers/navigate-settings.ts

@@ -0,0 +1,27 @@
+import type { HandlerContext } from './shared.js';
+
+/**
+ * Valid settings tab identifiers matching the macOS client's SettingsTab enum.
+ * These correspond to the raw values the Swift client expects.
+ */
+export const SETTINGS_TABS = [
+  'Connect',
+  'Integrations',
+  'Trust',
+  'Schedules',
+  'Heartbeat',
+  'Wake Word',
+  'Appearance',
+  'Advanced',
+  'Parental',
+] as const;
+
+export type SettingsTabId = (typeof SETTINGS_TABS)[number];
+
+/**
+ * Broadcast a `navigate_settings` message to all connected clients,
+ * opening the settings panel to the specified tab.
+ */
+export function navigateToSettingsTab(ctx: HandlerContext, tab: SettingsTabId): void {
+  ctx.broadcast({ type: 'navigate_settings', tab });
+}