@vellumai/assistant 0.6.6 → 0.7.1

package/src/daemon/handlers/recording.ts

@@ -3,13 +3,12 @@ import * as path from "node:path";
 
 import { v4 as uuid } from "uuid";
 
-import {
-  attachFileBackedAttachmentToMessage,
-} from "../../memory/attachments-store.js";
+import { attachFileBackedAttachmentToMessage } from "../../memory/attachments-store.js";
 import { addMessage, getConversation } from "../../memory/conversation-crud.js";
 import { syncMessageToDisk } from "../../memory/conversation-disk-view.js";
+import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import type { RecordingOptions, RecordingStatus } from "../message-protocol.js";
-import { type HandlerContext, log } from "./shared.js";
+import { log } from "./shared.js";
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 
@@ -79,7 +78,6 @@ const deferredRestartByConversation = new Map<string, DeferredRestartParams>();
 export function handleRecordingStart(
   conversationId: string,
   options: RecordingOptions | undefined,
-  ctx: HandlerContext,
   operationToken?: string,
 ): string | null {
   const existingRecordingId = recordingOwnerByConversation.get(conversationId);
@@ -112,7 +110,7 @@ export function handleRecordingStart(
   standaloneRecordingConversationId.set(recordingId, conversationId);
   recordingOwnerByConversation.set(conversationId, recordingId);
 
-  ctx.broadcast({
+  broadcastMessage({
     type: "recording_start",
     recordingId,
     attachToConversationId: conversationId,
@@ -141,7 +139,6 @@ export function handleRecordingStart(
  */
 export function handleRecordingStop(
   conversationId: string,
-  ctx: HandlerContext,
 ): string | undefined {
   let recordingId = recordingOwnerByConversation.get(conversationId);
   let ownerConversationId = conversationId;
@@ -165,7 +162,7 @@ export function handleRecordingStop(
     return undefined;
   }
 
-  ctx.broadcast({
+  broadcastMessage({
     type: "recording_stop",
     recordingId,
   });
@@ -204,116 +201,6 @@ export function handleRecordingStop(
   return recordingId;
 }
 
-// ─── Restart ─────────────────────────────────────────────────────────────────
-
-export interface RecordingRestartResult {
-  /** Whether the restart was initiated. false if no recording was active to stop. */
-  initiated: boolean;
-  /** The operation token threaded through the stop+start cycle. */
-  operationToken?: string;
-  /** Response text for the user. */
-  responseText: string;
-  /** When initiated is false, explains why the restart could not proceed. */
-  reason?: "no_active_recording" | "restart_in_progress";
-}
-
-/**
- * Restart the active recording: stop the current one, then defer starting a
- * new one until the client acknowledges the stop via a 'stopped' status
- * callback.
- *
- * This prevents a race condition where the macOS client processes
- * recording_stop asynchronously — if recording_start arrives before the
- * async stop completes, RecordingManager.start() rejects because state is
- * still active.
- *
- * Uses an operation token to guard against stale async completions from
- * a previous restart cycle. The token is:
- * 1. Generated here and stored as `activeRestartToken`
- * 2. Stored in `deferredRestartByConversation` for later use
- * 3. Threaded through to the new `recording_start` message when the stop ack arrives
- * 4. Validated when `recording_status` callbacks arrive
- *
- * If the stop fails or times out, the deferred restart state is cleaned up.
- */
-export function handleRecordingRestart(
-  conversationId: string,
-  ctx: HandlerContext,
-): RecordingRestartResult {
-  // Generate a restart operation token for race hardening
-  const operationToken = uuid();
-
-  // Stop current recording (if any)
-  const stoppedRecordingId = handleRecordingStop(conversationId, ctx);
-
-  if (!stoppedRecordingId) {
-    // No active recording — check if mid-restart (state is not truly idle)
-    if (pendingRestartByConversation.has(conversationId)) {
-      log.info(
-        { conversationId },
-        "Restart requested while another restart is pending",
-      );
-      return {
-        initiated: false,
-        reason: "restart_in_progress",
-        responseText: "A restart is already in progress.",
-      };
-    }
-
-    log.info(
-      { conversationId },
-      "Restart requested but no active recording to stop",
-    );
-    return {
-      initiated: false,
-      reason: "no_active_recording",
-      responseText: "No active recording to restart.",
-    };
-  }
-
-  // Resolve the actual owner conversation ID. When conversation B requests
-  // a restart but the recording is owned by conversation A (cross-conversation
-  // restart via global fallback), the deferred restart must be keyed by A's
-  // conversationId because the stopped callback resolves the conversationId
-  // from standaloneRecordingConversationId (which maps to A, the owner).
-  // This lookup must happen BEFORE cleanupMaps removes the entry.
-  const ownerConversationId =
-    standaloneRecordingConversationId.get(stoppedRecordingId) ?? conversationId;
-  if (ownerConversationId !== conversationId) {
-    log.info(
-      { conversationId, ownerConversationId, stoppedRecordingId },
-      "Cross-conversation restart: keying deferred restart by owner conversation",
-    );
-  }
-
-  // Atomically set the restart token and pending state so that:
-  // 1. Stale completions from a previous cycle are rejected
-  // 2. "no active recording" checks know we're mid-restart
-  activeRestartToken = operationToken;
-  pendingRestartByConversation.set(ownerConversationId, operationToken);
-
-  // Store the deferred restart parameters. The actual recording_start will
-  // be sent when the 'stopped' status callback arrives in handleRecordingStatus,
-  // ensuring the client has fully completed the async stop before we start.
-  // Keyed by ownerConversationId so the stopped handler (which resolves
-  // conversationId from the recording's owner) can find this entry.
-  deferredRestartByConversation.set(ownerConversationId, {
-    conversationId,
-    operationToken,
-  });
-
-  log.info(
-    { conversationId, ownerConversationId, operationToken, stoppedRecordingId },
-    "Recording restart initiated — start deferred until stop-ack",
-  );
-
-  return {
-    initiated: true,
-    operationToken,
-    responseText: "Restarting screen recording.",
-  };
-}
-
 // ─── Pause ───────────────────────────────────────────────────────────────────
 
 /**
@@ -325,7 +212,6 @@ export function handleRecordingRestart(
  */
 export function handleRecordingPause(
   conversationId: string,
-  ctx: HandlerContext,
 ): string | undefined {
   let recordingId = recordingOwnerByConversation.get(conversationId);
 
@@ -342,7 +228,7 @@ export function handleRecordingPause(
     return undefined;
   }
 
-  ctx.broadcast({
+  broadcastMessage({
     type: "recording_pause",
     recordingId,
   });
@@ -362,7 +248,6 @@ export function handleRecordingPause(
  */
 export function handleRecordingResume(
   conversationId: string,
-  ctx: HandlerContext,
 ): string | undefined {
   let recordingId = recordingOwnerByConversation.get(conversationId);
 
@@ -379,7 +264,7 @@ export function handleRecordingResume(
     return undefined;
   }
 
-  ctx.broadcast({
+  broadcastMessage({
     type: "recording_resume",
     recordingId,
   });
@@ -443,14 +328,13 @@ function cleanupMaps(
  * Includes an idempotency guard so the same recording cannot be finalized
  * twice (prevents double-finalization during restart races).
  */
-export async function finalizeAndPublishRecording(params: {
+async function finalizeAndPublishRecording(params: {
   recordingId: string;
   conversationId: string;
   filePath?: string;
   durationMs?: number;
-  ctx: HandlerContext;
 }): Promise<{ success: boolean; messageId?: string }> {
-  const { recordingId, conversationId, filePath, ctx } = params;
+  const { recordingId, conversationId, filePath } = params;
 
   // Idempotency guard: prevent double-finalization.
   // Mark as finalized eagerly (before any async work) so concurrent calls
@@ -484,12 +368,12 @@ export async function finalizeAndPublishRecording(params: {
         "Failed to persist recording error message",
       );
     }
-    ctx.broadcast({
+    broadcastMessage({
       type: "assistant_text_delta",
       text: errorText,
       conversationId: conversationId,
     });
-    ctx.broadcast({
+    broadcastMessage({
       type: "message_complete",
       conversationId: conversationId,
     });
@@ -537,12 +421,12 @@ export async function finalizeAndPublishRecording(params: {
         "Failed to persist recording error message",
       );
     }
-    ctx.broadcast({
+    broadcastMessage({
       type: "assistant_text_delta",
       text: errorText,
       conversationId: conversationId,
     });
-    ctx.broadcast({
+    broadcastMessage({
       type: "message_complete",
       conversationId: conversationId,
     });
@@ -565,12 +449,12 @@ export async function finalizeAndPublishRecording(params: {
           "Failed to persist recording error message",
         );
       }
-      ctx.broadcast({
+      broadcastMessage({
         type: "assistant_text_delta",
         text: errorText,
         conversationId: conversationId,
       });
-      ctx.broadcast({
+      broadcastMessage({
         type: "message_complete",
         conversationId: conversationId,
       });
@@ -598,12 +482,12 @@ export async function finalizeAndPublishRecording(params: {
           "Failed to persist recording error message",
         );
       }
-      ctx.broadcast({
+      broadcastMessage({
         type: "assistant_text_delta",
         text: errorText,
         conversationId: conversationId,
       });
-      ctx.broadcast({
+      broadcastMessage({
         type: "message_complete",
         conversationId: conversationId,
       });
@@ -665,12 +549,12 @@ export async function finalizeAndPublishRecording(params: {
     const thumbnailData: string | undefined = undefined;
 
     // Notify the client via broadcast
-    ctx.broadcast({
+    broadcastMessage({
       type: "assistant_text_delta",
       text: msgText,
       conversationId: conversationId,
     });
-    ctx.broadcast({
+    broadcastMessage({
       type: "message_complete",
       conversationId: conversationId,
       attachments: [
@@ -705,12 +589,12 @@ export async function finalizeAndPublishRecording(params: {
         "Failed to persist recording error message",
       );
     }
-    ctx.broadcast({
+    broadcastMessage({
       type: "assistant_text_delta",
       text: errorText,
       conversationId: conversationId,
     });
-    ctx.broadcast({
+    broadcastMessage({
       type: "message_complete",
       conversationId: conversationId,
     });
@@ -730,7 +614,6 @@ export async function finalizeAndPublishRecording(params: {
  */
 export async function handleRecordingStatusCore(
   msg: RecordingStatus,
-  ctx: HandlerContext,
 ): Promise<void> {
   const recordingId = msg.conversationId;
   let conversationId = standaloneRecordingConversationId.get(recordingId);
@@ -830,12 +713,12 @@ export async function handleRecordingStatusCore(
         activeRestartToken = null;
       }
 
-      ctx.broadcast({
+      broadcastMessage({
         type: "assistant_text_delta",
         text: "Recording restart cancelled.",
         conversationId: conversationId,
       });
-      ctx.broadcast({
+      broadcastMessage({
         type: "message_complete",
         conversationId: conversationId,
       });
@@ -884,7 +767,6 @@ export async function handleRecordingStatusCore(
         const newRecordingId = handleRecordingStart(
           deferred.conversationId,
           { promptForSource: true },
-          ctx,
           deferred.operationToken,
         );
 
@@ -955,19 +837,18 @@ export async function handleRecordingStatusCore(
           conversationId,
           filePath: msg.filePath,
           durationMs: msg.durationMs,
-          ctx,
         });
 
         // Handle old-success + new-start-failure: the old recording saved
         // but the new one couldn't start. Send explicit follow-up text so
         // the user knows the state.
         if (!newRecordingId && finResult.success) {
-          ctx.broadcast({
+          broadcastMessage({
             type: "assistant_text_delta",
             text: "Previous recording saved. New recording failed to start.",
             conversationId: deferred.conversationId,
           });
-          ctx.broadcast({
+          broadcastMessage({
             type: "message_complete",
             conversationId: deferred.conversationId,
           });
@@ -984,7 +865,6 @@ export async function handleRecordingStatusCore(
         conversationId,
         filePath: msg.filePath,
         durationMs: msg.durationMs,
-        ctx,
       });
 
       break;
@@ -996,12 +876,12 @@ export async function handleRecordingStatusCore(
         "Standalone recording failed",
       );
 
-      ctx.broadcast({
+      broadcastMessage({
         type: "assistant_text_delta",
         text: `Recording failed: ${msg.error ?? "unknown error"}`,
         conversationId: conversationId,
       });
-      ctx.broadcast({
+      broadcastMessage({
         type: "message_complete",
         conversationId: conversationId,
       });
@@ -1025,18 +905,6 @@ export async function handleRecordingStatusCore(
 
 // ─── Test helpers ────────────────────────────────────────────────────────────
 
-/**
- * Inject a recording owner entry. Only for use in tests.
- * This allows tests to simulate a second active recording that blocks
- * handleRecordingStart's global single-active guard.
- */
-export function __injectRecordingOwner(
-  conversationId: string,
-  recordingId: string,
-): void {
-  recordingOwnerByConversation.set(conversationId, recordingId);
-}
-
 /** Reset module-level state. Only for use in tests. */
 export function __resetRecordingState(): void {
   for (const handle of pendingStopTimeouts.values()) {

package/src/daemon/handlers/shared.ts

@@ -2,19 +2,14 @@ import { v4 as uuid } from "uuid";
 
 import { getConfig } from "../../config/loader.js";
 import type { LLMCallSite, Speed } from "../../config/schemas/llm.js";
-import type { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
 import type { SecretPromptResult } from "../../permissions/secret-prompter.js";
 import { isPlaceholderSentinelText } from "../../providers/anthropic/client.js";
+import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../../runtime/auth/types.js";
-import type { DebouncerMap } from "../../util/debounce.js";
 import { getLogger } from "../../util/logger.js";
 import { estimateBase64Bytes } from "../assistant-attachments.js";
-import { Conversation } from "../conversation.js";
-import type { TrustContext } from "../conversation-runtime-assembly.js";
-import type {
-  ConversationTransportMetadata,
-  ServerMessage,
-} from "../message-protocol.js";
+import type { ConversationTransportMetadata } from "../message-protocol.js";
+import type { TrustContext } from "../trust-context.js";
 
 const log = getLogger("handlers");
 
@@ -26,7 +21,7 @@ export const CONFIG_RELOAD_DEBOUNCE_MS = 300;
 const HISTORY_ATTACHMENT_TEXT_LIMIT = 500;
 
 // Module-level map for non-conversation secret prompts (e.g. publish_page)
-export const pendingStandaloneSecrets = new Map<
+const pendingStandaloneSecrets = new Map<
   string,
   {
     resolve: (result: SecretPromptResult) => void;
@@ -34,28 +29,6 @@ export const pendingStandaloneSecrets = new Map<
   }
 >();
 
-// Pending signing responses (bundle signing orchestration), keyed by unique requestId
-interface PendingSigningResolve {
-  resolve: (result: {
-    signature: string;
-    keyId: string;
-    publicKey: string;
-  }) => void;
-  reject: (err: Error) => void;
-  timer: ReturnType<typeof setTimeout>;
-}
-export const pendingSignBundlePayload = new Map<
-  string,
-  PendingSigningResolve
->();
-
-interface PendingIdentityResolve {
-  resolve: (result: { keyId: string; publicKey: string }) => void;
-  reject: (err: Error) => void;
-  timer: ReturnType<typeof setTimeout>;
-}
-export const pendingSigningIdentity = new Map<string, PendingIdentityResolve>();
-
 export interface HistoryToolCall {
   name: string;
   input: Record<string, unknown>;
@@ -73,6 +46,20 @@ export interface HistoryToolCall {
   confirmationDecision?: string;
   /** Friendly label for the confirmation (e.g. "Edit File", "Run Command"). */
   confirmationLabel?: string;
+  /** Risk level classification at invocation time ("low" | "medium" | "high" | "unknown"). */
+  riskLevel?: string;
+  /** Human-readable reason for the risk classification. */
+  riskReason?: string;
+  /** ID of the trust rule that matched this invocation (if any). */
+  matchedTrustRuleId?: string;
+  /** Whether the tool was auto-approved (true) or required explicit user input (false). */
+  autoApproved?: boolean;
+  /** How the approval decision was reached: prompted, auto, blocked, or unknown (legacy). */
+  approvalMode?: string;
+  /** Why the approval decision was reached (stable enum for client display). */
+  approvalReason?: string;
+  /** Snapshot of the auto-approve threshold at execution time. */
+  riskThreshold?: string;
 }
 
 export interface HistorySurface {
@@ -137,13 +124,12 @@ export interface ConversationCreateOptions {
   authContext?: AuthContext;
   /** Whether this turn can block on interactive approval prompts. */
   isInteractive?: boolean;
+  /** Slack-only non-persisted notice injected into the active model turn. */
+  slackRuntimeContextNotice?: string;
   memoryScopeId?: string;
-  isPrivateConversation?: boolean;
-  strictPrivateSideEffects?: boolean;
   /** Channel command intent metadata (e.g. Telegram /start). */
   commandIntent?: { type: string; payload?: string; languageCode?: string };
-  /** Optional callback to receive real-time agent loop events (text deltas, tool starts, etc.). */
-  onEvent?: (msg: ServerMessage) => void;
+
   /**
    * Optional explicit model override (provider/model string) for this
    * conversation's agent loop. Used by the auto-analyze loop to pin the
@@ -166,35 +152,11 @@ export interface ConversationCreateOptions {
   slackInbound?: SlackInboundMessageMetadata;
 }
 
-/**
- * Shared context that handlers need from the DaemonServer.
- * Keeps handlers decoupled from the server class itself.
- */
-export interface HandlerContext {
-  conversations: Map<string, Conversation>;
-  sharedRequestTimestamps: number[];
-  debounceTimers: DebouncerMap;
-  suppressConfigReload: boolean;
-  setSuppressConfigReload(value: boolean): void;
-  updateConfigFingerprint(): void;
-  send(msg: ServerMessage): void;
-  broadcast(msg: ServerMessage): void;
-  clearAllConversations(): number;
-  getOrCreateConversation(
-    conversationId: string,
-    options?: ConversationCreateOptions,
-  ): Promise<Conversation>;
-  /** Refresh the eviction timestamp for a conversation that was accessed directly. */
-  touchConversation(conversationId: string): void;
-  /** Optional heartbeat service reference for "Run Now" support. */
-  heartbeatService?: HeartbeatService;
-}
-
-export function isRecord(value: unknown): value is Record<string, unknown> {
+function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value != null;
 }
 
-export function formatBytes(sizeBytes: number): string {
+function formatBytes(sizeBytes: number): string {
   if (sizeBytes < 1024) return `${sizeBytes} B`;
   const kb = sizeBytes / 1024;
   if (kb < 1024) return `${kb.toFixed(1)} KB`;
@@ -390,6 +352,20 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
         entry.confirmationDecision = block._confirmationDecision;
       if (typeof block._confirmationLabel === "string")
         entry.confirmationLabel = block._confirmationLabel;
+      if (typeof block._riskLevel === "string")
+        entry.riskLevel = block._riskLevel;
+      if (typeof block._riskReason === "string")
+        entry.riskReason = block._riskReason;
+      if (typeof block._matchedTrustRuleId === "string")
+        entry.matchedTrustRuleId = block._matchedTrustRuleId;
+      if (typeof block._autoApproved === "boolean")
+        entry.autoApproved = block._autoApproved;
+      if (typeof block._approvalMode === "string")
+        entry.approvalMode = block._approvalMode;
+      if (typeof block._approvalReason === "string")
+        entry.approvalReason = block._approvalReason;
+      if (typeof block._riskThreshold === "string")
+        entry.riskThreshold = block._riskThreshold;
       toolCalls.push(entry);
       if (id) pendingToolUses.set(id, entry);
       contentOrder.push(`tool:${toolCalls.length - 1}`);
@@ -533,21 +509,19 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
 
 /**
  * Send a `secret_request` to the client and wait for the response,
- * outside of a conversation context (e.g. from handler-level code like publish_page).
+ * outside of a conversation context (e.g. from IPC routes like
+ * credentials/prompt).
  */
-export function requestSecretStandalone(
-  ctx: HandlerContext,
-  params: {
-    service: string;
-    field: string;
-    label: string;
-    description?: string;
-    placeholder?: string;
-    purpose?: string;
-    allowedTools?: string[];
-    allowedDomains?: string[];
-  },
-): Promise<SecretPromptResult> {
+export function requestSecretStandalone(params: {
+  service: string;
+  field: string;
+  label: string;
+  description?: string;
+  placeholder?: string;
+  purpose?: string;
+  allowedTools?: string[];
+  allowedDomains?: string[];
+}): Promise<SecretPromptResult> {
   const requestId = uuid();
   const config = getConfig();
   return new Promise((resolve) => {
@@ -556,7 +530,7 @@ export function requestSecretStandalone(
       resolve({ value: null, delivery: "store" });
     }, config.timeouts.permissionTimeoutSec * 1000);
     pendingStandaloneSecrets.set(requestId, { resolve, timer });
-    ctx.send({
+    broadcastMessage({
       type: "secret_request",
       requestId,
       service: params.service,
@@ -572,29 +546,6 @@ export function requestSecretStandalone(
   });
 }
 
-const SIGNING_TIMEOUT_MS = 30_000;
-
-/**
- * Create a SigningCallback that sends `sign_bundle_payload` to the Swift client
- * over HTTP and waits for the `sign_bundle_payload_response`.
- */
-export function createSigningCallback(
-  ctx: HandlerContext,
-): (
-  payload: string,
-) => Promise<{ signature: string; keyId: string; publicKey: string }> {
-  return (payload: string) =>
-    new Promise((resolve, reject) => {
-      const requestId = uuid();
-      const timer = setTimeout(() => {
-        pendingSignBundlePayload.delete(requestId);
-        reject(new Error("Signing request timed out"));
-      }, SIGNING_TIMEOUT_MS);
-      pendingSignBundlePayload.set(requestId, { resolve, reject, timer });
-      ctx.send({ type: "sign_bundle_payload", requestId, payload });
-    });
-}
-
 /** Get or create the skill entry object for a given skill name, creating intermediate objects as needed.
  *  Guards against malformed config (e.g. skills or entries being a string, array, or null)
  *  by resetting non-object intermediates to {}, restoring self-healing behavior. */