vellum 0.2.13 → 0.3.2

package/src/daemon/session-attachments.ts

@@ -1,196 +0,0 @@
-import type { ContentBlock } from '../providers/types.js';
-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, setAttachmentThumbnail, AttachmentUploadError } from '../memory/attachments-store.js';
-import { generateVideoThumbnail } from './video-thumbnail.js';
-import {
-  resolveDirectives,
-  contentBlocksToDrafts,
-  deduplicateDrafts,
-  validateDrafts,
-  type DirectiveRequest,
-  type AssistantAttachmentDraft,
-  type ApproveHostRead,
-} from './assistant-attachments.js';
-import { getLogger } from '../util/logger.js';
-
-const log = getLogger('session-attachments');
-
-/**
- * Approve reading a host file for assistant attachment resolution.
- * Checks the permission store and prompts the user if needed.
- */
-export async function approveHostAttachmentRead(
-  filePath: string,
-  workingDir: string,
-  prompter: PermissionPrompter,
-  conversationId: string,
-  hasNoClient: boolean,
-): Promise<boolean> {
-  const toolName = 'host_file_read';
-  const input = { path: filePath };
-  const decision = await check(toolName, input, workingDir);
-
-  if (decision.decision === 'allow') {
-    return true;
-  }
-  if (decision.decision === 'deny') {
-    return false;
-  }
-
-  // HTTP-created sessions use a no-op sendToClient — prompting would
-  // block for the full permission timeout before auto-denying.
-  if (hasNoClient) {
-    log.info({ filePath }, 'Denying host attachment read: no interactive client connected');
-    return false;
-  }
-
-  const response = await prompter.prompt(
-    toolName,
-    input,
-    await classifyRisk(toolName, input, workingDir),
-    generateAllowlistOptions(toolName, input),
-    generateScopeOptions(workingDir, toolName),
-    undefined,
-    undefined,
-    conversationId,
-    'host',
-  );
-
-  if ((response.decision === 'always_allow' || response.decision === 'always_allow_high_risk') && response.selectedPattern && response.selectedScope) {
-    addRule(toolName, response.selectedPattern, response.selectedScope, 'allow', 100,
-      response.decision === 'always_allow_high_risk' ? { allowHighRisk: true } : undefined);
-  }
-  if (response.decision === 'always_deny' && response.selectedPattern && response.selectedScope) {
-    addRule(toolName, response.selectedPattern, response.selectedScope, 'deny');
-  }
-
-  return response.decision === 'allow' || response.decision === 'always_allow' || response.decision === 'always_allow_high_risk';
-}
-
-export function formatAttachmentWarnings(warnings: string[]): string | null {
-  if (warnings.length === 0) return null;
-  const lines = warnings.map((warning) => `Attachment warning: ${warning}`);
-  return `\n\n${lines.join('\n')}`;
-}
-
-export interface AttachmentResolutionResult {
-  assistantAttachments: AssistantAttachmentDraft[];
-  emittedAttachments: UserMessageAttachment[];
-  directiveWarnings: string[];
-}
-
-/**
- * Resolve accumulated directives and tool content blocks into assistant
- * attachments. Persists attachments and links them to the assistant message.
- */
-export async function resolveAssistantAttachments(
-  accumulatedDirectives: DirectiveRequest[],
-  accumulatedToolContentBlocks: ContentBlock[],
-  directiveWarnings: string[],
-  workingDir: string,
-  approveHostRead: ApproveHostRead,
-  lastAssistantMessageId: string | undefined,
-): Promise<AttachmentResolutionResult> {
-  let assistantAttachments: AssistantAttachmentDraft[] = [];
-  const emittedAttachments: UserMessageAttachment[] = [];
-
-  log.info(
-    { directiveCount: accumulatedDirectives.length, toolBlockCount: accumulatedToolContentBlocks.length, workingDir },
-    'Resolving assistant attachments',
-  );
-
-  if (accumulatedDirectives.length > 0 || accumulatedToolContentBlocks.length > 0) {
-    const directiveDrafts = accumulatedDirectives.length > 0
-      ? await resolveDirectives(accumulatedDirectives, workingDir, approveHostRead)
-      : { drafts: [], warnings: [] };
-    directiveWarnings.push(...directiveDrafts.warnings);
-
-    if (directiveDrafts.warnings.length > 0) {
-      log.warn({ warnings: directiveDrafts.warnings }, 'Directive resolution warnings');
-    }
-    log.info(
-      { resolvedDrafts: directiveDrafts.drafts.length, directives: accumulatedDirectives.map(d => ({ source: d.source, path: d.path, filename: d.filename, mimeType: d.mimeType })) },
-      'Directive resolution complete',
-    );
-
-    const toolDrafts = contentBlocksToDrafts(accumulatedToolContentBlocks);
-
-    const merged = deduplicateDrafts([...directiveDrafts.drafts, ...toolDrafts]);
-    const validated = validateDrafts(merged);
-    directiveWarnings.push(...validated.warnings);
-    assistantAttachments = validated.accepted;
-
-    log.info(
-      { merged: merged.length, accepted: validated.accepted.length, validationWarnings: validated.warnings },
-      'Attachment validation complete',
-    );
-  } else {
-    log.info('No directives or tool content blocks to resolve');
-  }
-
-  // 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(
-          draft.filename,
-          draft.mimeType,
-          draft.dataBase64,
-        );
-      } catch (err) {
-        if (err instanceof AttachmentUploadError) {
-          log.warn({ filename: draft.filename, error: err.message }, 'Skipping attachment upload');
-          directiveWarnings.push(`Attachment ${draft.filename} skipped: ${err.message}`);
-          continue;
-        }
-        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: omitData ? '' : draft.dataBase64,
-        ...(omitData ? { sizeBytes: draft.sizeBytes } : {}),
-        ...(thumbnailData ? { thumbnailData } : {}),
-      });
-    }
-  } else if (assistantAttachments.length > 0) {
-    for (const draft of assistantAttachments) {
-      emittedAttachments.push({
-        filename: draft.filename,
-        mimeType: draft.mimeType,
-        data: draft.dataBase64,
-      });
-    }
-  }
-
-  return { assistantAttachments, emittedAttachments, directiveWarnings };
-}

