@vellumai/assistant 0.4.52 → 0.4.54

package/src/daemon/handlers/dictation.ts

@@ -1,19 +1,4 @@
-import {
-  createTimeout,
-  extractToolUse,
-  getConfiguredProvider,
-  userMessage,
-} from "../../providers/provider-send-message.js";
-import {
-  type ProfileResolution,
-  resolveProfile,
-} from "../dictation-profile-store.js";
-import {
-  applyDictionary,
-  expandSnippets,
-} from "../dictation-text-processing.js";
 import type { DictationRequest } from "../message-protocol.js";
-import { type HandlerContext, log } from "./shared.js";
 
 // Action verbs for fast heuristic fallback (used when LLM classifier is unavailable)
 const ACTION_VERBS = [
@@ -32,29 +17,6 @@ const ACTION_VERBS = [
   "navigate",
 ];
 
-const DICTATION_CLASSIFICATION_TIMEOUT_MS = 5000;
-
-const MAX_WINDOW_TITLE_LENGTH = 100;
-
-/** Sanitize window title to mitigate prompt injection from attacker-controlled titles (e.g. browser tabs, Slack conversations). */
-function sanitizeWindowTitle(title: string | undefined): string {
-  if (!title) return "";
-  return title
-    .replace(/[<>]/g, "") // strip angle brackets to prevent tag injection
-    .slice(0, MAX_WINDOW_TITLE_LENGTH);
-}
-
-/** Build a delimited app metadata block so the LLM treats it as contextual data, not instructions. */
-function buildAppMetadataBlock(msg: DictationRequest): string {
-  const windowTitle = sanitizeWindowTitle(msg.context.windowTitle);
-  return [
-    "<app_metadata>",
-    `App: ${msg.context.appName} (${msg.context.bundleIdentifier})`,
-    `Window: ${windowTitle}`,
-    "</app_metadata>",
-  ].join("\n");
-}
-
 type DictationMode = "dictation" | "command" | "action";
 
 /** Fast heuristic fallback — used when LLM classifier is unavailable or fails. */
@@ -80,394 +42,3 @@ export function detectDictationModeHeuristic(
 
   return "dictation";
 }
-
-/** Build a combined system prompt that classifies AND cleans dictation in a single LLM call. */
-function buildCombinedDictationPrompt(
-  msg: DictationRequest,
-  stylePrompt?: string,
-): string {
-  const sections = [
-    "You are a voice input assistant. You will receive a speech transcription and must:",
-    '1. Classify it as "dictation" (text to insert) or "action" (task for an assistant to execute)',
-    "2. If dictation, clean up the text. If action, return the raw transcription.",
-    "",
-    "## Classification",
-    'DICTATION examples: "Hey how are you doing", "I think we should move forward with the proposal", "Dear team comma please review the attached document"',
-    'ACTION examples: "Message Aaron on Slack saying hey what\'s up", "Send an email to the team about the meeting", "Open Spotify and play my playlist", "Search for flights to Denver", "Create a new document in Google Docs"',
-    "",
-    "Key signals for ACTION: the user is addressing an assistant and asking it to DO something (send, message, open, search, create, schedule, etc.)",
-    "Key signals for DICTATION: the user is composing text content that should be typed out as-is",
-    `Cursor in text field: ${msg.context.cursorInTextField ? "yes" : "no"} — if yes, lean toward dictation unless the intent to command is clear.`,
-    "",
-    "## Cleanup Rules (for dictation mode only)",
-    "- Fix grammar, punctuation, and capitalization",
-    "- Remove filler words (um, uh, like, you know)",
-    '- Rewrite vague or hedging language ("so yeah probably", "I guess maybe") into clear, confident statements',
-    "- Maintain the speaker's intent and meaning",
-  ];
-
-  if (stylePrompt) {
-    sections.push(
-      "",
-      "## User Style (HIGHEST PRIORITY)",
-      "The user has configured these style preferences. They OVERRIDE the default tone adaptation below.",
-      "Follow these instructions precisely — they reflect the user's personal writing voice and preferences.",
-      "",
-      stylePrompt,
-    );
-  }
-
-  sections.push("", "## Tone Adaptation");
-
-  if (stylePrompt) {
-    sections.push(
-      "Use these as fallback guidance only when the User Style above does not cover a specific aspect:",
-    );
-  } else {
-    sections.push("Adapt your output tone based on the active application:");
-  }
-
-  sections.push(
-    "- Email apps (Gmail, Mail): Professional but warm. Use proper greetings and sign-offs if appropriate.",
-    "- Slack: Casual and conversational. Match typical chat style.",
-    "- Code editors (VS Code, Xcode): Technical and concise. Code comments style.",
-    "- Terminal: Command-like, terse.",
-    "- Messages/iMessage: Very casual, texting style. Short sentences.",
-    "- Notes/Docs: Neutral, clear writing.",
-    "- Default: Match the user's natural voice.",
-    "",
-    "## Context Clues",
-    "- Window title may contain recipient name (Slack DMs, email compose)",
-    "- If you can identify a recipient, adapt formality to the apparent relationship",
-    "- Maintain the user's natural voice — don't over-formalize casual speech",
-    "- The user's writing patterns and preferences may be available from memory context — follow those when present",
-    "",
-    buildAppMetadataBlock(msg),
-  );
-
-  return sections.join("\n");
-}
-
-function buildCommandPrompt(
-  msg: DictationRequest,
-  stylePrompt?: string,
-): string {
-  const sections = [
-    "You are a text transformation assistant. The user has selected text and given a voice command to transform it.",
-    "",
-    "## Rules",
-    "- Apply the instruction to the selected text",
-    "- Return ONLY the transformed text, nothing else",
-    "- Do NOT add explanations or commentary",
-  ];
-
-  if (stylePrompt) {
-    sections.push(
-      "",
-      "## User Style (HIGHEST PRIORITY)",
-      "The user has configured these style preferences. They OVERRIDE the default tone adaptation below.",
-      "Follow these instructions precisely — they reflect the user's personal writing voice and preferences.",
-      "",
-      stylePrompt,
-    );
-  }
-
-  sections.push("", "## Tone Adaptation");
-
-  if (stylePrompt) {
-    sections.push(
-      "Use these as fallback guidance only when the User Style above does not cover a specific aspect:",
-    );
-  } else {
-    sections.push("Match the tone to the active application context:");
-  }
-
-  sections.push(
-    "- Email apps (Gmail, Mail): Professional but warm.",
-    "- Slack: Casual and conversational.",
-    "- Code editors (VS Code, Xcode): Technical and concise.",
-    "- Terminal: Command-like, terse.",
-    "- Messages/iMessage: Very casual, texting style.",
-    "- Notes/Docs: Neutral, clear writing.",
-    "- Default: Match the user's natural voice.",
-    "",
-    "## Context Clues",
-    "- Window title may contain recipient name (Slack DMs, email compose)",
-    "- If you can identify a recipient, adapt formality to the apparent relationship",
-    "- Maintain the user's natural voice — don't over-formalize casual speech",
-    "- The user's writing patterns and preferences may be available from memory context — follow those when present",
-    "",
-    buildAppMetadataBlock(msg),
-    "",
-    "Selected text:",
-    msg.context.selectedText ?? "",
-    "",
-    `Instruction: ${msg.transcription}`,
-  );
-
-  return sections.join("\n");
-}
-
-/** Compute dynamic max_tokens based on input length to avoid waste and truncation. */
-function computeMaxTokens(inputLength: number): number {
-  const estimatedInputTokens = Math.ceil(inputLength / 3);
-  return Math.max(256, estimatedInputTokens + 128);
-}
-
-export async function handleDictationRequest(
-  msg: DictationRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  log.info(
-    { transcriptionLength: msg.transcription.length },
-    "Dictation request received",
-  );
-
-  // Resolve profile for all modes (metadata is included in response)
-  const resolution = resolveProfile(
-    msg.context.bundleIdentifier,
-    msg.context.appName,
-    msg.profileId,
-  );
-  const { profile, source: profileSource } = resolution;
-  log.info(
-    { profileId: profile.id, profileSource },
-    "Resolved dictation profile",
-  );
-
-  const profileMeta = {
-    resolvedProfileId: profile.id,
-    profileSource,
-  };
-
-  const stylePrompt = profile.stylePrompt || undefined;
-
-  // Command mode: selected text present — deterministic, no classification needed
-  if (msg.context.selectedText && msg.context.selectedText.trim().length > 0) {
-    log.info({ mode: "command" }, "Command mode (selected text present)");
-    await handleCommandMode(msg, ctx, profile, profileMeta, stylePrompt);
-    return;
-  }
-
-  // Non-command: single LLM call that classifies AND cleans in one shot
-  const transcription = expandSnippets(msg.transcription, profile.snippets);
-
-  try {
-    const provider = getConfiguredProvider();
-    if (!provider) {
-      log.warn(
-        "Dictation: no provider available, using heuristic + raw transcription",
-      );
-      const mode = detectDictationModeHeuristic(msg);
-      const normalizedText = applyDictionary(transcription, profile.dictionary);
-      if (mode === "action") {
-        ctx.send({
-          type: "dictation_response",
-          text: msg.transcription,
-          mode: "action",
-          actionPlan: `User wants to: ${msg.transcription}`,
-          ...profileMeta,
-        });
-      } else {
-        ctx.send({
-          type: "dictation_response",
-          text: normalizedText,
-          mode,
-          ...profileMeta,
-        });
-      }
-      return;
-    }
-
-    const systemPrompt = buildCombinedDictationPrompt(msg, stylePrompt);
-    const maxTokens = computeMaxTokens(transcription.length);
-    const { signal, cleanup } = createTimeout(
-      DICTATION_CLASSIFICATION_TIMEOUT_MS,
-    );
-
-    try {
-      const response = await provider.sendMessage(
-        [userMessage(`Transcription: "${transcription}"`)],
-        [
-          {
-            name: "process_dictation",
-            description: "Classify the voice input and return cleaned text",
-            input_schema: {
-              type: "object" as const,
-              properties: {
-                mode: {
-                  type: "string",
-                  enum: ["dictation", "action"],
-                  description:
-                    "dictation = user wants text inserted/cleaned up for typing. action = user wants the assistant to perform a task (send a message, open an app, search, navigate, control something).",
-                },
-                text: {
-                  type: "string",
-                  description:
-                    "If dictation: the cleaned/formatted text ready for insertion. If action: the raw transcription unchanged.",
-                },
-                reasoning: {
-                  type: "string",
-                  description: "Brief reasoning for the classification",
-                },
-              },
-              required: ["mode", "text", "reasoning"],
-            },
-          },
-        ],
-        systemPrompt,
-        {
-          config: {
-            modelIntent: "latency-optimized",
-            max_tokens: maxTokens,
-            tool_choice: { type: "tool" as const, name: "process_dictation" },
-          },
-          signal,
-        },
-      );
-      cleanup();
-
-      const toolBlock = extractToolUse(response);
-      if (toolBlock) {
-        const input = toolBlock.input as {
-          mode?: string;
-          text?: string;
-          reasoning?: string;
-        };
-        const mode: DictationMode =
-          input.mode === "action" ? "action" : "dictation";
-        log.info(
-          { mode, reasoning: input.reasoning },
-          "LLM dictation classify+clean",
-        );
-
-        if (mode === "action") {
-          ctx.send({
-            type: "dictation_response",
-            text: msg.transcription,
-            mode: "action",
-            actionPlan: `User wants to: ${msg.transcription}`,
-            ...profileMeta,
-          });
-        } else {
-          const cleanedText = input.text?.trim() || transcription;
-          const normalizedText = applyDictionary(
-            cleanedText,
-            profile.dictionary,
-          );
-          ctx.send({
-            type: "dictation_response",
-            text: normalizedText,
-            mode: "dictation",
-            ...profileMeta,
-          });
-        }
-        return;
-      }
-
-      // No tool_use block — fall through to heuristic
-      log.warn("No tool_use block in combined dictation call, using heuristic");
-    } finally {
-      cleanup();
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.warn(
-      { err: message },
-      "Combined dictation LLM call failed, using heuristic",
-    );
-  }
-
-  // Heuristic fallback
-  const fallbackMode = detectDictationModeHeuristic(msg);
-  log.info({ mode: fallbackMode }, "Using heuristic fallback");
-  if (fallbackMode === "action") {
-    ctx.send({
-      type: "dictation_response",
-      text: msg.transcription,
-      mode: "action",
-      actionPlan: `User wants to: ${msg.transcription}`,
-      ...profileMeta,
-    });
-  } else {
-    const normalizedText = applyDictionary(transcription, profile.dictionary);
-    ctx.send({
-      type: "dictation_response",
-      text: normalizedText,
-      mode: fallbackMode,
-      ...profileMeta,
-    });
-  }
-}
-
-/** Handle command mode (selected text) — separate code path, latency-optimized. */
-async function handleCommandMode(
-  msg: DictationRequest,
-  ctx: HandlerContext,
-  profile: ReturnType<typeof resolveProfile>["profile"],
-  profileMeta: {
-    resolvedProfileId: string;
-    profileSource: ProfileResolution["source"];
-  },
-  stylePrompt: string | undefined,
-): Promise<void> {
-  const systemPrompt = buildCommandPrompt(msg, stylePrompt);
-  const inputLength =
-    (msg.context.selectedText ?? "").length + msg.transcription.length;
-  const maxTokens = Math.max(1024, computeMaxTokens(inputLength));
-
-  try {
-    const provider = getConfiguredProvider();
-    if (!provider) {
-      log.warn("Command mode: no provider available, returning selected text");
-      const normalizedText = applyDictionary(
-        msg.context.selectedText ?? msg.transcription,
-        profile.dictionary,
-      );
-      ctx.send({
-        type: "dictation_response",
-        text: normalizedText,
-        mode: "command",
-        ...profileMeta,
-      });
-      return;
-    }
-
-    const response = await provider.sendMessage(
-      [userMessage(msg.transcription)],
-      [], // no tools
-      systemPrompt,
-      { config: { modelIntent: "latency-optimized", max_tokens: maxTokens } },
-    );
-
-    const textBlock = response.content.find((b) => b.type === "text");
-    const cleanedText =
-      textBlock && "text" in textBlock
-        ? textBlock.text.trim()
-        : (msg.context.selectedText ?? msg.transcription);
-    const normalizedText = applyDictionary(cleanedText, profile.dictionary);
-    ctx.send({
-      type: "dictation_response",
-      text: normalizedText,
-      mode: "command",
-      ...profileMeta,
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, "Command mode LLM call failed, returning selected text");
-    const normalizedText = applyDictionary(
-      msg.context.selectedText ?? msg.transcription,
-      profile.dictionary,
-    );
-    ctx.send({
-      type: "dictation_response",
-      text: normalizedText,
-      mode: "command",
-      ...profileMeta,
-    });
-    ctx.send({
-      type: "error",
-      message: `Dictation cleanup failed: ${message}`,
-    });
-  }
-}

package/src/daemon/handlers/sessions.ts

@@ -2,7 +2,6 @@ import { v4 as uuid } from "uuid";
 
 import {
   type InterfaceId,
-  isChannelId,
   parseChannelId,
   parseInterfaceId,
 } from "../../channels/types.js";
@@ -12,25 +11,18 @@ import {
   generateCanonicalRequestCode,
   resolveCanonicalGuardianRequest,
 } from "../../memory/canonical-guardian-store.js";
-import { getAttentionStateByConversationIds } from "../../memory/conversation-attention-store.js";
 import {
   batchSetDisplayOrders,
   clearAll,
   createConversation,
   getConversation,
-  getDisplayMetaForConversations,
   updateConversationTitle,
 } from "../../memory/conversation-crud.js";
-import {
-  countConversations,
-  listConversations,
-} from "../../memory/conversation-queries.js";
 import {
   GENERATING_TITLE,
   queueGenerateConversationTitle,
   UNTITLED_FALLBACK,
 } from "../../memory/conversation-title-service.js";
-import * as externalConversationStore from "../../memory/external-conversation-store.js";
 import * as pendingInteractions from "../../runtime/pending-interactions.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { truncate } from "../../util/truncate.js";
@@ -38,7 +30,6 @@ import { HostBashProxy } from "../host-bash-proxy.js";
 import { HostCuProxy } from "../host-cu-proxy.js";
 import { HostFileProxy } from "../host-file-proxy.js";
 import type {
-  CancelRequest,
   ConfirmationResponse,
   DeleteQueuedMessage,
   RegenerateRequest,
@@ -63,23 +54,6 @@ import {
   pendingStandaloneSecrets,
 } from "./shared.js";
 
-/**
- * Extract a valid ChannelId from a binding's sourceChannel, which may carry a
- * `notification:` namespace prefix (e.g. `"notification:telegram"` -> `"telegram"`).
- * Returns the ChannelId if valid, or null otherwise.
- */
-function parseBindingSourceChannel(
-  sourceChannel: string,
-): import("../../channels/types.js").ChannelId | null {
-  if (isChannelId(sourceChannel)) return sourceChannel;
-  const NOTIFICATION_PREFIX = "notification:";
-  if (sourceChannel.startsWith(NOTIFICATION_PREFIX)) {
-    const inner = sourceChannel.slice(NOTIFICATION_PREFIX.length);
-    if (isChannelId(inner)) return inner;
-  }
-  return null;
-}
-
 export function syncCanonicalStatusFromConfirmationDecision(
   requestId: string,
   decision: ConfirmationResponse["decision"],
@@ -242,83 +216,6 @@ export function handleSecretResponse(
   );
 }
 
-export function handleSessionList(
-  ctx: HandlerContext,
-  offset = 0,
-  limit = 50,
-): void {
-  const conversations = listConversations(limit, false, offset);
-  const totalCount = countConversations();
-  const conversationIds = conversations.map((c) => c.id);
-  const bindings =
-    externalConversationStore.getBindingsForConversations(conversationIds);
-  const attentionStates = getAttentionStateByConversationIds(conversationIds);
-  const displayMetas = getDisplayMetaForConversations(conversationIds);
-  ctx.send({
-    type: "session_list_response",
-    sessions: conversations.map((c) => {
-      const binding = bindings.get(c.id);
-      const originChannel = parseChannelId(c.originChannel);
-      const originInterface = parseInterfaceId(c.originInterface);
-      const attn = attentionStates.get(c.id);
-      const displayMeta = displayMetas.get(c.id);
-      const assistantAttention = attn
-        ? {
-            hasUnseenLatestAssistantMessage:
-              attn.latestAssistantMessageAt != null &&
-              (attn.lastSeenAssistantMessageAt == null ||
-                attn.lastSeenAssistantMessageAt <
-                  attn.latestAssistantMessageAt),
-            ...(attn.latestAssistantMessageAt != null
-              ? { latestAssistantMessageAt: attn.latestAssistantMessageAt }
-              : {}),
-            ...(attn.lastSeenAssistantMessageAt != null
-              ? { lastSeenAssistantMessageAt: attn.lastSeenAssistantMessageAt }
-              : {}),
-            ...(attn.lastSeenConfidence != null
-              ? { lastSeenConfidence: attn.lastSeenConfidence }
-              : {}),
-            ...(attn.lastSeenSignalType != null
-              ? { lastSeenSignalType: attn.lastSeenSignalType }
-              : {}),
-          }
-        : undefined;
-      return {
-        id: c.id,
-        title: c.title ?? "Untitled",
-        createdAt: c.createdAt,
-        updatedAt: c.updatedAt,
-        threadType: normalizeThreadType(c.threadType),
-        source: c.source ?? "user",
-        ...(binding && parseBindingSourceChannel(binding.sourceChannel)
-          ? {
-              channelBinding: {
-                sourceChannel: parseBindingSourceChannel(
-                  binding.sourceChannel,
-                )!,
-                externalChatId: binding.externalChatId,
-                externalUserId: binding.externalUserId,
-                displayName: binding.displayName,
-                username: binding.username,
-              },
-            }
-          : {}),
-        ...(c.scheduleJobId ? { scheduleJobId: c.scheduleJobId } : {}),
-        ...(originChannel ? { conversationOriginChannel: originChannel } : {}),
-        ...(originInterface
-          ? { conversationOriginInterface: originInterface }
-          : {}),
-        ...(assistantAttention ? { assistantAttention } : {}),
-        ...(displayMeta?.displayOrder != null
-          ? { displayOrder: displayMeta.displayOrder }
-          : {}),
-        ...(displayMeta?.isPinned ? { isPinned: displayMeta.isPinned } : {}),
-      };
-    }),
-    hasMore: offset + conversations.length < totalCount,
-  });
-}
-
 /**
  * Clear all sessions and DB conversations. Returns the number of sessions cleared.
  */
@@ -332,11 +229,6 @@ export function clearAllSessions(ctx: HandlerContext): number {
   return cleared;
 }
 
-export function handleSessionsClear(ctx: HandlerContext): void {
-  const cleared = clearAllSessions(ctx);
-  ctx.send({ type: "sessions_clear_response", cleared });
-}
-
 export async function handleSessionCreate(
   msg: SessionCreateRequest,
   ctx: HandlerContext,
@@ -570,13 +462,6 @@ export function cancelGeneration(
   return true;
 }
 
-export function handleCancel(msg: CancelRequest, ctx: HandlerContext): void {
-  const sessionId = msg.sessionId;
-  if (sessionId) {
-    cancelGeneration(sessionId, ctx);
-  }
-}
-
 /**
  * Undo the last message in a session. Returns the removed count, or null if
  * the conversation does not exist. Restores evicted sessions from the database.
@@ -594,7 +479,10 @@ export async function undoLastMessage(
   return { removedCount };
 }
 
-export async function handleUndo(msg: UndoRequest, ctx: HandlerContext): Promise<void> {
+export async function handleUndo(
+  msg: UndoRequest,
+  ctx: HandlerContext,
+): Promise<void> {
   const result = await undoLastMessage(msg.sessionId, ctx);
   if (!result) {
     ctx.send({ type: "error", message: "No active session" });