@vellumai/assistant 0.4.44 → 0.4.45

package/src/daemon/recording-executor.ts

@@ -1,180 +0,0 @@
-// Unified recording intent executor.
-// Bridges the gap between recording-intent.ts (classification) and
-// handlers/recording.ts (side effects), so both sessions.ts and misc.ts
-// can share the same execution logic without duplicating switch/case blocks.
-
-import {
-  handleRecordingPause,
-  handleRecordingRestart,
-  handleRecordingResume,
-  handleRecordingStart,
-  handleRecordingStop,
-  isRecordingIdle,
-} from "./handlers/recording.js";
-import type { HandlerContext } from "./handlers/shared.js";
-import type { RecordingIntentResult } from "./recording-intent.js";
-
-export interface RecordingExecutionContext {
-  conversationId: string;
-  ctx: HandlerContext;
-}
-
-export interface RecordingExecutionOutput {
-  /** If true, the intent was fully handled (start_only / stop_only) -- handler should send completion and return */
-  handled: boolean;
-  /** Human-readable response text for the user */
-  responseText?: string;
-  /** For _with_remainder: the remaining text after stripping recording clauses */
-  remainderText?: string;
-  /** Whether a recording start should be/was initiated */
-  pendingStart?: boolean;
-  /** Whether a recording stop should be/was initiated */
-  pendingStop?: boolean;
-  /** Whether a restart is pending (for restart_with_remainder) */
-  pendingRestart?: boolean;
-  /** Whether handleRecordingStart succeeded (true) or was rejected (false). Only set for start_only / start_and_stop_only. */
-  recordingStarted?: boolean;
-}
-
-export function executeRecordingIntent(
-  result: RecordingIntentResult,
-  context: RecordingExecutionContext,
-): RecordingExecutionOutput {
-  switch (result.kind) {
-    case "none":
-      return { handled: false };
-
-    case "start_only": {
-      const recordingId = handleRecordingStart(
-        context.conversationId,
-        { promptForSource: true },
-        context.ctx,
-      );
-      return {
-        handled: true,
-        recordingStarted: !!recordingId,
-        responseText: recordingId
-          ? "Starting screen recording."
-          : "A recording is already active.",
-      };
-    }
-
-    case "stop_only": {
-      const stopped =
-        handleRecordingStop(context.conversationId, context.ctx) !== undefined;
-      return {
-        handled: true,
-        responseText: stopped
-          ? "Stopping the recording."
-          : "No active recording to stop.",
-      };
-    }
-
-    case "start_with_remainder":
-      return {
-        handled: false,
-        remainderText: result.remainder,
-        pendingStart: true,
-      };
-
-    case "stop_with_remainder":
-      return {
-        handled: false,
-        remainderText: result.remainder,
-        pendingStop: true,
-      };
-
-    case "start_and_stop_only": {
-      // Route through handleRecordingRestart which properly cleans up maps
-      // between stop and start, preventing the "already active" guard from
-      // blocking the new recording.
-      const restartResult = handleRecordingRestart(
-        context.conversationId,
-        context.ctx,
-      );
-
-      // When there was no active recording to restart, fall back to a plain
-      // start — the user said "stop and start" but nothing was recording, so
-      // the stop is a no-op and we just start a new recording.
-      // Only fall back for this specific reason; "restart_in_progress" should
-      // not start a duplicate recording.
-      if (
-        !restartResult.initiated &&
-        restartResult.reason === "no_active_recording"
-      ) {
-        const recordingId = handleRecordingStart(
-          context.conversationId,
-          { promptForSource: true },
-          context.ctx,
-        );
-        return {
-          handled: true,
-          recordingStarted: !!recordingId,
-          responseText: recordingId
-            ? "Starting screen recording."
-            : "A recording is already active.",
-        };
-      }
-
-      return {
-        handled: true,
-        recordingStarted: restartResult.initiated,
-        responseText: restartResult.initiated
-          ? "Stopping current recording and starting a new one."
-          : restartResult.responseText,
-      };
-    }
-
-    case "start_and_stop_with_remainder":
-      // When there's no active recording, fall back to a plain start rather
-      // than a restart — the stop is a no-op and we just need to start.
-      return {
-        handled: false,
-        remainderText: result.remainder,
-        ...(isRecordingIdle()
-          ? { pendingStart: true }
-          : { pendingRestart: true }),
-      };
-
-    case "restart_only": {
-      const restartResult = handleRecordingRestart(
-        context.conversationId,
-        context.ctx,
-      );
-      return {
-        handled: true,
-        responseText: restartResult.responseText,
-      };
-    }
-
-    case "restart_with_remainder":
-      return {
-        handled: false,
-        remainderText: result.remainder,
-        pendingRestart: true,
-      };
-
-    case "pause_only": {
-      const paused =
-        handleRecordingPause(context.conversationId, context.ctx) !== undefined;
-      return {
-        handled: true,
-        responseText: paused
-          ? "Pausing the recording."
-          : "No active recording to pause.",
-      };
-    }
-
-    case "resume_only": {
-      const resumed =
-        handleRecordingResume(context.conversationId, context.ctx) !==
-        undefined;
-      return {
-        handled: true,
-        responseText: resumed
-          ? "Resuming the recording."
-          : "No active recording to resume.",
-      };
-    }
-  }
-}