package/src/daemon/session-conflict-gate.ts

@@ -1,128 +0,0 @@
-/**
- * Conflict-gate logic extracted from Session.
- *
- * Decides whether to ask the user about a pending memory conflict (relevant gate)
- * or skip entirely.
- */
-
-import {
-  applyConflictResolution,
-  listPendingConflictDetails,
-  markConflictAsked,
-} from '../memory/conflict-store.js';
-import type { PendingConflictDetail } from '../memory/conflict-store.js';
-import { resolveConflictClarification } from '../memory/clarification-resolver.js';
-import {
-  computeConflictRelevance,
-  looksLikeClarificationReply,
-  shouldAttemptConflictResolution,
-} from '../memory/conflict-intent.js';
-
-export interface ConflictGateDecision {
-  question: string;
-  relevant: boolean;
-}
-
-export class ConflictGate {
-  private turnCounter = 0;
-  private lastAskedTurn = new Map<string, number>();
-
-  async evaluate(
-    userMessage: string,
-    conflictConfig: {
-      enabled: boolean;
-      gateMode: string;
-      relevanceThreshold: number;
-      reaskCooldownTurns: number;
-      resolverLlmTimeoutMs: number;
-    },
-    scopeId = 'default',
-  ): Promise<ConflictGateDecision | null> {
-    if (!conflictConfig.enabled || conflictConfig.gateMode !== 'soft') return null;
-
-    this.turnCounter += 1;
-    const threshold = conflictConfig.relevanceThreshold;
-    const cooldownTurns = Math.max(1, conflictConfig.reaskCooldownTurns);
-    const pendingBeforeResolve = listPendingConflictDetails(scopeId, 50);
-    const clarificationReply = looksLikeClarificationReply(userMessage);
-    const candidatesBeforeResolve = pendingBeforeResolve.filter((conflict) => {
-      const relevance = computeConflictRelevance(userMessage, conflict);
-      return shouldAttemptConflictResolution({
-        clarificationReply,
-        relevance,
-        wasRecentlyAsked: this.wasRecentlyAsked(conflict.id, cooldownTurns),
-      });
-    });
-    await this.resolvePendingConflicts(
-      userMessage,
-      conflictConfig.resolverLlmTimeoutMs,
-      candidatesBeforeResolve,
-    );
-
-    const pending = listPendingConflictDetails(scopeId, 50);
-    if (pending.length === 0) return null;
-
-    const scored = pending.map((conflict) => ({
-      conflict,
-      relevance: computeConflictRelevance(userMessage, conflict),
-    }));
-    const askable = scored
-      .filter((entry) => entry.relevance >= threshold)
-      .find((entry) => this.shouldAsk(entry.conflict.id, cooldownTurns));
-    if (!askable) return null;
-
-    this.lastAskedTurn.set(askable.conflict.id, this.turnCounter);
-    markConflictAsked(askable.conflict.id);
-    return {
-      question: askable.conflict.clarificationQuestion ?? buildFallbackConflictQuestion(askable.conflict),
-      relevant: true,
-    };
-  }
-
-  private async resolvePendingConflicts(
-    userMessage: string,
-    resolverTimeoutMs: number,
-    pendingConflicts: PendingConflictDetail[],
-  ): Promise<void> {
-    for (const conflict of pendingConflicts) {
-      const resolution = await resolveConflictClarification(
-        {
-          existingStatement: conflict.existingStatement,
-          candidateStatement: conflict.candidateStatement,
-          userMessage,
-        },
-        { timeoutMs: resolverTimeoutMs },
-      );
-      if (resolution.resolution === 'still_unclear') continue;
-
-      applyConflictResolution({
-        conflictId: conflict.id,
-        resolution: resolution.resolution,
-        mergedStatement: resolution.resolution === 'merge' ? resolution.resolvedStatement : null,
-        resolutionNote: resolution.explanation,
-      });
-    }
-  }
-
-  private shouldAsk(conflictId: string, cooldownTurns: number): boolean {
-    const lastAsked = this.lastAskedTurn.get(conflictId);
-    if (lastAsked === undefined) return true;
-    return this.turnCounter - lastAsked >= cooldownTurns;
-  }
-
-  private wasRecentlyAsked(conflictId: string, cooldownTurns: number): boolean {
-    const lastAsked = this.lastAskedTurn.get(conflictId);
-    if (lastAsked === undefined) return false;
-    return this.turnCounter - lastAsked <= cooldownTurns;
-  }
-}
-
-export function buildFallbackConflictQuestion(conflict: PendingConflictDetail): string {
-  return [
-    'I have two conflicting notes and need your confirmation.',
-    `A) ${conflict.existingStatement}`,
-    `B) ${conflict.candidateStatement}`,
-    'Which one should I keep?',
-  ].join('\n');
-}
-export { computeConflictRelevance, looksLikeClarificationReply };

