@vellumai/assistant 0.4.43 → 0.4.45

package/src/daemon/session-error.ts

@@ -1,8 +1,11 @@
 import { ProviderError } from "../util/errors.js";
-import type { SessionErrorCode, SessionErrorMessage } from "./message-protocol.js";
+import type {
+  SessionErrorCode,
+  SessionErrorMessage,
+} from "./message-protocol.js";
 
 /**
- * Classified session error ready for IPC emission.
+ * Classified session error ready for client emission.
  */
 export interface ClassifiedSessionError {
   code: SessionErrorCode;
@@ -73,7 +76,7 @@ const CANCEL_PATTERNS = [/abort/i, /cancel/i];
  */
 export interface ErrorContext {
   /** Where in the processing pipeline the error occurred. */
-  phase: "agent_loop" | "queue" | "regenerate" | "handler" | "persist";
+  phase: "agent_loop" | "regenerate" | "handler" | "persist";
   /** Whether the abort signal was active when the error occurred. */
   aborted?: boolean;
 }
@@ -90,11 +93,11 @@ export function isUserCancellation(error: unknown, ctx: ErrorContext): boolean {
   return false;
 }
 
-/** Maximum length for debugDetails to prevent unbounded IPC payloads. */
+/** Maximum length for debugDetails to prevent unbounded event payloads. */
 const MAX_DEBUG_DETAIL_LENGTH = 4000;
 
 /**
- * Truncate debug details to a reasonable size for IPC transport.
+ * Truncate debug details to a reasonable size for transport.
  */
 function truncateDebugDetails(details: string): string {
   if (details.length <= MAX_DEBUG_DETAIL_LENGTH) return details;
@@ -121,15 +124,6 @@ export function classifySessionError(
   const debugDetails = truncateDebugDetails(rawDetails);
 
   // Phase-specific overrides
-  if (ctx.phase === "queue") {
-    return {
-      code: "QUEUE_FULL",
-      userMessage: "Message queue is full (10 messages pending).",
-      retryable: true,
-      debugDetails: truncateDebugDetails(message),
-    };
-  }
-
   if (ctx.phase === "regenerate") {
     const base = classifyCore(error, message);
     return {
@@ -165,6 +159,13 @@ function classifyCore(
         retryable: false,
       };
     }
+    if (error.statusCode === 401) {
+      return {
+        code: "PROVIDER_BILLING",
+        userMessage: "Your API key is invalid or expired.",
+        retryable: false,
+      };
+    }
     if (error.statusCode === 429) {
       return {
         code: "PROVIDER_RATE_LIMIT",
@@ -209,7 +210,7 @@ function classifyCore(
       return {
         code: "PROVIDER_API",
         userMessage: "The AI provider rejected the request.",
-        retryable: false,
+        retryable: true,
       };
     }
   }
@@ -311,7 +312,7 @@ function classifyByMessage(
 }
 
 /**
- * Build a `session_error` IPC message from a classified error.
+ * Build a `session_error` server message from a classified error.
  */
 export function buildSessionErrorMessage(
   sessionId: string,

package/src/daemon/session-lifecycle.ts

@@ -24,7 +24,11 @@ import {
 import { unregisterSessionSender } from "../tools/browser/browser-screencast.js";
 import { getLogger } from "../util/logger.js";
 import { repairHistory } from "./history-repair.js";
-import type { SurfaceData, SurfaceType, UsageStats } from "./message-protocol.js";
+import type {
+  SurfaceData,
+  SurfaceType,
+  UsageStats,
+} from "./message-protocol.js";
 import {
   unregisterCallNotifiers,
   unregisterWatchNotifiers,
@@ -74,6 +78,7 @@ export interface LoadFromDbContext {
   contextCompactedAt: number | null;
   trustContext?: { trustClass: TrustClass };
   loadedHistoryTrustClass?: TrustClass;
+  hasAttachments?: boolean;
 }
 
 export interface AbortContext {
@@ -177,6 +182,20 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
 
   ctx.loadedHistoryTrustClass = trustClass;
 
+  // Scan ALL db messages (including compacted ones) for attachments so that
+  // asset tools remain available after context compaction.
+  if (
+    ctx.contextCompactedMessageCount > 0 &&
+    dbMessages.some(
+      (m) =>
+        m.role === "user" &&
+        (m.content.includes('"type":"image"') ||
+          m.content.includes('"type":"file"')),
+    )
+  ) {
+    ctx.hasAttachments = true;
+  }
+
   log.info(
     { conversationId: ctx.conversationId, count: ctx.messages.length },
     "Loaded messages from DB",

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

@@ -19,29 +19,15 @@ export function stripMediaPayloadsForRetry(messages: Message[]): {
   latestUserIndex: number | null;
 } {
   let latestUserIndex: number | null = null;
-  let lastSummaryUserIndex: number | null = null;
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (msg.role !== "user") continue;
     if (isToolResultOnlyMessage(msg)) continue;
-    if (getSummaryFromContextMessage(msg) != null) {
-      // Track the last summary message as a fallback — after aggressive
-      // compaction (minKeepRecentUserTurns: 0), the summary may be the only
-      // user message left and it can contain preserved image blocks that
-      // should not be stripped.
-      if (lastSummaryUserIndex == null) lastSummaryUserIndex = i;
-      continue;
-    }
+    if (getSummaryFromContextMessage(msg) != null) continue;
     latestUserIndex = i;
     break;
   }
 
-  // Fall back to the summary message when compaction consumed all user turns,
-  // so images preserved by compaction are not unconditionally stripped.
-  if (latestUserIndex == null && lastSummaryUserIndex != null) {
-    latestUserIndex = lastSummaryUserIndex;
-  }
-
   let modified = false;
   let replacedBlocks = 0;
   let keptLatestMediaBlocks = 0;

package/src/daemon/session-messaging.ts

@@ -28,7 +28,10 @@ import {
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
-import type { ServerMessage, UserMessageAttachment } from "./message-protocol.js";
+import type {
+  ServerMessage,
+  UserMessageAttachment,
+} from "./message-protocol.js";
 import type { MessageQueue } from "./session-queue-manager.js";
 import type { TrustContext } from "./session-runtime-assembly.js";
 
@@ -212,7 +215,7 @@ export function enqueueMessage(
   metadata?: Record<string, unknown>,
   options?: { isInteractive?: boolean },
   displayContent?: string,
-): { queued: boolean; rejected?: boolean; requestId: string } {
+): { queued: boolean; requestId: string; rejected?: boolean } {
   if (!ctx.processing) {
     return { queued: false, requestId };
   }
@@ -225,7 +228,7 @@ export function enqueueMessage(
     extractTurnInterfaceContext(metadata) ??
     ctx.getTurnInterfaceContext() ??
     undefined;
-  const pushed = ctx.queue.push({
+  const accepted = ctx.queue.push({
     content,
     attachments,
     requestId,
@@ -236,11 +239,16 @@ export function enqueueMessage(
     turnChannelContext,
     turnInterfaceContext,
     isInteractive: options?.isInteractive,
-    queuedAt: Date.now(),
     displayContent,
   });
-  if (!pushed) {
-    return { queued: false, rejected: true, requestId };
+  if (!accepted) {
+    onEvent({
+      type: "error",
+      message:
+        "The assistant is busy and cannot accept more messages right now. Please try again shortly.",
+      category: "queue_full",
+    });
+    return { queued: false, requestId, rejected: true };
   }
   return { queued: true, requestId };
 }

package/src/daemon/session-process.ts

@@ -36,14 +36,18 @@ import type {
 import type { MessageQueue } from "./session-queue-manager.js";
 import type { QueueDrainReason } from "./session-queue-manager.js";
 import type { TrustContext } from "./session-runtime-assembly.js";
-import { resolveSlash, type SlashContext } from "./session-slash.js";
+import {
+  isProviderShortcut,
+  resolveSlash,
+  type SlashContext,
+} from "./session-slash.js";
 import type { TraceEmitter } from "./trace-emitter.js";
 import { resolveVerificationSessionIntent } from "./verification-session-intent.js";
 
 const log = getLogger("session-process");
 
 /** Build a model_info event with fresh config data. */
-function buildModelInfoEvent(): ServerMessage {
+export function buildModelInfoEvent(): ServerMessage {
   const config = getConfig();
   const configured = Object.keys(config.apiKeys).filter(
     (k) => !!config.apiKeys[k],
@@ -58,7 +62,7 @@ function buildModelInfoEvent(): ServerMessage {
 }
 
 /** True when the trimmed content is a /model or /models slash command. */
-function isModelSlashCommand(content: string): boolean {
+export function isModelSlashCommand(content: string): boolean {
   const trimmed = content.trim();
   return (
     trimmed === "/model" ||
@@ -114,6 +118,10 @@ export interface ProcessSessionContext {
   setTurnChannelContext(ctx: TurnChannelContext): void;
   getTurnInterfaceContext(): TurnInterfaceContext | null;
   setTurnInterfaceContext(ctx: TurnInterfaceContext): void;
+  /** Mark host proxies as unavailable so tool execution uses local fallback. */
+  clearProxyAvailability(): void;
+  /** Restore host proxy availability based on whether a real client is connected. */
+  restoreProxyAvailability(): void;
   emitActivityState(
     phase:
       | "idle"
@@ -131,7 +139,8 @@ export interface ProcessSessionContext {
       | "confirmation_resolved"
       | "message_complete"
       | "generation_cancelled"
-      | "error_terminal",
+      | "error_terminal"
+      | "preview_start",
     anchor?: "assistant_turn" | "user_turn" | "global",
     requestId?: string,
     statusText?: string,
@@ -260,6 +269,23 @@ export async function drainQueue(
     session.setTurnInterfaceContext(queuedInterfaceCtx);
   }
 
+  // Non-interactive queued messages (channel requests) must not execute tools
+  // via the desktop host proxy. Clear proxy availability so isAvailable()
+  // returns false and tool execution falls back to local.
+  if (next.isInteractive === false) {
+    session.clearProxyAvailability();
+  } else {
+    // Restore proxy availability only for desktop-originating turns (macos/ios)
+    // in case a prior non-interactive drain disabled it. Non-desktop interactive
+    // interfaces (CLI, Vellum) should not re-enable desktop host proxies.
+    const interfaceCtx =
+      queuedInterfaceCtx ?? session.getTurnInterfaceContext();
+    const sourceInterface = interfaceCtx?.userMessageInterface;
+    if (sourceInterface === "macos" || sourceInterface === "ios") {
+      session.restoreProxyAvailability();
+    }
+  }
+
   // Resolve slash commands for queued messages
   const slashResult = resolveSlash(next.content, buildSlashContext(session));
 
@@ -326,7 +352,10 @@ export async function drainQueue(
 
       // Emit fresh model info before the text delta so the client has
       // up-to-date configuredProviders when rendering /model or /models UI.
-      if (isModelSlashCommand(next.content)) {
+      if (
+        isModelSlashCommand(next.content) ||
+        isProviderShortcut(next.content)
+      ) {
         next.onEvent(buildModelInfoEvent());
       }
       next.onEvent({ type: "assistant_text_delta", text: slashResult.message });
@@ -510,7 +539,7 @@ export async function drainQueue(
 
 /**
  * Convenience function that persists a user message and runs the agent loop
- * in a single call. Used by the IPC path where blocking is expected.
+ * in a single call. Used by the message-handler path where blocking is expected.
  */
 export async function processMessage(
   session: ProcessSessionContext,
@@ -676,7 +705,7 @@ export async function processMessage(
 
     // Emit fresh model info before the text delta so the client has
     // up-to-date configuredProviders when rendering /model or /models UI.
-    if (isModelSlashCommand(content)) {
+    if (isModelSlashCommand(content) || isProviderShortcut(content)) {
       onEvent(buildModelInfoEvent());
     }
     onEvent({ type: "assistant_text_delta", text: slashResult.message });

package/src/daemon/session-queue-manager.ts

@@ -10,7 +10,10 @@ import type {
   TurnInterfaceContext,
 } from "../channels/types.js";
 import { getLogger } from "../util/logger.js";
-import type { ServerMessage, UserMessageAttachment } from "./message-protocol.js";
+import type {
+  ServerMessage,
+  UserMessageAttachment,
+} from "./message-protocol.js";
 
 const log = getLogger("session-queue");
 
@@ -26,16 +29,16 @@ export interface QueuedMessage {
   turnInterfaceContext?: TurnInterfaceContext;
   /** When false, the turn has no interactive user and should skip clarification prompts. */
   isInteractive?: boolean;
-  /** Timestamp (ms) when the message was enqueued. */
-  queuedAt: number;
   /** Original user message text to persist to DB when recording intent stripping produced a different `content`. */
   displayContent?: string;
 }
 
-export const MAX_QUEUE_DEPTH = 10;
-/** Messages older than this (ms) are auto-expired from the queue. */
-export const DEFAULT_MAX_WAIT_MS = 60_000;
-const CAPACITY_WARNING_THRESHOLD = 0.8;
+/**
+ * Maximum total estimated bytes across all queued messages per session.
+ * Limits memory consumption when a sender floods messages while the
+ * session is busy.  50 MB is well above any legitimate usage.
+ */
+export const DEFAULT_MAX_QUEUE_BYTES = 50 * 1024 * 1024; // 50 MB
 
 /**
  * Describes why a queued message was promoted from the queue.
@@ -53,75 +56,59 @@ export interface QueuePolicy {
   checkpointHandoffEnabled: boolean;
 }
 
-export interface QueueMetrics {
-  currentDepth: number;
-  totalDropped: number;
-  totalExpired: number;
-  /** Average wait time (ms) of dequeued messages. 0 when no messages have been dequeued. */
-  averageWaitMs: number;
-}
-
 /**
  * Typed wrapper around the queued-message array.
  *
- * Session owns one instance; the wrapper handles capacity checks,
- * expiry, metrics, and iteration so the rest of Session doesn't
- * touch the raw array.
+ * Session owns one instance; the wrapper handles iteration
+ * so the rest of Session doesn't touch the raw array.
+ *
+ * A byte budget caps total memory held by queued messages so a
+ * high-rate sender cannot exhaust the process.
  */
 export class MessageQueue {
   private items: QueuedMessage[] = [];
-  private maxWaitMs: number;
-  private droppedCount = 0;
-  private expiredCount = 0;
-  private totalWaitMs = 0;
-  private dequeuedCount = 0;
-  private capacityWarned = false;
-
-  constructor(maxWaitMs: number = DEFAULT_MAX_WAIT_MS) {
-    this.maxWaitMs = maxWaitMs;
+  private currentBytes = 0;
+  private maxBytes: number;
+
+  constructor(maxBytes: number = DEFAULT_MAX_QUEUE_BYTES) {
+    this.maxBytes = maxBytes;
   }
 
+  /**
+   * Attempt to enqueue a message.
+   * Returns `true` if accepted, `false` if rejected (over budget).
+   */
   push(item: QueuedMessage): boolean {
-    this.expireStale();
-
-    if (this.items.length >= MAX_QUEUE_DEPTH) {
-      this.droppedCount++;
-      return false;
-    }
-
-    item.queuedAt = Date.now();
-    this.items.push(item);
-
-    const ratio = this.items.length / MAX_QUEUE_DEPTH;
-    if (ratio >= CAPACITY_WARNING_THRESHOLD && !this.capacityWarned) {
-      this.capacityWarned = true;
+    const itemBytes = estimateItemBytes(item);
+    if (this.currentBytes + itemBytes > this.maxBytes && this.items.length > 0) {
       log.warn(
-        { depth: this.items.length, max: MAX_QUEUE_DEPTH },
-        "Queue nearing capacity",
+        {
+          requestId: item.requestId,
+          queueDepth: this.items.length,
+          currentBytes: this.currentBytes,
+          itemBytes,
+          maxBytes: this.maxBytes,
+        },
+        "Rejecting queued message: queue byte budget exceeded",
       );
-    } else if (ratio < CAPACITY_WARNING_THRESHOLD) {
-      this.capacityWarned = false;
+      return false;
     }
-
+    this.items.push(item);
+    this.currentBytes += itemBytes;
     return true;
   }
 
   shift(): QueuedMessage | undefined {
-    this.expireStale();
     const item = this.items.shift();
     if (item) {
-      this.dequeuedCount++;
-      this.totalWaitMs += Date.now() - item.queuedAt;
-    }
-    if (this.items.length / MAX_QUEUE_DEPTH < CAPACITY_WARNING_THRESHOLD) {
-      this.capacityWarned = false;
+      this.currentBytes -= estimateItemBytes(item);
     }
     return item;
   }
 
   clear(): void {
     this.items = [];
-    this.capacityWarned = false;
+    this.currentBytes = 0;
   }
 
   get length(): number {
@@ -132,6 +119,10 @@ export class MessageQueue {
     return this.items.length === 0;
   }
 
+  get totalBytes(): number {
+    return this.currentBytes;
+  }
+
   /**
    * Remove a queued message by its requestId.
    * Returns the removed message, or undefined if not found.
@@ -139,60 +130,28 @@ export class MessageQueue {
   removeByRequestId(requestId: string): QueuedMessage | undefined {
     const idx = this.items.findIndex((m) => m.requestId === requestId);
     if (idx === -1) return undefined;
-    return this.items.splice(idx, 1)[0];
-  }
-
-  getMetrics(): QueueMetrics {
-    return {
-      currentDepth: this.items.length,
-      totalDropped: this.droppedCount,
-      totalExpired: this.expiredCount,
-      averageWaitMs:
-        this.dequeuedCount > 0 ? this.totalWaitMs / this.dequeuedCount : 0,
-    };
-  }
-
-  /** Remove messages that have been waiting longer than maxWaitMs. */
-  private expireStale(): void {
-    const now = Date.now();
-    const cutoff = now - this.maxWaitMs;
-    const expired: QueuedMessage[] = [];
-    this.items = this.items.filter((item) => {
-      if (item.queuedAt < cutoff) {
-        this.expiredCount++;
-        expired.push(item);
-        return false;
-      }
-      return true;
-    });
-    for (const item of expired) {
-      log.warn(
-        { requestId: item.requestId, waitMs: now - item.queuedAt },
-        "Expiring stale queued message",
-      );
-      try {
-        item.onEvent({
-          type: "error",
-          message:
-            "Your queued message was dropped because it waited too long in the queue.",
-          category: "queue_expired",
-        });
-      } catch (e) {
-        log.debug(
-          { err: e, requestId: item.requestId },
-          "Failed to notify client of expired message",
-        );
-      }
-    }
-    if (
-      expired.length > 0 &&
-      this.items.length / MAX_QUEUE_DEPTH < CAPACITY_WARNING_THRESHOLD
-    ) {
-      this.capacityWarned = false;
-    }
+    const [removed] = this.items.splice(idx, 1);
+    this.currentBytes -= estimateItemBytes(removed);
+    return removed;
   }
 
   [Symbol.iterator](): Iterator<QueuedMessage> {
     return this.items[Symbol.iterator]();
   }
 }
+
+/**
+ * Estimate the in-memory byte cost of a queued message.
+ * Dominated by content text and attachment `data` (base64 strings).
+ */
+function estimateItemBytes(item: QueuedMessage): number {
+  let bytes = item.content.length * 2; // JS strings are UTF-16
+  for (const a of item.attachments) {
+    bytes += a.data.length * 2;
+    if (a.extractedText) bytes += a.extractedText.length * 2;
+  }
+  // Small fixed overhead for metadata, pointers, etc. (not worth
+  // measuring precisely — the content/attachment data dominates).
+  bytes += 512;
+  return bytes;
+}

package/src/daemon/session-runtime-assembly.ts

@@ -421,13 +421,6 @@ export function injectActiveSurfaceContext(
       "8. Keep your text response to 1 brief sentence confirming what you changed.",
     );
 
-    if (ctx.html.includes('data-vellum-home-base="v1"')) {
-      lines.push(
-        "9. This is the prebuilt Home Base scaffold. Preserve layout anchors:",
-        "   `home-base-root`, `home-base-onboarding-lane`, and `home-base-starter-lane`.",
-      );
-    }
-
     // File tree with sizes (capped at 50 files to bound prompt size)
     const files = ctx.appFiles ?? listAppFiles(ctx.appId);
     const MAX_FILE_TREE_ENTRIES = 50;
@@ -1181,3 +1174,30 @@ export function applyRuntimeInjections(
 
   return result;
 }
+
+// ---------------------------------------------------------------------------
+// Attachment detection
+// ---------------------------------------------------------------------------
+
+/** Content block types that indicate user-uploaded attachments. */
+const ATTACHMENT_CONTENT_TYPES = new Set(["image", "file"]);
+
+/**
+ * Scan conversation messages for user-uploaded attachment content blocks
+ * (image or file). Returns true as soon as any attachment is found.
+ *
+ * Used to set the one-way `hasAttachments` flag on Session so that asset
+ * tools (asset_search, asset_materialize) are included in tool definitions
+ * only when the conversation contains attachments.
+ */
+export function messagesContainAttachments(messages: Message[]): boolean {
+  for (const message of messages) {
+    if (message.role !== "user") continue;
+    for (const block of message.content) {
+      if (ATTACHMENT_CONTENT_TYPES.has(block.type)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}

package/src/daemon/session-skill-tools.ts

@@ -240,12 +240,21 @@ export function projectSkillTools(
   const contextIds = contextEntries.map((e) => e.id);
   const allCandidateIds = new Set<string>([...contextIds, ...preactivated]);
 
+  // Load the catalog (cached for session lifetime) and index by ID
+  const catalog = getCachedCatalog(options?.cache);
+  const catalogById = new Map<string, SkillSummary>();
+  for (const skill of catalog) {
+    catalogById.set(skill.id, skill);
+  }
+
   // Assistant feature flag gate: drop skills whose flag is explicitly OFF,
   // even if they have markers in conversation history from before the flag was turned off.
   const config = getConfig();
   const activeIds = new Set<string>();
   for (const id of allCandidateIds) {
-    if (isAssistantFeatureFlagEnabled(skillFlagKey(id), config)) {
+    const skill = catalogById.get(id);
+    const flagKey = skill ? skillFlagKey(skill) : undefined;
+    if (!flagKey || isAssistantFeatureFlagEnabled(flagKey, config)) {
       activeIds.add(id);
     }
   }
@@ -270,14 +279,7 @@ export function projectSkillTools(
     return { toolDefinitions: [], allowedToolNames: new Set() };
   }
 
-  // Load the catalog (cached for session lifetime) and index by ID
-  const catalog = getCachedCatalog(options?.cache);
-  const catalogById = new Map<string, SkillSummary>();
-  for (const skill of catalog) {
-    catalogById.set(skill.id, skill);
-  }
-
-  const allToolDefinitions: ToolDefinition[] = [];
+  // Tool definitions are no longer sent to the LLM — tools are invoked via skill_execute dispatch.
   const allToolNames = new Set<string>();
   const successfulEntries = new Map<string, string>();
   // Track skills already unregistered in the version-change branch so the
@@ -373,7 +375,6 @@ export function projectSkillTools(
 
       successfulEntries.set(skillId, currentHash);
       for (const tool of accepted) {
-        allToolDefinitions.push(tool.getDefinition());
         allToolNames.add(tool.name);
       }
     }
@@ -405,7 +406,7 @@ export function projectSkillTools(
   }
 
   return {
-    toolDefinitions: allToolDefinitions,
+    toolDefinitions: [],
     allowedToolNames: allToolNames,
   };
 }

package/src/daemon/session-slash.ts

@@ -121,6 +121,13 @@ const PROVIDER_MODEL_SHORTCUTS: Record<
   },
 };
 
+/** True when the trimmed content matches a provider shortcut like /opus, /gpt4, etc. */
+export function isProviderShortcut(content: string): boolean {
+  const match = content.trim().match(/^\/([a-z0-9-]+)(\s|$)/i);
+  if (!match) return false;
+  return match[1].toLowerCase() in PROVIDER_MODEL_SHORTCUTS;
+}
+
 /** Reverse lookup: model ID → provider, derived from PROVIDER_MODEL_SHORTCUTS. */
 export const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
   Object.values(PROVIDER_MODEL_SHORTCUTS).map(({ model, provider }) => [