package/src/daemon/recording-intent-fallback.ts

@@ -1,162 +0,0 @@
-// LLM-based fallback classifier for recording intent detection.
-// Fires only when the deterministic resolver returns `none` but the text
-// contains recording-related keywords that suggest an intent the regex missed.
-// Safety: returns `{ action: 'none', confidence: 'low' }` on any failure —
-// never triggers a recording action on error.
-
-import {
-  createTimeout,
-  extractText,
-  getConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("recording-intent-fallback");
-
-const FALLBACK_TIMEOUT_MS = 5000;
-
-export type RecordingFallbackAction =
-  | "start"
-  | "stop"
-  | "restart"
-  | "pause"
-  | "resume"
-  | "none";
-
-export interface RecordingFallbackResult {
-  action: RecordingFallbackAction;
-  confidence: "high" | "medium" | "low";
-}
-
-const SAFE_DEFAULT: RecordingFallbackResult = {
-  action: "none",
-  confidence: "low",
-};
-
-/** Keywords that gate whether we spend an LLM call on fallback classification. */
-const RECORDING_KEYWORDS = [
-  "record",
-  "recording",
-  "screen capture",
-  "screencast",
-  "capture screen",
-  "capture my screen",
-  "screen rec",
-];
-
-const SYSTEM_PROMPT =
-  "You are classifying user messages for a screen recording assistant. " +
-  "Determine if the user wants to: start a recording, stop a recording, restart a recording, " +
-  "pause a recording, resume a recording, or none of these. " +
-  "Only classify as an action if the user is giving an imperative command. " +
-  'Questions about recording (e.g., "how do I record?", "what does recording do?") should be classified as "none". ' +
-  'Respond with a JSON object: {"action": "start|stop|restart|pause|resume|none", "confidence": "high|medium|low"}';
-
-const VALID_ACTIONS = new Set<RecordingFallbackAction>([
-  "start",
-  "stop",
-  "restart",
-  "pause",
-  "resume",
-  "none",
-]);
-const VALID_CONFIDENCES = new Set<string>(["high", "medium", "low"]);
-
-/**
- * Returns true if the text contains any recording-related keywords,
- * indicating it is worth spending an LLM call on fallback classification.
- */
-export function containsRecordingKeywords(text: string): boolean {
-  const lower = text.toLowerCase();
-  return RECORDING_KEYWORDS.some((kw) => lower.includes(kw));
-}
-
-/**
- * Uses a lightweight LLM call to classify whether text contains a recording intent
- * that the deterministic resolver missed.
- *
- * Returns `{ action: 'none', confidence: 'high' }` for informational questions.
- * Only returns an actionable result with 'high' confidence for clear imperative commands.
- */
-export async function classifyRecordingIntentFallback(
-  text: string,
-): Promise<RecordingFallbackResult> {
-  const provider = getConfiguredProvider();
-  if (!provider) {
-    log.debug("No configured provider available for fallback classification");
-    return SAFE_DEFAULT;
-  }
-
-  try {
-    const { signal, cleanup } = createTimeout(FALLBACK_TIMEOUT_MS);
-    try {
-      const response = await provider.sendMessage(
-        [userMessage(text)],
-        [], // no tools
-        SYSTEM_PROMPT,
-        {
-          config: {
-            modelIntent: "latency-optimized",
-            max_tokens: 64,
-          },
-          signal,
-        },
-      );
-      cleanup();
-
-      const raw = extractText(response);
-      return parseClassificationResponse(raw);
-    } finally {
-      cleanup();
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.warn({ err: message }, "LLM fallback classification failed");
-    return SAFE_DEFAULT;
-  }
-}
-
-/**
- * Parse the LLM's JSON response into a validated RecordingFallbackResult.
- * Returns safe default on any parse/validation failure.
- */
-function parseClassificationResponse(raw: string): RecordingFallbackResult {
-  try {
-    // Extract JSON from the response — the LLM may include surrounding text
-    const jsonMatch = raw.match(/\{[^}]*\}/);
-    if (!jsonMatch) {
-      log.debug({ raw }, "No JSON object found in LLM fallback response");
-      return SAFE_DEFAULT;
-    }
-
-    const parsed = JSON.parse(jsonMatch[0]) as {
-      action?: string;
-      confidence?: string;
-    };
-
-    const action = parsed.action as RecordingFallbackAction | undefined;
-    const confidence = parsed.confidence;
-
-    if (!action || !VALID_ACTIONS.has(action)) {
-      log.debug({ raw, action }, "Invalid action in LLM fallback response");
-      return SAFE_DEFAULT;
-    }
-
-    if (!confidence || !VALID_CONFIDENCES.has(confidence)) {
-      log.debug(
-        { raw, confidence },
-        "Invalid confidence in LLM fallback response",
-      );
-      return SAFE_DEFAULT;
-    }
-
-    return {
-      action,
-      confidence: confidence as RecordingFallbackResult["confidence"],
-    };
-  } catch (err) {
-    log.debug({ err, raw }, "Failed to parse LLM fallback response as JSON");
-    return SAFE_DEFAULT;
-  }
-}