package/src/daemon/session-dynamic-profile.ts

@@ -1,63 +0,0 @@
-/**
- * Dynamic-profile injection and stripping helpers extracted from Session.
- *
- * These are pure functions with no state — they wrap profile text into user
- * messages at runtime and strip it back out before persistence.
- */
-
-import type { Message } from '../providers/types.js';
-
-export function injectDynamicProfileIntoUserMessage(message: Message, profileText: string): Message {
-  const trimmedProfile = profileText.trim();
-  if (trimmedProfile.length === 0) return message;
-  const block = [
-    '<dynamic-profile-context>',
-    trimmedProfile,
-    '</dynamic-profile-context>',
-  ].join('\n');
-  return {
-    ...message,
-    content: [
-      ...message.content,
-      { type: 'text', text: `\n\n${block}` },
-    ],
-  };
-}
-
-export function stripDynamicProfileMessages(messages: Message[], profileText: string): Message[] {
-  const trimmedProfile = profileText.trim();
-  if (trimmedProfile.length === 0) return messages;
-  const injectedBlock = `\n\n<dynamic-profile-context>\n${trimmedProfile}\n</dynamic-profile-context>`;
-  // Find the last user message that actually contains the injected profile block.
-  // We can't just target the last user message by role — tool_result messages also
-  // have role 'user', so after tool use the last user message won't be the one
-  // we injected the profile into.
-  let lastUserIdx = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === 'user' && messages[i].content.some(
-      (b) => b.type === 'text' && b.text.includes(injectedBlock),
-    )) { lastUserIdx = i; break; }
-  }
-  if (lastUserIdx === -1) return messages;
-  const message = messages[lastUserIdx];
-  let changed = false;
-  const nextContent = message.content.map((block) => {
-    if (block.type !== 'text') return block;
-    const nextText = block.text.split(injectedBlock).join('');
-    if (nextText === block.text) return block;
-    changed = true;
-    const stripped = nextText.replace(/\n{3,}/g, '\n\n').trimEnd();
-    return stripped.length > 0 ? { ...block, text: stripped } : null;
-  }).filter((block): block is NonNullable<typeof block> => block !== null);
-  if (!changed) return messages;
-  // If stripping removed all content blocks, drop the message entirely
-  // to avoid sending an empty content array to the provider.
-  if (nextContent.length === 0) {
-    return [...messages.slice(0, lastUserIdx), ...messages.slice(lastUserIdx + 1)];
-  }
-  return [
-    ...messages.slice(0, lastUserIdx),
-    { ...message, content: nextContent },
-    ...messages.slice(lastUserIdx + 1),
-  ];
-}

