@vellumai/assistant 0.4.44 → 0.4.45

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

@@ -1174,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 }) => [

package/src/daemon/session-surfaces.ts

@@ -7,7 +7,6 @@ import { isPlainObject } from "../util/object.js";
 import type {
   CardSurfaceData,
   DynamicPageSurfaceData,
-  FileUploadSurfaceData,
   ListSurfaceData,
   ServerMessage,
   SurfaceData,
@@ -215,7 +214,7 @@ export interface SurfaceSessionContext {
     metadata?: Record<string, unknown>,
     options?: { isInteractive?: boolean },
     displayContent?: string,
-  ): { queued: boolean; rejected?: boolean; requestId: string };
+  ): { queued: boolean; requestId: string; rejected?: boolean };
   getQueueDepth(): number;
   processMessage(
     content: string,
@@ -573,23 +572,14 @@ export function handleSurfaceAction(
       requestId,
       surfaceId,
     );
+
     if (result.rejected) {
-      log.error({ surfaceId, actionId }, "Relay prompt rejected — queue full");
-      onEvent(
-        buildSessionErrorMessage(ctx.conversationId, {
-          code: "QUEUE_FULL",
-          userMessage:
-            "Message queue is full (max depth: 10). Please wait for current messages to be processed.",
-          retryable: true,
-          debugDetails: "Relay prompt rejected — session queue is full",
-        }),
-      );
+      ctx.surfaceActionRequestIds.delete(requestId);
       return;
     }
 
     // Echo the prompt to the client so it appears in the chat UI.
-    // Sent after enqueue succeeds so the user doesn't see a prompt that
-    // won't be processed.
+    // Deferred until after rejection check to avoid ghost messages.
     ctx.sendToClient({
       type: "user_message_echo",
       text: prompt,
@@ -715,15 +705,6 @@ export function handleSurfaceAction(
   ctx.surfaceActionRequestIds.add(requestId);
   const onEvent = (msg: ServerMessage) => ctx.sendToClient(msg);
 
-  // Echo the user's prompt to the client so it appears in the chat UI
-  if (shouldRelayPrompt && prompt) {
-    ctx.sendToClient({
-      type: "user_message_echo",
-      text: prompt,
-      sessionId: ctx.conversationId,
-    });
-  }
-
   ctx.traceEmitter.emit("request_received", "Surface action received", {
     requestId,
     status: "info",
@@ -741,6 +722,20 @@ export function handleSurfaceAction(
     undefined,
     displayContent,
   );
+  if (result.rejected) {
+    ctx.surfaceActionRequestIds.delete(requestId);
+    return;
+  }
+
+  // Echo the user's prompt to the client so it appears in the chat UI.
+  // Deferred until after rejection check to avoid ghost messages.
+  if (shouldRelayPrompt && prompt) {
+    ctx.sendToClient({
+      type: "user_message_echo",
+      text: prompt,
+      sessionId: ctx.conversationId,
+    });
+  }
   if (result.queued) {
     const position = ctx.getQueueDepth();
     if (!retainPending) {
@@ -768,29 +763,6 @@ export function handleSurfaceAction(
     return;
   }
 
-  if (result.rejected) {
-    log.error({ surfaceId, actionId }, "Surface action rejected — queue full");
-    ctx.traceEmitter.emit(
-      "request_error",
-      "Surface action rejected — queue full",
-      {
-        requestId,
-        status: "error",
-        attributes: { reason: "queue_full", source: "surface_action" },
-      },
-    );
-    onEvent(
-      buildSessionErrorMessage(ctx.conversationId, {
-        code: "QUEUE_FULL",
-        userMessage:
-          "Message queue is full (max depth: 10). Please wait for current messages to be processed.",
-        retryable: true,
-        debugDetails: "Surface action rejected — session queue is full",
-      }),
-    );
-    return;
-  }
-
   if (!retainPending) {
     ctx.pendingSurfaceActions.delete(surfaceId);
   }
@@ -959,7 +931,7 @@ export function buildUserFacingLabel(
 
 /**
  * Resolve a proxy tool call that targets a UI surface.
- * Handles ui_show, ui_update, ui_dismiss, request_file, computer_use_request_control, and app_open.
+ * Handles ui_show, ui_update, ui_dismiss, computer_use_request_control, and app_open.
  */
 export async function surfaceProxyResolver(
   ctx: SurfaceSessionContext,
@@ -980,56 +952,6 @@ export async function surfaceProxyResolver(
     }
   }
 
-  if (toolName === "request_file") {
-    const surfaceId = uuid();
-    const prompt =
-      typeof input.prompt === "string" ? input.prompt : "Please share a file";
-    const acceptedTypes = Array.isArray(input.accepted_types)
-      ? (input.accepted_types as string[])
-      : undefined;
-    const maxFiles = typeof input.max_files === "number" ? input.max_files : 1;
-
-    const data: FileUploadSurfaceData = {
-      prompt,
-      acceptedTypes,
-      maxFiles,
-    };
-
-    ctx.surfaceState.set(surfaceId, { surfaceType: "file_upload", data });
-
-    ctx.sendToClient({
-      type: "ui_surface_show",
-      sessionId: ctx.conversationId,
-      surfaceId,
-      surfaceType: "file_upload",
-      title: "File Request",
-      data,
-    } as UiSurfaceShow);
-
-    // Track surface for persistence
-    ctx.currentTurnSurfaces.push({
-      surfaceId,
-      surfaceType: "file_upload",
-      title: "File Request",
-      data,
-    });
-
-    // Non-blocking: return immediately, user action arrives as follow-up message
-    ctx.pendingSurfaceActions.set(surfaceId, {
-      surfaceType: "file_upload" as SurfaceType,
-    });
-    return {
-      content: JSON.stringify({
-        surfaceId,
-        status: "awaiting_user_action",
-        message:
-          "File upload dialog displayed and the user can see it. The uploaded file data will arrive as a follow-up message. Do not output any waiting message — just stop here.",
-      }),
-      isError: false,
-      yieldToUser: true,
-    };
-  }
-
   if (toolName === "ui_show") {
     const surfaceId = uuid();
     const surfaceType = input.surface_type as SurfaceType;