vellum 0.2.1 → 0.2.2

package/src/daemon/session-attachments.ts

@@ -3,7 +3,8 @@ import type { UserMessageAttachment } from './ipc-protocol.js';
 import { check, classifyRisk, generateAllowlistOptions, generateScopeOptions } from '../permissions/checker.js';
 import { addRule } from '../permissions/trust-store.js';
 import type { PermissionPrompter } from '../permissions/prompter.js';
-import { uploadAttachment, linkAttachmentToMessage, AttachmentUploadError } from '../memory/attachments-store.js';
+import { uploadAttachment, linkAttachmentToMessage, setAttachmentThumbnail, AttachmentUploadError } from '../memory/attachments-store.js';
+import { generateVideoThumbnail } from './video-thumbnail.js';
 import {
   resolveDirectives,
   contentBlocksToDrafts,
@@ -92,7 +93,6 @@ export async function resolveAssistantAttachments(
   workingDir: string,
   approveHostRead: ApproveHostRead,
   lastAssistantMessageId: string | undefined,
-  assistantScope: string,
 ): Promise<AttachmentResolutionResult> {
   let assistantAttachments: AssistantAttachmentDraft[] = [];
   const emittedAttachments: UserMessageAttachment[] = [];
@@ -131,14 +131,17 @@ export async function resolveAssistantAttachments(
     log.info('No directives or tool content blocks to resolve');
   }
 
-  // Persist resolved attachments and link to the last assistant message
+  // Persist resolved attachments and link to the last assistant message.
+  // Large video attachments are omitted from the IPC payload and lazy-loaded
+  // by the client via the HTTP endpoint (same pattern as history_response).
+  const MAX_INLINE_B64_SIZE = 512 * 1024;
+
   if (assistantAttachments.length > 0 && lastAssistantMessageId) {
     for (let i = 0; i < assistantAttachments.length; i++) {
       const draft = assistantAttachments[i];
       let stored;
       try {
         stored = uploadAttachment(
-          assistantScope,
           draft.filename,
           draft.mimeType,
           draft.dataBase64,
@@ -152,11 +155,31 @@ export async function resolveAssistantAttachments(
         throw err;
       }
       linkAttachmentToMessage(lastAssistantMessageId, stored.id, i);
+      const isVideo = draft.mimeType.startsWith('video/');
+      const omitData = isVideo && draft.dataBase64.length > MAX_INLINE_B64_SIZE;
+
+      // Generate and persist a thumbnail for video attachments.
+      let thumbnailData: string | undefined;
+      if (isVideo) {
+        const existing = stored.thumbnailBase64;
+        if (existing) {
+          thumbnailData = existing;
+        } else {
+          const generated = await generateVideoThumbnail(draft.dataBase64);
+          if (generated) {
+            setAttachmentThumbnail(stored.id, generated);
+            thumbnailData = generated;
+          }
+        }
+      }
+
       emittedAttachments.push({
         id: stored.id,
         filename: draft.filename,
         mimeType: draft.mimeType,
-        data: draft.dataBase64,
+        data: omitData ? '' : draft.dataBase64,
+        ...(omitData ? { sizeBytes: draft.sizeBytes } : {}),
+        ...(thumbnailData ? { thumbnailData } : {}),
       });
     }
   } else if (assistantAttachments.length > 0) {

package/src/daemon/session-error.ts

@@ -41,7 +41,16 @@ const CONTEXT_TOO_LARGE_PATTERNS = [
   /prompt.?is.?too.?long/i,
   /request too large/i,
   /too many.*input.*tokens/i,
-  /max_tokens/i,
+  /max_tokens.*exceeded/i,
+  /exceeded.*max_tokens/i,
+];
+
+// Generic timeout patterns — checked after NETWORK_PATTERNS and PROVIDER_API_PATTERNS
+// so that "connection timeout" → PROVIDER_NETWORK and "gateway timeout" → PROVIDER_API
+const TIMEOUT_PATTERNS = [
+  /\btimeout\b/i,
+  /deadline.?exceeded/i,
+  /request.?timed?.?out/i,
 ];
 
 // Provider API error patterns (5xx, server error, etc.)
@@ -210,7 +219,7 @@ function classifyByMessage(message: string): Omit<ClassifiedSessionError, 'debug
     }
   }
 
-  // Network errors
+  // Network errors (before timeout so "connection timeout" is classified as network)
   for (const pattern of NETWORK_PATTERNS) {
     if (pattern.test(message)) {
       return {
@@ -221,7 +230,7 @@ function classifyByMessage(message: string): Omit<ClassifiedSessionError, 'debug
     }
   }
 
-  // Provider API errors (5xx)
+  // Provider API errors (before timeout so "gateway timeout" keeps its specific message)
   for (const pattern of PROVIDER_API_PATTERNS) {
     if (pattern.test(message)) {
       return {
@@ -232,6 +241,18 @@ function classifyByMessage(message: string): Omit<ClassifiedSessionError, 'debug
     }
   }
 
+  // Generic timeout errors (checked after network and provider API patterns so
+  // specific timeouts like "connection timeout" and "gateway timeout" aren't misclassified)
+  for (const pattern of TIMEOUT_PATTERNS) {
+    if (pattern.test(message)) {
+      return {
+        code: 'PROVIDER_API',
+        userMessage: 'The request took too long. This is usually temporary — try again shortly.',
+        retryable: true,
+      };
+    }
+  }
+
   // Non-user abort/failure (e.g. AbortError from internal logic, not user cancel)
   for (const pattern of CANCEL_PATTERNS) {
     if (pattern.test(message)) {

package/src/daemon/session-lifecycle.ts

@@ -0,0 +1,147 @@
+/**
+ * Session lifecycle methods extracted from Session: loadFromDb, abort,
+ * and dispose. Each operates on a context interface so the Session class
+ * can delegate without exposing its full surface.
+ */
+
+import type { Message, ContentBlock } from '../providers/types.js';
+import type { UsageStats, SurfaceType, SurfaceData } from './ipc-protocol.js';
+import { repairHistory } from './history-repair.js';
+import { createContextSummaryMessage } from '../context/window-manager.js';
+import * as conversationStore from '../memory/conversation-store.js';
+import type { PermissionPrompter } from '../permissions/prompter.js';
+import type { SecretPrompter } from '../permissions/secret-prompter.js';
+import type { ToolProfiler } from '../events/tool-profiling-listener.js';
+import type { EventBus } from '../events/bus.js';
+import type { AssistantDomainEvents } from '../events/domain-events.js';
+import type { MessageQueue } from './session-queue-manager.js';
+import { getHookManager } from '../hooks/manager.js';
+import { getLogger } from '../util/logger.js';
+import { unregisterWatchNotifiers, unregisterCallNotifiers } from './session-notifiers.js';
+import { unregisterSessionSender } from '../tools/browser/browser-screencast.js';
+import { resetSkillToolProjection } from './session-skill-tools.js';
+
+const log = getLogger('session-lifecycle');
+
+// ── Context Interfaces ───────────────────────────────────────────────
+
+export interface LoadFromDbContext {
+  readonly conversationId: string;
+  messages: Message[];
+  usageStats: UsageStats;
+  contextCompactedMessageCount: number;
+  contextCompactedAt: number | null;
+}
+
+export interface AbortContext {
+  readonly conversationId: string;
+  processing: boolean;
+  abortController: AbortController | null;
+  prompter: PermissionPrompter;
+  secretPrompter: SecretPrompter;
+  pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
+  surfaceState: Map<string, { surfaceType: SurfaceType; data: SurfaceData }>;
+  readonly queue: MessageQueue;
+}
+
+export interface DisposeContext extends AbortContext {
+  eventBus: EventBus<AssistantDomainEvents>;
+  readonly skillProjectionState: Map<string, string>;
+  profiler: ToolProfiler;
+  messages: Message[];
+  surfaceUndoStacks: Map<string, string[]>;
+  currentTurnSurfaces: Array<unknown>;
+  lastSurfaceAction: Map<string, unknown>;
+  workspaceTopLevelContext: string | null;
+  abort(): void;
+}
+
+// ── loadFromDb ───────────────────────────────────────────────────────
+
+export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
+  const dbMessages = conversationStore.getMessages(ctx.conversationId);
+
+  const conv = conversationStore.getConversation(ctx.conversationId);
+  const contextSummary = conv?.contextSummary?.trim() || null;
+  ctx.contextCompactedMessageCount = Math.max(
+    0,
+    Math.min(conv?.contextCompactedMessageCount ?? 0, dbMessages.length),
+  );
+  ctx.contextCompactedAt = conv?.contextCompactedAt ?? null;
+
+  const parsedMessages: Message[] = dbMessages
+    .slice(ctx.contextCompactedMessageCount)
+    .map((m) => {
+      const role = m.role as 'user' | 'assistant';
+      let content: ContentBlock[];
+      try {
+        const parsed = JSON.parse(m.content);
+        content = Array.isArray(parsed) ? parsed : [{ type: 'text', text: m.content }];
+      } catch {
+        log.warn({ conversationId: ctx.conversationId, messageId: m.id }, 'Invalid JSON in persisted message content, replacing with safe text block');
+        content = [{ type: 'text', text: m.content }];
+      }
+      return { role, content };
+    });
+
+  const { messages: repairedMessages, stats } = repairHistory(parsedMessages);
+  if (stats.assistantToolResultsMigrated > 0 || stats.missingToolResultsInserted > 0 || stats.orphanToolResultsDowngraded > 0 || stats.consecutiveSameRoleMerged > 0) {
+    log.warn({ conversationId: ctx.conversationId, phase: 'load', ...stats }, 'Repaired persisted history');
+  }
+  ctx.messages = repairedMessages;
+
+  if (contextSummary) {
+    ctx.messages.unshift(createContextSummaryMessage(contextSummary));
+  }
+
+  if (conv) {
+    ctx.usageStats = {
+      inputTokens: conv.totalInputTokens,
+      outputTokens: conv.totalOutputTokens,
+      estimatedCost: conv.totalEstimatedCost,
+    };
+  }
+
+  log.info({ conversationId: ctx.conversationId, count: ctx.messages.length }, 'Loaded messages from DB');
+}
+
+// ── abort ─────────────────────────────────────────────────────────────
+
+export function abortSession(ctx: AbortContext): void {
+  if (ctx.processing) {
+    log.info({ conversationId: ctx.conversationId }, 'Aborting in-flight processing');
+    ctx.abortController?.abort();
+    ctx.prompter.dispose();
+    ctx.secretPrompter.dispose();
+    ctx.pendingSurfaceActions.clear();
+    ctx.surfaceState.clear();
+    unregisterWatchNotifiers(ctx.conversationId);
+    for (const queued of ctx.queue) {
+      queued.onEvent({ type: 'generation_cancelled', sessionId: ctx.conversationId });
+    }
+    ctx.queue.clear();
+  }
+}
+
+// ── dispose ──────────────────────────────────────────────────────────
+
+export function disposeSession(ctx: DisposeContext): void {
+  void getHookManager().trigger('session-end', {
+    sessionId: ctx.conversationId,
+  });
+  ctx.abort();
+  unregisterCallNotifiers(ctx.conversationId);
+  unregisterSessionSender(ctx.conversationId);
+  resetSkillToolProjection(ctx.skillProjectionState);
+  ctx.eventBus.dispose();
+
+  // Release heavy in-memory data so GC can reclaim it
+  ctx.messages = [];
+  ctx.profiler.clear();
+  ctx.surfaceUndoStacks.clear();
+  ctx.currentTurnSurfaces = [];
+  ctx.pendingSurfaceActions.clear();
+  ctx.surfaceState.clear();
+  ctx.lastSurfaceAction.clear();
+  ctx.workspaceTopLevelContext = null;
+}

package/src/daemon/session-media-retry.ts

@@ -0,0 +1,147 @@
+/**
+ * Media payload trimming for context-too-large retry scenarios.
+ *
+ * When the provider rejects a request because the context is too large,
+ * this module replaces older image and file content blocks with lightweight
+ * text stubs to shrink the payload before retrying.
+ */
+
+import type { Message, ContentBlock } from '../providers/types.js';
+import { getSummaryFromContextMessage } from '../context/window-manager.js';
+
+const RETRY_KEEP_LATEST_MEDIA_BLOCKS = 3;
+const MAX_MEDIA_STUB_TEXT = 2_000;
+
+export function stripMediaPayloadsForRetry(messages: Message[]): { messages: Message[]; modified: boolean; replacedBlocks: number; latestUserIndex: number | null } {
+  let latestUserIndex: number | null = null;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== 'user') continue;
+    if (getSummaryFromContextMessage(msg) !== null) continue;
+    if (isToolResultOnlyMessage(msg)) continue;
+    latestUserIndex = i;
+    break;
+  }
+
+  let modified = false;
+  let replacedBlocks = 0;
+  let keptLatestMediaBlocks = 0;
+
+  const nextMessages = messages.map((msg, msgIndex) => {
+    const nextContent: ContentBlock[] = [];
+    for (const block of msg.content) {
+      if (block.type === 'image') {
+        const keep = latestUserIndex === msgIndex && keptLatestMediaBlocks < RETRY_KEEP_LATEST_MEDIA_BLOCKS;
+        if (keep) {
+          keptLatestMediaBlocks += 1;
+          nextContent.push(block);
+        } else {
+          replacedBlocks += 1;
+          modified = true;
+          nextContent.push(imageBlockToStub(block));
+        }
+        continue;
+      }
+
+      if (block.type === 'file') {
+        const keep = latestUserIndex === msgIndex && keptLatestMediaBlocks < RETRY_KEEP_LATEST_MEDIA_BLOCKS;
+        if (keep) {
+          keptLatestMediaBlocks += 1;
+          nextContent.push(block);
+        } else {
+          replacedBlocks += 1;
+          modified = true;
+          nextContent.push(fileBlockToStub(block));
+        }
+        continue;
+      }
+
+      if (block.type === 'tool_result' && block.contentBlocks && block.contentBlocks.length > 0) {
+        let toolResultChanged = false;
+        const nextToolContentBlocks: ContentBlock[] = block.contentBlocks.map((cb) => {
+          if (cb.type === 'image') {
+            replacedBlocks += 1;
+            modified = true;
+            toolResultChanged = true;
+            return imageBlockToStub(cb);
+          }
+          if (cb.type === 'file') {
+            replacedBlocks += 1;
+            modified = true;
+            toolResultChanged = true;
+            return fileBlockToStub(cb);
+          }
+          return cb;
+        });
+        if (toolResultChanged) {
+          nextContent.push({ ...block, contentBlocks: nextToolContentBlocks });
+        } else {
+          nextContent.push(block);
+        }
+        continue;
+      }
+
+      nextContent.push(block);
+    }
+    return { ...msg, content: nextContent };
+  });
+
+  return {
+    messages: modified ? nextMessages : messages,
+    modified,
+    replacedBlocks,
+    latestUserIndex,
+  };
+}
+
+function imageBlockToStub(block: Extract<ContentBlock, { type: 'image' }>): Extract<ContentBlock, { type: 'text' }> {
+  const sizeBytes = Math.ceil(block.source.data.length / 4) * 3;
+  return {
+    type: 'text',
+    text: `[Image omitted from retry context: ${block.source.media_type}, ${sizeBytes} bytes]`,
+  };
+}
+
+function fileBlockToStub(block: Extract<ContentBlock, { type: 'file' }>): Extract<ContentBlock, { type: 'text' }> {
+  const sizeBytes = Math.ceil(block.source.data.length / 4) * 3;
+  const extracted = (block.extracted_text ?? '').trim();
+  const preview = extracted.length > MAX_MEDIA_STUB_TEXT
+    ? `${extracted.slice(0, MAX_MEDIA_STUB_TEXT)}...`
+    : extracted;
+  return {
+    type: 'text',
+    text: preview.length > 0
+      ? `[File omitted from retry context: ${block.source.filename} (${block.source.media_type}, ${sizeBytes} bytes)]\n${preview}`
+      : `[File omitted from retry context: ${block.source.filename} (${block.source.media_type}, ${sizeBytes} bytes)]`,
+  };
+}
+
+function isToolResultOnlyMessage(message: Message): boolean {
+  return message.content.length > 0
+    && message.content.every((block) => block.type === 'tool_result');
+}
+
+/**
+ * Race a promise against a timeout. Returns 'completed' if the promise
+ * resolves/rejects within the budget, or 'timed_out' if the timeout fires
+ * first. The timer is always cleared in `finally` to prevent handle leaks.
+ */
+export async function raceWithTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+): Promise<'completed' | 'timed_out'> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const result = await Promise.race([
+      promise.then(() => 'completed' as const, () => 'completed' as const),
+      new Promise<'timed_out'>((resolve) => {
+        timer = setTimeout(() => resolve('timed_out'), timeoutMs);
+      }),
+    ]);
+    return result;
+  } finally {
+    if (timer !== undefined) {
+      clearTimeout(timer);
+    }
+  }
+}

package/src/daemon/session-messaging.ts

@@ -0,0 +1,145 @@
+/**
+ * Session messaging methods: enqueue, persistUserMessage,
+ * redirectToSecurePrompt, and queue/confirmation helpers.
+ *
+ * Extracted from Session to keep the class focused on coordination.
+ */
+
+import { v4 as uuid } from 'uuid';
+import type { Message } from '../providers/types.js';
+import type { ServerMessage, UserMessageAttachment } from './ipc-protocol.js';
+import { createUserMessage } from '../agent/message-types.js';
+import * as conversationStore from '../memory/conversation-store.js';
+import type { SecretPrompter } from '../permissions/secret-prompter.js';
+import type { MessageQueue } from './session-queue-manager.js';
+import { getLogger } from '../util/logger.js';
+
+const log = getLogger('session-messaging');
+
+// ── Context Interface ────────────────────────────────────────────────
+
+export interface MessagingSessionContext {
+  readonly conversationId: string;
+  messages: Message[];
+  processing: boolean;
+  abortController: AbortController | null;
+  currentRequestId?: string;
+  readonly queue: MessageQueue;
+}
+
+// ── enqueueMessage ───────────────────────────────────────────────────
+
+export function enqueueMessage(
+  ctx: MessagingSessionContext,
+  content: string,
+  attachments: UserMessageAttachment[],
+  onEvent: (msg: ServerMessage) => void,
+  requestId: string,
+  activeSurfaceId?: string,
+  currentPage?: string,
+  metadata?: Record<string, unknown>,
+): { queued: boolean; rejected?: boolean; requestId: string } {
+  if (!ctx.processing) {
+    return { queued: false, requestId };
+  }
+
+  const pushed = ctx.queue.push({ content, attachments, requestId, onEvent, activeSurfaceId, currentPage, metadata });
+  if (!pushed) {
+    return { queued: false, rejected: true, requestId };
+  }
+  return { queued: true, requestId };
+}
+
+// ── persistUserMessage ───────────────────────────────────────────────
+
+export function persistUserMessage(
+  ctx: MessagingSessionContext,
+  content: string,
+  attachments: UserMessageAttachment[],
+  requestId?: string,
+  metadata?: Record<string, unknown>,
+): string {
+  if (ctx.processing) {
+    throw new Error('Session is already processing a message');
+  }
+
+  if (!content.trim() && attachments.length === 0) {
+    throw new Error('Message content or attachments are required');
+  }
+
+  const reqId = requestId ?? uuid();
+  ctx.currentRequestId = reqId;
+  ctx.processing = true;
+  ctx.abortController = new AbortController();
+
+  const userMessage = createUserMessage(content, attachments.map((attachment) => ({
+    id: attachment.id,
+    filename: attachment.filename,
+    mimeType: attachment.mimeType,
+    data: attachment.data,
+    extractedText: attachment.extractedText,
+  })));
+  ctx.messages.push(userMessage);
+
+  try {
+    const persistedUserMessage = conversationStore.addMessage(
+      ctx.conversationId,
+      'user',
+      JSON.stringify(userMessage.content),
+      metadata,
+    );
+
+    if (!persistedUserMessage.id) {
+      throw new Error('Failed to persist user message');
+    }
+
+    return persistedUserMessage.id;
+  } catch (err) {
+    ctx.messages.pop();
+    ctx.processing = false;
+    ctx.abortController = null;
+    ctx.currentRequestId = undefined;
+    throw err;
+  }
+}
+
+// ── redirectToSecurePrompt ───────────────────────────────────────────
+
+export function redirectToSecurePrompt(
+  conversationId: string,
+  secretPrompter: SecretPrompter,
+  detectedTypes: string[],
+  onComplete?: () => void,
+): void {
+  const service = 'detected';
+  const field = detectedTypes.join(',');
+  secretPrompter.prompt(
+    service, field,
+    'Secure Credential Entry',
+    'Your message contained a secret. Please enter it here instead — it will be stored securely and never sent to the AI.',
+    undefined, conversationId,
+  ).then(async (result) => {
+    if (!result.value) return;
+
+    const { setSecureKey } = await import('../security/secure-keys.js');
+    const { upsertCredentialMetadata } = await import('../tools/credentials/metadata-store.js');
+
+    if (result.delivery === 'transient_send') {
+      const { credentialBroker } = await import('../tools/credentials/broker.js');
+      credentialBroker.injectTransient(service, field, result.value);
+      try { upsertCredentialMetadata(service, field, {}); } catch (e) { log.debug({ err: e, service, field }, 'Non-critical credential metadata upsert failed'); }
+      log.info({ service, field, delivery: 'transient_send' }, 'Ingress redirect: transient credential injected');
+    } else {
+      const key = `credential:${service}:${field}`;
+      const stored = setSecureKey(key, result.value);
+      if (stored) {
+        try { upsertCredentialMetadata(service, field, {}); } catch (e) { log.debug({ err: e, service, field }, 'Non-critical credential metadata upsert failed'); }
+        log.info({ service, field }, 'Ingress redirect: credential stored');
+      } else {
+        log.warn({ service, field }, 'Ingress redirect: secure storage write failed');
+      }
+    }
+  }).catch(() => { /* prompt timeout or cancel is fine */ }).finally(() => {
+    onComplete?.();
+  });
+}