vellum 0.2.1 → 0.2.7

package/src/daemon/session-surfaces.ts

@@ -4,6 +4,7 @@ import type {
   ServerMessage,
   SurfaceType,
   SurfaceData,
+  CardSurfaceData,
   DynamicPageSurfaceData,
   FileUploadSurfaceData,
   UiSurfaceShow,
@@ -20,6 +21,74 @@ import {
 const log = getLogger('session-surfaces');
 
 const MAX_UNDO_DEPTH = 10;
+const TASK_PROGRESS_TEMPLATE_FIELDS = ['title', 'status', 'steps'] as const;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function normalizeCardShowData(input: Record<string, unknown>, rawData: Record<string, unknown>): CardSurfaceData {
+  const normalized: Record<string, unknown> = { ...rawData };
+
+  // Older prompt examples sent template/templateData at the top level.
+  if (typeof normalized.template !== 'string' && typeof input.template === 'string') {
+    normalized.template = input.template;
+  }
+  if (!isPlainObject(normalized.templateData) && isPlainObject(input.templateData)) {
+    normalized.templateData = input.templateData;
+  }
+
+  // task_progress cards need a title for Swift parsing; fall back when missing.
+  if (normalized.template === 'task_progress' && typeof normalized.title !== 'string') {
+    if (typeof input.title === 'string' && input.title.trim().length > 0) {
+      normalized.title = input.title;
+    } else if (isPlainObject(normalized.templateData) && typeof normalized.templateData.title === 'string') {
+      normalized.title = normalized.templateData.title;
+    } else {
+      normalized.title = 'Task Progress';
+    }
+  }
+
+  if (normalized.template === 'task_progress' && typeof normalized.body !== 'string') {
+    normalized.body = '';
+  }
+
+  return normalized as unknown as CardSurfaceData;
+}
+
+function normalizeTaskProgressCardPatch(existingCard: CardSurfaceData, patch: Record<string, unknown>): Record<string, unknown> {
+  if (existingCard.template !== 'task_progress') {
+    return patch;
+  }
+
+  const normalizedPatch: Record<string, unknown> = { ...patch };
+  const mergedTemplateData: Record<string, unknown> = isPlainObject(existingCard.templateData)
+    ? { ...existingCard.templateData }
+    : {};
+
+  let updatedTemplateData = false;
+
+  if (isPlainObject(normalizedPatch.templateData)) {
+    Object.assign(mergedTemplateData, normalizedPatch.templateData);
+    updatedTemplateData = true;
+  }
+
+  // Accept top-level task_progress fields from older prompt examples and
+  // move them into templateData where the Swift client expects them.
+  for (const key of TASK_PROGRESS_TEMPLATE_FIELDS) {
+    if (key in normalizedPatch) {
+      mergedTemplateData[key] = normalizedPatch[key];
+      delete normalizedPatch[key];
+      updatedTemplateData = true;
+    }
+  }
+
+  if (updatedTemplateData) {
+    normalizedPatch.templateData = mergedTemplateData;
+  }
+
+  return normalizedPatch;
+}
 
 /**
  * Subset of Session state that surface helpers need access to.
@@ -447,7 +516,10 @@ export async function surfaceProxyResolver(
     const surfaceId = uuid();
     const surfaceType = input.surface_type as SurfaceType;
     const title = typeof input.title === 'string' ? input.title : undefined;
-    const data = input.data as SurfaceData;
+    const rawData = isPlainObject(input.data) ? input.data : {};
+    const data = (surfaceType === 'card'
+      ? normalizeCardShowData(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;
@@ -502,12 +574,15 @@ export async function surfaceProxyResolver(
 
   if (toolName === 'ui_update') {
     const surfaceId = input.surface_id as string;
-    const patch = input.data as Record<string, unknown>;
+    let patch = (isPlainObject(input.data) ? input.data : {}) as Record<string, unknown>;
 
     // Merge the partial patch into the stored full surface data
     const stored = ctx.surfaceState.get(surfaceId);
     let mergedData: SurfaceData;
     if (stored) {
+      if (stored.surfaceType === 'card') {
+        patch = normalizeTaskProgressCardPatch(stored.data as CardSurfaceData, patch);
+      }
       // Push current HTML to undo stack for dynamic pages
       if (stored.surfaceType === 'dynamic_page') {
         const currentHtml = (stored.data as DynamicPageSurfaceData).html;

package/src/daemon/session-tool-setup.ts

@@ -6,7 +6,7 @@
  * keeping the constructor body focused on wiring.
  */
 
-import type { ToolDefinition } from '../providers/types.js';
+import type { Message, ToolDefinition } from '../providers/types.js';
 import type { ToolExecutionResult, ToolLifecycleEventHandler } from '../tools/types.js';
 import type { ServerMessage, UiSurfaceShow } from './ipc-protocol.js';
 import type { ToolExecutor } from '../tools/executor.js';
@@ -26,6 +26,7 @@ import type { SurfaceSessionContext } from './session-surfaces.js';
 import { updatePublishedAppDeployment } from '../services/published-app-updater.js';
 import { registerSessionSender } from '../tools/browser/browser-screencast.js';
 import type { ProxyApprovalCallback, ProxyApprovalRequest } from '../tools/network/script-proxy/index.js';
+import { projectSkillTools, type SkillProjectionCache } from './session-skill-tools.js';
 
 // ── Context Interface ────────────────────────────────────────────────
 
@@ -46,6 +47,10 @@ export interface ToolSetupContext extends SurfaceSessionContext {
   memoryPolicy: { scopeId: string; strictSideEffects: boolean };
   /** True when the session has no connected IPC client (HTTP-only path). */
   hasNoClient?: boolean;
+  /** When true, the session is executing a task run and must not become interactive. */
+  headlessLock?: boolean;
+  /** When set, this session is executing a task run. Used to retrieve ephemeral permission rules. */
+  taskRunId?: string;
 }
 
 // ── buildToolDefinitions ─────────────────────────────────────────────
@@ -65,6 +70,59 @@ export function buildToolDefinitions(): ToolDefinition[] {
   ];
 }
 
+// ── DoorDash task_progress auto-update ────────────────────────────────
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+interface DoordashStep { label: string; status: string; detail?: string }
+
+/**
+ * Map a `vellum doordash <subcommand>` to the step label it corresponds to.
+ */
+function doordashCommandToStep(cmd: string): string | null {
+  if (/vellum doordash status\b/.test(cmd) || /vellum doordash refresh\b/.test(cmd) || /vellum doordash login\b/.test(cmd)) return 'Check session';
+  if (/vellum doordash search\b/.test(cmd) || /vellum doordash search-items\b/.test(cmd)) return 'Search restaurants';
+  if (/vellum doordash menu\b/.test(cmd) || /vellum doordash item\b/.test(cmd) || /vellum doordash store-search\b/.test(cmd)) return 'Browse menu';
+  if (/vellum doordash cart\b/.test(cmd)) return 'Add to cart';
+  if (/vellum doordash checkout\b/.test(cmd) || /vellum doordash payment-methods\b/.test(cmd)) return 'Add to cart';
+  if (/vellum doordash order\b/.test(cmd)) return 'Place order';
+  return null;
+}
+
+/**
+ * Given a completed DoorDash CLI command, return updated steps array or null if no change.
+ */
+function updateDoordashSteps(cmd: string, steps: DoordashStep[], isError: boolean): DoordashStep[] | null {
+  const stepLabel = doordashCommandToStep(cmd);
+  if (!stepLabel) return null;
+
+  const stepIndex = steps.findIndex(s => s.label === stepLabel);
+  if (stepIndex < 0) return null;
+
+  const updated = steps.map((s, i) => {
+    if (i < stepIndex) {
+      // Steps before current should be completed
+      return s.status === 'completed' ? s : { ...s, status: 'completed' };
+    }
+    if (i === stepIndex) {
+      if (isError) {
+        // If the command failed, mark as in_progress still (will retry)
+        return { ...s, status: 'in_progress' };
+      }
+      return { ...s, status: 'completed' };
+    }
+    if (i === stepIndex + 1 && !isError) {
+      // Next step becomes waiting (user may need to respond before it starts)
+      return { ...s, status: 'waiting' };
+    }
+    return s;
+  });
+
+  return updated;
+}
+
 // ── createToolExecutor ───────────────────────────────────────────────
 
 /**
@@ -85,11 +143,47 @@ export function createToolExecutor(
   registerSessionSender(ctx.conversationId, (msg) => ctx.sendToClient(msg));
 
   return async (name: string, input: Record<string, unknown>, onOutput?: (chunk: string) => void) => {
+    // Pre-execution: mark the current DoorDash step as in_progress when command starts
+    if (name === 'bash' || name === 'host_bash') {
+      const preCmd = input.command as string | undefined;
+      if (preCmd?.includes('vellum doordash')) {
+        const surfaceId = 'doordash-progress';
+        const stored = ctx.surfaceState.get(surfaceId);
+        if (stored && stored.surfaceType === 'card') {
+          const card = stored.data as import('./ipc-contract.js').CardSurfaceData;
+          if (card.template === 'task_progress' && isPlainObject(card.templateData)) {
+            const steps = (card.templateData as Record<string, unknown>).steps;
+            if (Array.isArray(steps)) {
+              const stepLabel = doordashCommandToStep(preCmd);
+              if (stepLabel) {
+                const stepIndex = (steps as DoordashStep[]).findIndex(s => s.label === stepLabel);
+                if (stepIndex >= 0 && (steps as DoordashStep[])[stepIndex].status !== 'in_progress') {
+                  const updatedSteps = (steps as DoordashStep[]).map((s, i) =>
+                    i === stepIndex ? { ...s, status: 'in_progress' } : s
+                  );
+                  const updatedTemplateData = { ...card.templateData as Record<string, unknown>, steps: updatedSteps };
+                  const updatedData = { ...card, templateData: updatedTemplateData };
+                  stored.data = updatedData as import('./ipc-contract.js').CardSurfaceData;
+                  ctx.sendToClient({
+                    type: 'ui_surface_update',
+                    sessionId: ctx.conversationId,
+                    surfaceId,
+                    data: updatedData,
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
     const result = await executor.execute(name, input, {
       workingDir: ctx.workingDir,
       sessionId: ctx.conversationId,
       conversationId: ctx.conversationId,
       requestId: ctx.currentRequestId,
+      taskRunId: ctx.taskRunId,
       onOutput,
       signal: ctx.abortController?.signal,
       sandboxOverride: ctx.sandboxOverride,
@@ -114,7 +208,7 @@ export function createToolExecutor(
           });
         }
       },
-      isInteractive: !ctx.hasNoClient,
+      isInteractive: !ctx.hasNoClient && !ctx.headlessLock,
       proxyToolResolver: (toolName: string, proxyInput: Record<string, unknown>) => surfaceProxyResolver(ctx, toolName, proxyInput),
       proxyApprovalCallback: createProxyApprovalCallback(prompter, ctx),
       requestSecret: async (params) => {
@@ -198,6 +292,74 @@ export function createToolExecutor(
       }
     }
 
+    // Auto-emit task_progress card on first DoorDash CLI command
+    if (name === 'bash' || name === 'host_bash') {
+      const cmd = input.command as string | undefined;
+      if (cmd?.includes('vellum doordash')) {
+        const surfaceId = 'doordash-progress';
+
+        if (!ctx.surfaceState.has(surfaceId)) {
+          // First DoorDash command — auto-emit the task_progress card
+          const data = {
+            title: 'Ordering from DoorDash',
+            body: '',
+            template: 'task_progress' as const,
+            templateData: {
+              title: 'Ordering from DoorDash',
+              status: 'in_progress',
+              steps: [
+                { label: 'Check session', status: 'in_progress' },
+                { label: 'Search restaurants', status: 'pending' },
+                { label: 'Browse menu', status: 'pending' },
+                { label: 'Add to cart', status: 'pending' },
+                { label: 'Place order', status: 'pending' },
+              ],
+            },
+          } satisfies import('./ipc-contract.js').CardSurfaceData;
+          ctx.surfaceState.set(surfaceId, { surfaceType: 'card', data });
+          ctx.sendToClient({
+            type: 'ui_surface_show',
+            sessionId: ctx.conversationId,
+            surfaceId,
+            surfaceType: 'card',
+            title: 'Ordering from DoorDash',
+            data,
+            display: 'inline',
+          });
+          ctx.currentTurnSurfaces.push({
+            surfaceId,
+            surfaceType: 'card',
+            title: 'Ordering from DoorDash',
+            data,
+            display: 'inline',
+          });
+        }
+
+        // Auto-update step statuses based on the command that just ran
+        const stored = ctx.surfaceState.get(surfaceId);
+        if (stored && stored.surfaceType === 'card') {
+          const card = stored.data as import('./ipc-contract.js').CardSurfaceData;
+          if (card.template === 'task_progress' && isPlainObject(card.templateData)) {
+            const steps = (card.templateData as Record<string, unknown>).steps;
+            if (Array.isArray(steps)) {
+              const updatedSteps = updateDoordashSteps(cmd, steps as Array<{ label: string; status: string; detail?: string }>, result.isError);
+              if (updatedSteps) {
+                const updatedTemplateData = { ...card.templateData as Record<string, unknown>, steps: updatedSteps };
+                const updatedData = { ...card, templateData: updatedTemplateData };
+                stored.data = updatedData as import('./ipc-contract.js').CardSurfaceData;
+                ctx.sendToClient({
+                  type: 'ui_surface_update',
+                  sessionId: ctx.conversationId,
+                  surfaceId,
+                  data: updatedData,
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+
     return result;
   };
 }
@@ -290,3 +452,55 @@ export function createProxyApprovalCallback(
       || response.decision === 'always_allow_high_risk';
   };
 }
+
+// ── createResolveToolsCallback ───────────────────────────────────────
+
+/**
+ * Bundled skills that must always be active regardless of conversation
+ * history or explicit preactivation. Without this, their tools are
+ * unavailable in fresh sessions until `skill_load` is called.
+ */
+const DEFAULT_PREACTIVATED_SKILL_IDS = ['tasks'];
+
+/**
+ * Subset of Session state that the resolveTools callback reads at each
+ * agent turn. Properties are read lazily from this reference.
+ */
+export interface SkillProjectionContext {
+  preactivatedSkillIds?: string[];
+  readonly skillProjectionState: Map<string, string>;
+  readonly skillProjectionCache: SkillProjectionCache;
+  readonly coreToolNames: Set<string>;
+  allowedToolNames?: Set<string>;
+}
+
+/**
+ * Build a resolveTools callback that merges base tool definitions with
+ * dynamically projected skill tools on each agent turn. Also updates
+ * allowedToolNames so newly-activated skill tools aren't blocked by
+ * the executor's stale gate.
+ */
+export function createResolveToolsCallback(
+  toolDefs: ToolDefinition[],
+  ctx: SkillProjectionContext,
+): ((history: Message[]) => ToolDefinition[]) | undefined {
+  if (toolDefs.length === 0) return undefined;
+
+  return (history: Message[]) => {
+    const effectivePreactivated = [
+      ...DEFAULT_PREACTIVATED_SKILL_IDS,
+      ...(ctx.preactivatedSkillIds ?? []),
+    ];
+    const projection = projectSkillTools(history, {
+      preactivatedSkillIds: effectivePreactivated,
+      previouslyActiveSkillIds: ctx.skillProjectionState,
+      cache: ctx.skillProjectionCache,
+    });
+    const turnAllowed = new Set(ctx.coreToolNames);
+    for (const name of projection.allowedToolNames) {
+      turnAllowed.add(name);
+    }
+    ctx.allowedToolNames = turnAllowed;
+    return [...toolDefs, ...projection.toolDefinitions];
+  };
+}

package/src/daemon/session-usage.ts

@@ -11,7 +11,6 @@ const log = getLogger('session-usage');
 export interface UsageContext {
   conversationId: string;
   providerName: string;
-  assistantId: string | null;
   usageStats: UsageStats;
 }
 
@@ -60,7 +59,6 @@ export function recordUsage(
         outputTokens,
         cacheCreationInputTokens: null,
         cacheReadInputTokens: null,
-        assistantId: ctx.assistantId,
         conversationId: ctx.conversationId,
         runId: null,
         requestId,