@vellumai/assistant 0.4.3 → 0.4.4

package/src/daemon/session.ts

@@ -36,6 +36,7 @@ import type { Message } from '../providers/types.js';
 import type { Provider } from '../providers/types.js';
 import { ToolExecutor } from '../tools/executor.js';
 import type { AssistantAttachmentDraft } from './assistant-attachments.js';
+import type { AssistantActivityState, ConfirmationStateChanged } from './ipc-contract/messages.js';
 import type { ServerMessage, SurfaceData,SurfaceType, UsageStats, UserMessageAttachment } from './ipc-protocol.js';
 import {
   classifyResponseTierAsync,
@@ -146,7 +147,7 @@ export class Session {
   /** @internal */ commandIntent?: { type: string; payload?: string; languageCode?: string };
   /** @internal */ pendingSurfaceActions = new Map<string, { surfaceType: SurfaceType }>();
   /** @internal */ lastSurfaceAction = new Map<string, { actionId: string; data?: Record<string, unknown> }>();
-  /** @internal */ surfaceState = new Map<string, { surfaceType: SurfaceType; data: SurfaceData }>();
+  /** @internal */ surfaceState = new Map<string, { surfaceType: SurfaceType; data: SurfaceData; title?: string }>();
   /** @internal */ surfaceUndoStacks = new Map<string, string[]>();
   /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{ surfaceId: string; surfaceType: SurfaceType; title?: string; data: SurfaceData; actions?: Array<{ id: string; label: string; style?: string }>; display?: string }> = [];
@@ -161,6 +162,16 @@ export class Session {
   public lastAttachmentWarnings: string[] = [];
   /** @internal */ currentTurnChannelContext: TurnChannelContext | null = null;
   /** @internal */ currentTurnInterfaceContext: TurnInterfaceContext | null = null;
+  /** @internal */ activityVersion = 0;
+  /**
+   * Optional callback invoked whenever a server-authoritative state signal
+   * (confirmation_state_changed or assistant_activity_state) is emitted.
+   *
+   * HTTP/SSE sessions set this so the hub publisher receives these events —
+   * without it, the signals only travel through `sendToClient`, which is a
+   * no-op for socketless sessions.
+   */
+  private onStateSignal?: (msg: ServerMessage) => void;
 
   constructor(
     conversationId: string,
@@ -180,6 +191,22 @@ export class Session {
     this.memoryPolicy = memoryPolicy ? { ...memoryPolicy } : { ...DEFAULT_MEMORY_POLICY };
     this.traceEmitter = new TraceEmitter(conversationId, sendToClient);
     this.prompter = new PermissionPrompter(sendToClient);
+    this.prompter.setOnStateChanged((requestId, state, source) => {
+      // Route through emitConfirmationStateChanged so the onStateSignal
+      // listener publishes to the SSE hub for HTTP/SSE consumers.
+      this.emitConfirmationStateChanged({
+        sessionId: this.conversationId,
+        requestId,
+        state,
+        source,
+      });
+      // Emit activity state transitions for confirmation lifecycle
+      if (state === 'pending') {
+        this.emitActivityState('awaiting_confirmation', 'confirmation_requested', 'assistant_turn');
+      } else if (state === 'timed_out') {
+        this.emitActivityState('thinking', 'confirmation_resolved', 'assistant_turn');
+      }
+    });
     this.secretPrompter = new SecretPrompter(sendToClient);
 
     // Register watch/call notifiers (reads ctx properties lazily)
@@ -356,6 +383,17 @@ export class Session {
     return this.sendToClient;
   }
 
+  /**
+   * Register a callback for server-authoritative state signals
+   * (confirmation_state_changed, assistant_activity_state).
+   *
+   * This enables HTTP/SSE sessions to receive these events through the
+   * hub publisher, since `sendToClient` is a no-op for socketless sessions.
+   */
+  setStateSignalListener(listener: (msg: ServerMessage) => void): void {
+    this.onStateSignal = listener;
+  }
+
   setSandboxOverride(enabled: boolean | undefined): void {
     this.sandboxOverride = enabled;
   }
@@ -453,6 +491,11 @@ export class Session {
     selectedPattern?: string,
     selectedScope?: string,
     decisionContext?: string,
+    emissionContext?: {
+      source?: ConfirmationStateChanged['source'];
+      causedByRequestId?: string;
+      decisionText?: string;
+    },
   ): void {
     this.prompter.resolveConfirmation(
       requestId,
@@ -461,12 +504,56 @@ export class Session {
       selectedScope,
       decisionContext,
     );
+
+    // Emit authoritative confirmation state and activity transition centrally
+    // so ALL callers (IPC handlers, /v1/confirm, channel bridges) get
+    // consistent events without duplicating emission logic.
+    const resolvedState = (decision === 'deny' || decision === 'always_deny')
+      ? 'denied' as const
+      : 'approved' as const;
+    this.emitConfirmationStateChanged({
+      sessionId: this.conversationId,
+      requestId,
+      state: resolvedState,
+      source: emissionContext?.source ?? 'button',
+      ...(emissionContext?.causedByRequestId ? { causedByRequestId: emissionContext.causedByRequestId } : {}),
+      ...(emissionContext?.decisionText ? { decisionText: emissionContext.decisionText } : {}),
+    });
+    this.emitActivityState('thinking', 'confirmation_resolved', 'assistant_turn');
   }
 
   handleSecretResponse(requestId: string, value?: string, delivery?: 'store' | 'transient_send'): void {
     this.secretPrompter.resolveSecret(requestId, value, delivery);
   }
 
+  // ── Server-authoritative state signals ─────────────────────────────
+
+  emitConfirmationStateChanged(params: Omit<ConfirmationStateChanged, 'type'>): void {
+    const msg: ServerMessage = { type: 'confirmation_state_changed', ...params } as ServerMessage;
+    this.sendToClient(msg);
+    this.onStateSignal?.(msg);
+  }
+
+  emitActivityState(
+    phase: AssistantActivityState['phase'],
+    reason: AssistantActivityState['reason'],
+    anchor: AssistantActivityState['anchor'] = 'assistant_turn',
+    requestId?: string,
+  ): void {
+    this.activityVersion++;
+    const msg: ServerMessage = {
+      type: 'assistant_activity_state',
+      sessionId: this.conversationId,
+      activityVersion: this.activityVersion,
+      phase,
+      anchor,
+      requestId,
+      reason,
+    } as ServerMessage;
+    this.sendToClient(msg);
+    this.onStateSignal?.(msg);
+  }
+
   setChannelCapabilities(caps: ChannelCapabilities | null): void {
     this.channelCapabilities = caps ?? undefined;
   }

package/src/daemon/tool-side-effects.ts

@@ -68,6 +68,19 @@ function registerHook(toolNames: string | string[], hook: PostExecutionHook): vo
   }
 }
 
+// Broadcast app_files_changed when a new app is created so clients
+// (e.g. macOS "Things" sidebar) refresh their app list immediately.
+registerHook('app_create', (_name, _input, result, { ctx, broadcastToAllClients }) => {
+  try {
+    const parsed = JSON.parse(result.content) as { id?: string };
+    if (parsed.id) {
+      handleAppChange(ctx, parsed.id, broadcastToAllClients);
+    }
+  } catch {
+    // Result wasn't valid JSON — skip the broadcast.
+  }
+});
+
 // Auto-refresh workspace surfaces when a persisted app is updated.
 // If no surface is currently showing the app, auto-open it.
 registerHook('app_update', (_name, input, _result, { ctx, broadcastToAllClients }) => {
@@ -77,6 +90,15 @@ registerHook('app_update', (_name, input, _result, { ctx, broadcastToAllClients
   }
 });
 
+// Broadcast app_files_changed when an app is deleted so clients remove it
+// from their cached app lists.
+registerHook('app_delete', (_name, input, _result, { broadcastToAllClients }) => {
+  const appId = input.app_id as string | undefined;
+  if (appId) {
+    broadcastToAllClients?.({ type: 'app_files_changed', appId });
+  }
+});
+
 // Broadcast tasks_changed so connected clients (e.g. macOS Tasks window)
 // auto-refresh when the LLM mutates the task queue via tools
 registerHook(