@vellumai/assistant 0.3.4 → 0.3.6

package/src/daemon/session-history.ts

@@ -14,7 +14,7 @@ const log = getLogger('session-history');
 
 function isUndoableUserMessage(message: Message): boolean {
   if (message.role !== 'user') return false;
-  if (getSummaryFromContextMessage(message) !== null) return false;
+  if (getSummaryFromContextMessage(message) != null) return false;
   // A user message is undoable if it contains user-authored content (non-tool_result
   // blocks). Messages that contain ONLY tool_result blocks (e.g. automated tool
   // responses) are not undoable. Messages that have both tool_result and text blocks

package/src/daemon/session-media-retry.ts

@@ -17,7 +17,7 @@ export function stripMediaPayloadsForRetry(messages: Message[]): { messages: Mes
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (msg.role !== 'user') continue;
-    if (getSummaryFromContextMessage(msg) !== null) continue;
+    if (getSummaryFromContextMessage(msg) != null) continue;
     if (isToolResultOnlyMessage(msg)) continue;
     latestUserIndex = i;
     break;

package/src/daemon/session-messaging.ts

@@ -7,6 +7,8 @@
 
 import { v4 as uuid } from 'uuid';
 import type { Message } from '../providers/types.js';
+import type { TurnChannelContext } from '../channels/types.js';
+import { parseChannelId } from '../channels/types.js';
 import type { ServerMessage, UserMessageAttachment } from './ipc-protocol.js';
 import { createUserMessage } from '../agent/message-types.js';
 import * as conversationStore from '../memory/conversation-store.js';
@@ -25,6 +27,15 @@ export interface MessagingSessionContext {
   abortController: AbortController | null;
   currentRequestId?: string;
   readonly queue: MessageQueue;
+  getTurnChannelContext(): TurnChannelContext | null;
+}
+
+function extractTurnChannelContext(metadata?: Record<string, unknown>): TurnChannelContext | null {
+  if (!metadata) return null;
+  const userMessageChannel = parseChannelId(metadata.userMessageChannel);
+  const assistantMessageChannel = parseChannelId(metadata.assistantMessageChannel);
+  if (!userMessageChannel || !assistantMessageChannel) return null;
+  return { userMessageChannel, assistantMessageChannel };
 }
 
 // ── enqueueMessage ───────────────────────────────────────────────────
@@ -43,7 +54,18 @@ export function enqueueMessage(
     return { queued: false, requestId };
   }
 
-  const pushed = ctx.queue.push({ content, attachments, requestId, onEvent, activeSurfaceId, currentPage, metadata });
+  const turnChannelContext = extractTurnChannelContext(metadata) ?? ctx.getTurnChannelContext() ?? undefined;
+  const pushed = ctx.queue.push({
+    content,
+    attachments,
+    requestId,
+    onEvent,
+    activeSurfaceId,
+    currentPage,
+    metadata,
+    turnChannelContext,
+    queuedAt: Date.now(),
+  });
   if (!pushed) {
     return { queued: false, rejected: true, requestId };
   }
@@ -82,13 +104,26 @@ export function persistUserMessage(
   ctx.messages.push(userMessage);
 
   try {
+    const turnCtx = extractTurnChannelContext(metadata) ?? ctx.getTurnChannelContext();
+    const mergedMetadata = turnCtx
+      ? {
+          ...(metadata ?? {}),
+          userMessageChannel: turnCtx.userMessageChannel,
+          assistantMessageChannel: turnCtx.assistantMessageChannel,
+        }
+      : metadata;
+
     const persistedUserMessage = conversationStore.addMessage(
       ctx.conversationId,
       'user',
       JSON.stringify(userMessage.content),
-      metadata,
+      mergedMetadata,
     );
 
+    if (turnCtx) {
+      conversationStore.setConversationOriginChannelIfUnset(ctx.conversationId, turnCtx.userMessageChannel);
+    }
+
     if (!persistedUserMessage.id) {
       throw new Error('Failed to persist user message');
     }

package/src/daemon/session-notifiers.ts

@@ -30,7 +30,8 @@ import {
   registerCallCompletionNotifier,
   unregisterCallCompletionNotifier,
 } from '../calls/call-state.js';
-import { getCallSession, getCallEvents } from '../calls/call-store.js';
+import { getCallSession } from '../calls/call-store.js';
+import { buildCallCompletionMessage } from '../calls/call-conversation-messages.js';
 
 /**
  * Subset of Session state that notifier callbacks need to read at
@@ -95,12 +96,13 @@ export function registerSessionNotifiers(
   registerCallQuestionNotifier(conversationId, (callSessionId: string, question: string) => {
     const callSession = getCallSession(callSessionId);
     const callee = callSession?.toNumber ?? 'the caller';
-    const questionText = `**Live call question** (to ${callee}):\n\n${question}\n\n_Reply in this thread to answer. Your next message will be treated as the answer to this question. Once answered, you can send messages to steer the conversation._`;
+    const questionText = `**Live call question** (to ${callee}):\n\n${question}\n\n_Use the call answer API to respond._`;
 
     conversationStore.addMessage(
       conversationId,
       'assistant',
       JSON.stringify([{ type: 'text', text: questionText }]),
+      { userMessageChannel: 'voice', assistantMessageChannel: 'voice' },
     );
 
     ctx.messages.push(createAssistantMessage(questionText));
@@ -122,14 +124,6 @@ export function registerSessionNotifiers(
       const speakerLabel = speaker === 'caller' ? 'Caller' : 'Assistant';
       const transcriptText = `**Live call transcript**\n${speakerLabel}: ${text}`;
 
-      conversationStore.addMessage(
-        conversationId,
-        'assistant',
-        JSON.stringify([{ type: 'text', text: transcriptText }]),
-      );
-
-      ctx.messages.push(createAssistantMessage(transcriptText));
-
       ctx.sendToClient({
         type: 'assistant_text_delta',
         text: transcriptText,
@@ -143,21 +137,7 @@ export function registerSessionNotifiers(
   );
 
   registerCallCompletionNotifier(conversationId, (callSessionId: string) => {
-    const callSession = getCallSession(callSessionId);
-    const events = getCallEvents(callSessionId);
-    const duration = callSession?.endedAt && callSession?.startedAt
-      ? Math.round((callSession.endedAt - callSession.startedAt) / 1000)
-      : null;
-    const durationStr = duration !== null ? ` (${duration}s)` : '';
-    const summaryText = `**Call completed**${durationStr}. ${events.length} event(s) recorded.`;
-
-    conversationStore.addMessage(
-      conversationId,
-      'assistant',
-      JSON.stringify([{ type: 'text', text: summaryText }]),
-    );
-
-    ctx.messages.push(createAssistantMessage(summaryText));
+    const summaryText = buildCallCompletionMessage(callSessionId);
 
     ctx.sendToClient({
       type: 'assistant_text_delta',

package/src/daemon/session-process.ts

@@ -7,6 +7,8 @@
  */
 
 import type { Message } from '../providers/types.js';
+import type { TurnChannelContext } from '../channels/types.js';
+import { parseChannelId } from '../channels/types.js';
 import type { ServerMessage, UserMessageAttachment } from './ipc-protocol.js';
 import type { UsageStats } from './ipc-contract.js';
 import type { MessageQueue } from './session-queue-manager.js';
@@ -14,10 +16,15 @@ import type { QueueDrainReason } from './session-queue-manager.js';
 import type { TraceEmitter } from './trace-emitter.js';
 import { createUserMessage, createAssistantMessage } from '../agent/message-types.js';
 import * as conversationStore from '../memory/conversation-store.js';
+import {
+  getPendingDeliveryByConversation,
+  getGuardianActionRequest,
+  resolveGuardianActionRequest,
+} from '../memory/guardian-action-store.js';
+import { answerCall } from '../calls/call-domain.js';
 import { resolveSlash, type SlashContext } from './session-slash.js';
 import { getConfig } from '../config/loader.js';
 import { getLogger } from '../util/logger.js';
-import { tryRouteCallMessage } from '../calls/call-bridge.js';
 
 const log = getLogger('session-process');
 
@@ -68,6 +75,24 @@ export interface ProcessSessionContext {
     onEvent: (msg: ServerMessage) => void,
     options?: { skipPreMessageRollback?: boolean },
   ): Promise<void>;
+  getTurnChannelContext(): TurnChannelContext | null;
+  setTurnChannelContext(ctx: TurnChannelContext): void;
+}
+
+function resolveQueuedTurnContext(
+  queued: { turnChannelContext?: TurnChannelContext; metadata?: Record<string, unknown> },
+  fallback: TurnChannelContext | null,
+): TurnChannelContext | null {
+  if (queued.turnChannelContext) return queued.turnChannelContext;
+  const metadata = queued.metadata;
+  if (metadata) {
+    const userMessageChannel = parseChannelId(metadata.userMessageChannel);
+    const assistantMessageChannel = parseChannelId(metadata.assistantMessageChannel);
+    if (userMessageChannel && assistantMessageChannel) {
+      return { userMessageChannel, assistantMessageChannel };
+    }
+  }
+  return fallback;
 }
 
 /** Build a SlashContext from the current session state and config. */
@@ -112,6 +137,11 @@ export function drainQueue(session: ProcessSessionContext, reason: QueueDrainRea
     requestId: next.requestId,
   });
 
+  const queuedTurnCtx = resolveQueuedTurnContext(next, session.getTurnChannelContext());
+  if (queuedTurnCtx) {
+    session.setTurnChannelContext(queuedTurnCtx);
+  }
+
   // Resolve slash commands for queued messages
   const slashResult = resolveSlash(next.content, buildSlashContext(session));
 
@@ -120,11 +150,15 @@ export function drainQueue(session: ProcessSessionContext, reason: QueueDrainRea
   // failed write never leaves an unpersisted message in memory.
   if (slashResult.kind === 'unknown') {
     try {
+      const drainChannelMeta = queuedTurnCtx
+        ? { userMessageChannel: queuedTurnCtx.userMessageChannel, assistantMessageChannel: queuedTurnCtx.assistantMessageChannel }
+        : undefined;
       const userMsg = createUserMessage(next.content, next.attachments);
       conversationStore.addMessage(
         session.conversationId,
         'user',
         JSON.stringify(userMsg.content),
+        drainChannelMeta,
       );
       session.messages.push(userMsg);
 
@@ -133,6 +167,7 @@ export function drainQueue(session: ProcessSessionContext, reason: QueueDrainRea
         session.conversationId,
         'assistant',
         JSON.stringify(assistantMsg.content),
+        drainChannelMeta,
       );
       session.messages.push(assistantMsg);
 
@@ -197,49 +232,15 @@ export function drainQueue(session: ProcessSessionContext, reason: QueueDrainRea
   session.currentPage = next.currentPage;
 
   // Fire-and-forget: persistUserMessage set session.processing = true
-  // so subsequent messages will still be enqueued. Route through the call
-  // bridge first — if consumed, skip agent processing and continue draining.
+  // so subsequent messages will still be enqueued.
   // runAgentLoop's finally block will call drainQueue when this run completes.
-  routeOrProcess(session, resolvedContent, userMessageId, next).catch((err) => {
+  session.runAgentLoop(resolvedContent, userMessageId, next.onEvent).catch((err) => {
     const message = err instanceof Error ? err.message : String(err);
     log.error({ err, conversationId: session.conversationId, requestId: next.requestId }, 'Error processing queued message');
     next.onEvent({ type: 'error', message: `Failed to process queued message: ${message}` });
   });
 }
 
-/**
- * Try the call bridge first; if not consumed, run the agent loop.
- * Used by drainQueue to handle the async bridge check in fire-and-forget mode.
- */
-async function routeOrProcess(
-  session: ProcessSessionContext,
-  content: string,
-  userMessageId: string,
-  next: { onEvent: (msg: ServerMessage) => void; requestId: string },
-): Promise<void> {
-  try {
-    const bridgeResult = await tryRouteCallMessage(session.conversationId, content, userMessageId);
-    if (bridgeResult.handled) {
-      session.preactivatedSkillIds = undefined;
-      session.processing = false;
-      session.abortController = null;
-      session.currentRequestId = undefined;
-      log.info({ conversationId: session.conversationId, userMessageId }, 'Queued message consumed by call bridge, skipping agent loop');
-      if (bridgeResult.userFacingText) {
-        next.onEvent({ type: 'assistant_text_delta', text: bridgeResult.userFacingText });
-      }
-      next.onEvent({ type: 'message_complete', sessionId: session.conversationId });
-      // runAgentLoop never ran so its finally block won't drain — continue manually
-      drainQueue(session);
-      return;
-    }
-  } catch (err) {
-    log.warn({ err, conversationId: session.conversationId }, 'Call bridge check failed (non-fatal), proceeding with agent loop');
-  }
-
-  await session.runAgentLoop(content, userMessageId, next.onEvent);
-}
-
 // ── processMessage ───────────────────────────────────────────────────
 
 /**
@@ -258,6 +259,61 @@ export async function processMessage(
   session.currentActiveSurfaceId = activeSurfaceId;
   session.currentPage = currentPage;
 
+  // ── Guardian action answer interception (mac channel) ──
+  // If this conversation has a pending guardian action delivery, treat the
+  // user message as the guardian's answer instead of running the agent loop.
+  const guardianDelivery = getPendingDeliveryByConversation(session.conversationId);
+  if (guardianDelivery) {
+    const guardianRequest = getGuardianActionRequest(guardianDelivery.requestId);
+    if (guardianRequest && guardianRequest.status === 'pending') {
+      const guardianChannelMeta = { userMessageChannel: 'macos' as const, assistantMessageChannel: 'macos' as const };
+      const userMsg = createUserMessage(content, attachments);
+      const persisted = conversationStore.addMessage(
+        session.conversationId,
+        'user',
+        JSON.stringify(userMsg.content),
+        guardianChannelMeta,
+      );
+      session.messages.push(userMsg);
+
+      // Attempt to deliver the answer to the call first. Only resolve
+      // the guardian action request if answerCall succeeds, so that a
+      // failed delivery leaves the request pending for retry from
+      // another channel.
+      const answerResult = await answerCall({ callSessionId: guardianRequest.callSessionId, answer: content });
+
+      if ('ok' in answerResult && answerResult.ok) {
+        const resolved = resolveGuardianActionRequest(guardianRequest.id, content, 'macos');
+        const replyText = resolved
+          ? 'Your answer has been relayed to the call.'
+          : 'This question has already been answered from another channel.';
+        const replyMsg = createAssistantMessage(replyText);
+        conversationStore.addMessage(
+          session.conversationId,
+          'assistant',
+          JSON.stringify(replyMsg.content),
+          guardianChannelMeta,
+        );
+        session.messages.push(replyMsg);
+        onEvent({ type: 'assistant_text_delta', text: replyText });
+      } else {
+        const errorDetail = 'error' in answerResult ? answerResult.error : 'Unknown error';
+        log.warn({ callSessionId: guardianRequest.callSessionId, error: errorDetail }, 'answerCall failed for mac guardian answer');
+        const failMsg = createAssistantMessage('Failed to deliver your answer to the call. Please try again.');
+        conversationStore.addMessage(
+          session.conversationId,
+          'assistant',
+          JSON.stringify(failMsg.content),
+          guardianChannelMeta,
+        );
+        session.messages.push(failMsg);
+        onEvent({ type: 'assistant_text_delta', text: 'Failed to deliver your answer to the call. Please try again.' });
+      }
+      onEvent({ type: 'message_complete', sessionId: session.conversationId });
+      return persisted.id;
+    }
+  }
+
   // Resolve slash commands before persistence
   const slashResult = resolveSlash(content, buildSlashContext(session));
 
@@ -265,11 +321,16 @@ export async function processMessage(
   // messageId is real.  Persist each message before pushing to session.messages
   // so that a failed write never leaves an unpersisted message in memory.
   if (slashResult.kind === 'unknown') {
+    const pmTurnCtx = session.getTurnChannelContext();
+    const pmChannelMeta = pmTurnCtx
+      ? { userMessageChannel: pmTurnCtx.userMessageChannel, assistantMessageChannel: pmTurnCtx.assistantMessageChannel }
+      : undefined;
     const userMsg = createUserMessage(content, attachments);
     const persisted = conversationStore.addMessage(
       session.conversationId,
       'user',
       JSON.stringify(userMsg.content),
+      pmChannelMeta,
     );
     session.messages.push(userMsg);
 
@@ -278,6 +339,7 @@ export async function processMessage(
       session.conversationId,
       'assistant',
       JSON.stringify(assistantMsg.content),
+      pmChannelMeta,
     );
     session.messages.push(assistantMsg);
 
@@ -313,28 +375,6 @@ export async function processMessage(
     return '';
   }
 
-  // Route through the call bridge before the agent loop. When the bridge
-  // consumes the message (answer or instruction), skip agent processing.
-  try {
-    const bridgeResult = await tryRouteCallMessage(session.conversationId, resolvedContent, userMessageId);
-    if (bridgeResult.handled) {
-      session.preactivatedSkillIds = undefined;
-      session.processing = false;
-      session.abortController = null;
-      session.currentRequestId = undefined;
-      log.info({ conversationId: session.conversationId, userMessageId }, 'IPC message consumed by call bridge, skipping agent loop');
-      if (bridgeResult.userFacingText) {
-        onEvent({ type: 'assistant_text_delta', text: bridgeResult.userFacingText });
-      }
-      onEvent({ type: 'message_complete', sessionId: session.conversationId });
-      // runAgentLoop never ran so its finally block won't drain — continue manually
-      drainQueue(session);
-      return userMessageId;
-    }
-  } catch (err) {
-    log.warn({ err, conversationId: session.conversationId }, 'Call bridge check failed (non-fatal), proceeding with agent loop');
-  }
-
   await session.runAgentLoop(resolvedContent, userMessageId, onEvent);
   return userMessageId;
 }

package/src/daemon/session-queue-manager.ts

@@ -6,6 +6,10 @@
  */
 
 import type { ServerMessage, UserMessageAttachment } from './ipc-protocol.js';
+import type { TurnChannelContext } from '../channels/types.js';
+import { getLogger } from '../util/logger.js';
+
+const log = getLogger('session-queue');
 
 export interface QueuedMessage {
   content: string;
@@ -15,9 +19,15 @@ export interface QueuedMessage {
   activeSurfaceId?: string;
   currentPage?: string;
   metadata?: Record<string, unknown>;
+  turnChannelContext?: TurnChannelContext;
+  /** Timestamp (ms) when the message was enqueued. */
+  queuedAt: number;
 }
 
 export const MAX_QUEUE_DEPTH = 10;
+/** Messages older than this (ms) are auto-expired from the queue. */
+export const DEFAULT_MAX_WAIT_MS = 60_000;
+const CAPACITY_WARNING_THRESHOLD = 0.8;
 
 /**
  * Describes why a queued message was promoted from the queue.
@@ -35,27 +45,77 @@ export interface QueuePolicy {
   checkpointHandoffEnabled: boolean;
 }
 
+export interface QueueMetrics {
+  currentDepth: number;
+  totalDropped: number;
+  totalExpired: number;
+  /** Average wait time (ms) of dequeued messages. 0 when no messages have been dequeued. */
+  averageWaitMs: number;
+}
+
 /**
  * Typed wrapper around the queued-message array.
  *
- * Session owns one instance; the wrapper handles capacity checks and
- * iteration so the rest of Session doesn't touch the raw array.
+ * Session owns one instance; the wrapper handles capacity checks,
+ * expiry, metrics, and iteration so the rest of Session doesn't
+ * touch the raw array.
  */
 export class MessageQueue {
   private items: QueuedMessage[] = [];
+  private maxWaitMs: number;
+  private droppedCount = 0;
+  private expiredCount = 0;
+  private totalWaitMs = 0;
+  private dequeuedCount = 0;
+  private capacityWarned = false;
+
+  constructor(maxWaitMs: number = DEFAULT_MAX_WAIT_MS) {
+    this.maxWaitMs = maxWaitMs;
+  }
 
   push(item: QueuedMessage): boolean {
-    if (this.items.length >= MAX_QUEUE_DEPTH) return false;
+    this.expireStale();
+
+    if (this.items.length >= MAX_QUEUE_DEPTH) {
+      this.droppedCount++;
+      item.onEvent({
+        type: 'error',
+        message: 'Message queue is full. Please wait for current messages to be processed.',
+        category: 'queue_full',
+      });
+      return false;
+    }
+
+    item.queuedAt = Date.now();
     this.items.push(item);
+
+    const ratio = this.items.length / MAX_QUEUE_DEPTH;
+    if (ratio >= CAPACITY_WARNING_THRESHOLD && !this.capacityWarned) {
+      this.capacityWarned = true;
+      log.warn({ depth: this.items.length, max: MAX_QUEUE_DEPTH }, 'Queue nearing capacity');
+    } else if (ratio < CAPACITY_WARNING_THRESHOLD) {
+      this.capacityWarned = false;
+    }
+
     return true;
   }
 
   shift(): QueuedMessage | undefined {
-    return this.items.shift();
+    this.expireStale();
+    const item = this.items.shift();
+    if (item) {
+      this.dequeuedCount++;
+      this.totalWaitMs += Date.now() - item.queuedAt;
+    }
+    if (this.items.length / MAX_QUEUE_DEPTH < CAPACITY_WARNING_THRESHOLD) {
+      this.capacityWarned = false;
+    }
+    return item;
   }
 
   clear(): void {
     this.items = [];
+    this.capacityWarned = false;
   }
 
   get length(): number {
@@ -76,6 +136,38 @@ export class MessageQueue {
     return this.items.splice(idx, 1)[0];
   }
 
+  getMetrics(): QueueMetrics {
+    return {
+      currentDepth: this.items.length,
+      totalDropped: this.droppedCount,
+      totalExpired: this.expiredCount,
+      averageWaitMs: this.dequeuedCount > 0 ? this.totalWaitMs / this.dequeuedCount : 0,
+    };
+  }
+
+  /** Remove messages that have been waiting longer than maxWaitMs. */
+  private expireStale(): void {
+    const now = Date.now();
+    const cutoff = now - this.maxWaitMs;
+    const before = this.items.length;
+    this.items = this.items.filter((item) => {
+      if (item.queuedAt < cutoff) {
+        this.expiredCount++;
+        log.warn({ requestId: item.requestId, waitMs: now - item.queuedAt }, 'Expiring stale queued message');
+        item.onEvent({
+          type: 'error',
+          message: 'Your queued message was dropped because it waited too long in the queue.',
+          category: 'queue_expired',
+        });
+        return false;
+      }
+      return true;
+    });
+    if (this.items.length < before && this.items.length / MAX_QUEUE_DEPTH < CAPACITY_WARNING_THRESHOLD) {
+      this.capacityWarned = false;
+    }
+  }
+
   [Symbol.iterator](): Iterator<QueuedMessage> {
     return this.items[Symbol.iterator]();
   }