@vellumai/assistant 0.4.2 → 0.4.4

package/src/daemon/session-surfaces.ts

@@ -25,6 +25,32 @@ const log = getLogger('session-surfaces');
 const MAX_UNDO_DEPTH = 10;
 const TASK_PROGRESS_TEMPLATE_FIELDS = ['title', 'status', 'steps'] as const;
 
+/**
+ * Migrate dynamic_page fields from the top-level tool input into `data`.
+ *
+ * The LLM sometimes sends `html`, `width`, `height`, or `preview` at the
+ * top level instead of nested inside `data`. Without this normalization the
+ * surface opens blank because `rawData` is `{}`.
+ */
+function normalizeDynamicPageShowData(input: Record<string, unknown>, rawData: Record<string, unknown>): DynamicPageSurfaceData {
+  const normalized: Record<string, unknown> = { ...rawData };
+
+  if (typeof normalized.html !== 'string' && typeof input.html === 'string') {
+    normalized.html = input.html;
+  }
+  if (normalized.width == null && input.width != null) {
+    normalized.width = input.width;
+  }
+  if (normalized.height == null && input.height != null) {
+    normalized.height = input.height;
+  }
+  if (!isPlainObject(normalized.preview) && isPlainObject(input.preview)) {
+    normalized.preview = input.preview;
+  }
+
+  return normalized as unknown as DynamicPageSurfaceData;
+}
+
 function normalizeCardShowData(input: Record<string, unknown>, rawData: Record<string, unknown>): CardSurfaceData {
   const normalized: Record<string, unknown> = { ...rawData };
 
@@ -105,7 +131,7 @@ export interface SurfaceSessionContext {
   sendToClient(msg: ServerMessage): void;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
   lastSurfaceAction: Map<string, { actionId: string; data?: Record<string, unknown> }>;
-  surfaceState: Map<string, { surfaceType: SurfaceType; data: SurfaceData }>;
+  surfaceState: Map<string, { surfaceType: SurfaceType; data: SurfaceData; title?: string }>;
   surfaceUndoStacks: Map<string, string[]>;
   currentTurnSurfaces: Array<{
     surfaceId: string;
@@ -592,7 +618,9 @@ export async function surfaceProxyResolver(
     const rawData = isPlainObject(input.data) ? input.data : {};
     const data = (surfaceType === 'card'
       ? normalizeCardShowData(input, rawData)
-      : rawData) as SurfaceData;
+      : surfaceType === 'dynamic_page'
+        ? normalizeDynamicPageShowData(input, rawData)
+        : rawData) as SurfaceData;
     const actions = input.actions as Array<{ id: string; label: string; style?: string }> | undefined;
     // Interactive surfaces default to awaiting user action.
     const hasActions = Array.isArray(actions) && actions.length > 0;
@@ -604,7 +632,7 @@ export async function surfaceProxyResolver(
     const awaitAction = (input.await_action as boolean) ?? isInteractive;
 
     // Track surface state for ui_update merging
-    ctx.surfaceState.set(surfaceId, { surfaceType, data });
+    ctx.surfaceState.set(surfaceId, { surfaceType, data, title });
 
     const display = (input.display as string) === 'panel' ? 'panel' : 'inline';
 
@@ -754,6 +782,7 @@ export async function surfaceProxyResolver(
     ctx.surfaceState.set(surfaceId, {
       surfaceType: 'dynamic_page',
       data: surfaceData,
+      title: app.name,
     });
 
     ctx.sendToClient({

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(