package/src/daemon/session-error.ts

@@ -1,290 +0,0 @@
-import type { SessionErrorCode, SessionErrorMessage } from './ipc-protocol.js';
-import { ProviderError } from '../util/errors.js';
-
-/**
- * Classified session error ready for IPC emission.
- */
-export interface ClassifiedSessionError {
-  code: SessionErrorCode;
-  userMessage: string;
-  retryable: boolean;
-  debugDetails?: string;
-}
-
-// Network-level error patterns (connection refused, timeout, DNS, reset)
-const NETWORK_PATTERNS = [
-  /ECONNREFUSED/i,
-  /ECONNRESET/i,
-  /ETIMEDOUT/i,
-  /ENOTFOUND/i,
-  /socket hang up/i,
-  /network.*error/i,
-  /fetch failed/i,
-  /connection.*refused/i,
-  /connection.*reset/i,
-  /connection.*timeout/i,
-];
-
-// Rate limit patterns (HTTP 429 or explicit rate limit messages)
-const RATE_LIMIT_PATTERNS = [
-  /429/,
-  /rate.?limit/i,
-  /too many requests/i,
-  /overloaded/i,
-];
-
-// Context-too-large patterns (request exceeds the model's context window)
-const CONTEXT_TOO_LARGE_PATTERNS = [
-  /context.?length.?exceeded/i,
-  /maximum.?context.?length/i,
-  /token.?limit.?exceeded/i,
-  /prompt.?is.?too.?long/i,
-  /request too large/i,
-  /too many.*input.*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.)
-const PROVIDER_API_PATTERNS = [
-  /\b5\d{2}\b/,
-  /server error/i,
-  /internal server error/i,
-  /bad gateway/i,
-  /service unavailable/i,
-  /gateway timeout/i,
-];
-
-// User-initiated cancellation patterns — these should NOT produce session_error
-const CANCEL_PATTERNS = [
-  /abort/i,
-  /cancel/i,
-];
-
-/**
- * Context about where the error occurred, used to refine classification.
- */
-export interface ErrorContext {
-  /** Where in the processing pipeline the error occurred. */
-  phase: 'agent_loop' | 'queue' | 'regenerate' | 'handler' | 'persist';
-  /** Whether the abort signal was active when the error occurred. */
-  aborted?: boolean;
-}
-
-/**
- * Returns true if the error looks like a user-initiated cancellation
- * (AbortError or explicit cancel). These should use `generation_cancelled`
- * instead of `session_error`.
- */
-export function isUserCancellation(error: unknown, ctx: ErrorContext): boolean {
-  if (!ctx.aborted) return false;
-  if (error instanceof DOMException && error.name === 'AbortError') return true;
-  if (error instanceof Error && error.name === 'AbortError') return true;
-  return false;
-}
-
-/** Maximum length for debugDetails to prevent unbounded IPC payloads. */
-const MAX_DEBUG_DETAIL_LENGTH = 4000;
-
-/**
- * Truncate debug details to a reasonable size for IPC transport.
- */
-function truncateDebugDetails(details: string): string {
-  if (details.length <= MAX_DEBUG_DETAIL_LENGTH) return details;
-  return details.slice(0, MAX_DEBUG_DETAIL_LENGTH) + '\n… (truncated)';
-}
-
-/**
- * Classify an unknown error into a structured session error.
- * Does NOT handle user-initiated cancellation — callers should check
- * `isUserCancellation` first and emit `generation_cancelled` instead.
- *
- * Classification priority:
- * 1. Phase-specific overrides (queue, regenerate)
- * 2. ProviderError.statusCode (deterministic for provider failures)
- * 3. Regex fallback for network/cancel/unknown errors
- */
-export function classifySessionError(
-  error: unknown,
-  ctx: ErrorContext,
-): ClassifiedSessionError {
-  const message = error instanceof Error ? error.message : String(error);
-  const rawDetails = (error instanceof Error ? error.stack : undefined) ?? message;
-  const debugDetails = truncateDebugDetails(rawDetails);
-
-  // Phase-specific overrides
-  if (ctx.phase === 'queue') {
-    return {
-      code: 'QUEUE_FULL',
-      userMessage: 'Message queue is full (max depth: 10). Please wait for current messages to be processed.',
-      retryable: true,
-      debugDetails: truncateDebugDetails(message),
-    };
-  }
-
-  if (ctx.phase === 'regenerate') {
-    const base = classifyCore(error, message);
-    return {
-      code: 'REGENERATE_FAILED',
-      userMessage: `Failed to regenerate response. ${base.userMessage}`,
-      retryable: true,
-      debugDetails,
-    };
-  }
-
-  // Classify using statusCode (if ProviderError) then regex fallback
-  const classified = classifyCore(error, message);
-  return {
-    ...classified,
-    debugDetails,
-  };
-}
-
-/**
- * Core classification: check ProviderError.statusCode first for
- * deterministic classification, then fall back to regex patterns.
- */
-function classifyCore(
-  error: unknown,
-  message: string,
-): Omit<ClassifiedSessionError, 'debugDetails'> {
-  // ProviderError with statusCode — deterministic classification
-  if (error instanceof ProviderError && error.statusCode !== undefined) {
-    if (error.statusCode === 429) {
-      return {
-        code: 'PROVIDER_RATE_LIMIT',
-        userMessage: 'The AI provider is rate limiting requests. Please wait a moment and try again.',
-        retryable: true,
-      };
-    }
-    if (error.statusCode >= 500) {
-      return {
-        code: 'PROVIDER_API',
-        userMessage: 'The AI provider returned an error. This is usually temporary — try again shortly.',
-        retryable: true,
-      };
-    }
-    // 4xx (non-429) — check for context-too-large before generic fallback
-    if (error.statusCode >= 400) {
-      if (isContextTooLarge(message)) {
-        return {
-          code: 'CONTEXT_TOO_LARGE',
-          userMessage: 'The conversation is too long for the model to process. Start a new conversation or try a shorter message.',
-          retryable: false,
-        };
-      }
-      return {
-        code: 'PROVIDER_API',
-        userMessage: 'The AI provider rejected the request. Please try again or check your settings.',
-        retryable: false,
-      };
-    }
-  }
-
-  // Regex fallback for non-ProviderError or ProviderError without statusCode
-  return classifyByMessage(message);
-}
-
-/** Check whether an error message indicates a context-too-large failure. */
-export function isContextTooLarge(message: string): boolean {
-  return CONTEXT_TOO_LARGE_PATTERNS.some((p) => p.test(message));
-}
-
-function classifyByMessage(message: string): Omit<ClassifiedSessionError, 'debugDetails'> {
-  // Check context-too-large before other patterns
-  if (isContextTooLarge(message)) {
-    return {
-      code: 'CONTEXT_TOO_LARGE',
-      userMessage: 'The conversation is too long for the model to process. Start a new conversation or try a shorter message.',
-      retryable: false,
-    };
-  }
-
-  // Check rate limit first (before network, since 429 could match both)
-  for (const pattern of RATE_LIMIT_PATTERNS) {
-    if (pattern.test(message)) {
-      return {
-        code: 'PROVIDER_RATE_LIMIT',
-        userMessage: 'The AI provider is rate limiting requests. Please wait a moment and try again.',
-        retryable: true,
-      };
-    }
-  }
-
-  // Network errors (before timeout so "connection timeout" is classified as network)
-  for (const pattern of NETWORK_PATTERNS) {
-    if (pattern.test(message)) {
-      return {
-        code: 'PROVIDER_NETWORK',
-        userMessage: 'Unable to reach the AI provider. Check your connection and try again.',
-        retryable: true,
-      };
-    }
-  }
-
-  // Provider API errors (before timeout so "gateway timeout" keeps its specific message)
-  for (const pattern of PROVIDER_API_PATTERNS) {
-    if (pattern.test(message)) {
-      return {
-        code: 'PROVIDER_API',
-        userMessage: 'The AI provider returned an error. This is usually temporary — try again shortly.',
-        retryable: true,
-      };
-    }
-  }
-
-  // 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)) {
-      return {
-        code: 'SESSION_ABORTED',
-        userMessage: 'The request was interrupted. You can try sending your message again.',
-        retryable: true,
-      };
-    }
-  }
-
-  // Default: processing failure
-  return {
-    code: 'SESSION_PROCESSING_FAILED',
-    userMessage: 'Something went wrong processing your message. Please try again.',
-    retryable: false,
-  };
-}
-
-/**
- * Build a `session_error` IPC message from a classified error.
- */
-export function buildSessionErrorMessage(
-  sessionId: string,
-  classified: ClassifiedSessionError,
-): SessionErrorMessage {
-  return {
-    type: 'session_error',
-    sessionId,
-    code: classified.code,
-    userMessage: classified.userMessage,
-    retryable: classified.retryable,
-    debugDetails: classified.debugDetails,
-  };
-}