@vellumai/assistant 0.4.49 → 0.4.51

package/src/daemon/host-cu-proxy.ts

@@ -9,6 +9,7 @@
 
 import { v4 as uuid } from "uuid";
 
+import { escapeAxTreeContent } from "../agent/loop.js";
 import type { ContentBlock } from "../providers/types.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -65,6 +66,7 @@ interface PendingRequest {
 export class HostCuProxy {
   private pending = new Map<string, PendingRequest>();
   private sendToClient: (msg: ServerMessage) => void;
+  private onInternalResolve?: (requestId: string) => void;
   private clientConnected = false;
 
   // CU state tracking (per-conversation)
@@ -76,9 +78,11 @@ export class HostCuProxy {
 
   constructor(
     sendToClient: (msg: ServerMessage) => void,
+    onInternalResolve?: (requestId: string) => void,
     maxSteps = MAX_STEPS,
   ) {
     this.sendToClient = sendToClient;
+    this.onInternalResolve = onInternalResolve;
     this._maxSteps = maxSteps;
   }
 
@@ -150,6 +154,7 @@ export class HostCuProxy {
     return new Promise<ToolExecutionResult>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(requestId);
+        this.onInternalResolve?.(requestId);
         log.warn({ requestId, toolName }, "Host CU proxy request timed out");
         resolve({
           content: "Host CU proxy timed out waiting for client response",
@@ -164,6 +169,7 @@ export class HostCuProxy {
           if (this.pending.has(requestId)) {
             clearTimeout(timer);
             this.pending.delete(requestId);
+            this.onInternalResolve?.(requestId);
             resolve({ content: "Aborted", isError: true });
           }
         };
@@ -191,10 +197,13 @@ export class HostCuProxy {
     clearTimeout(entry.timer);
     this.pending.delete(requestId);
 
+    // Capture pre-update state so formatObservation sees the correct previous AX tree
+    const prevAXTree = this._previousAXTree;
+
     // Update CU state from observation
     this.updateStateFromObservation(observation);
 
-    const result = this.formatObservation(observation);
+    const result = this.formatObservation(observation, prevAXTree);
     entry.resolve(result);
   }
 
@@ -202,6 +211,10 @@ export class HostCuProxy {
     return this.pending.has(requestId);
   }
 
+  isAvailable(): boolean {
+    return this.clientConnected;
+  }
+
   // ---------------------------------------------------------------------------
   // CU state management
   // ---------------------------------------------------------------------------
@@ -245,7 +258,11 @@ export class HostCuProxy {
    * (AX tree wrapped in markers, diff, warnings) and optional screenshot
    * as an image content block.
    */
-  formatObservation(obs: CuObservationResult): ToolExecutionResult {
+  formatObservation(
+    obs: CuObservationResult,
+    previousAXTree?: string,
+  ): ToolExecutionResult {
+    const prevTree = previousAXTree;
     const parts: string[] = [];
 
     // Surface user guidance prominently so the model sees it first
@@ -263,21 +280,30 @@ export class HostCuProxy {
     if (obs.axDiff) {
       parts.push(obs.axDiff);
       parts.push("");
-    } else if (this._previousAXTree != null && obs.axTree != null) {
-      // No diff means the screen didn't change
-      if (
-        this._consecutiveUnchangedSteps >=
-        CONSECUTIVE_UNCHANGED_WARNING_THRESHOLD
-      ) {
-        parts.push(
-          `WARNING: ${this._consecutiveUnchangedSteps} consecutive actions had NO VISIBLE EFFECT on the UI. You MUST try a completely different approach.`,
-        );
-      } else {
-        parts.push(
-          "Your last action had NO VISIBLE EFFECT on the UI. Try something different.",
-        );
+    } else if (prevTree != null && obs.axTree != null) {
+      // Skip unchanged warning after wait actions — they intentionally yield no immediate change
+      const lastAction =
+        this._actionHistory.length > 0
+          ? this._actionHistory[this._actionHistory.length - 1]
+          : undefined;
+      const isWaitAction = lastAction?.toolName === "computer_use_wait";
+
+      if (!isWaitAction) {
+        // No diff means the screen didn't change
+        if (
+          this._consecutiveUnchangedSteps >=
+          CONSECUTIVE_UNCHANGED_WARNING_THRESHOLD
+        ) {
+          parts.push(
+            `WARNING: ${this._consecutiveUnchangedSteps} consecutive actions had NO VISIBLE EFFECT on the UI. You MUST try a completely different approach.`,
+          );
+        } else {
+          parts.push(
+            "Your last action had NO VISIBLE EFFECT on the UI. Try something different.",
+          );
+        }
+        parts.push("");
       }
-      parts.push("");
     }
 
     // Loop detection: identical actions repeated
@@ -300,10 +326,20 @@ export class HostCuProxy {
     if (obs.axTree) {
       parts.push("<ax-tree>");
       parts.push("CURRENT SCREEN STATE:");
-      parts.push(HostCuProxy.escapeAxTreeContent(obs.axTree));
+      parts.push(escapeAxTreeContent(obs.axTree));
       parts.push("</ax-tree>");
     }
 
+    // Secondary windows for cross-app awareness
+    if (obs.secondaryWindows) {
+      parts.push("");
+      parts.push(obs.secondaryWindows);
+      parts.push("");
+      parts.push(
+        "Note: The element [ID]s above are from other windows — you can reference them for context but can only interact with the focused window's elements.",
+      );
+    }
+
     // Screenshot metadata
     const screenshotMeta = this.formatScreenshotMetadata(obs);
     if (screenshotMeta.length > 0) {
@@ -342,8 +378,9 @@ export class HostCuProxy {
   // ---------------------------------------------------------------------------
 
   dispose(): void {
-    for (const [_requestId, entry] of this.pending) {
+    for (const [requestId, entry] of this.pending) {
       clearTimeout(entry.timer);
+      this.onInternalResolve?.(requestId);
       entry.reject(
         new AssistantError("Host CU proxy disposed", ErrorCode.INTERNAL_ERROR),
       );
@@ -390,12 +427,4 @@ export class HostCuProxy {
     }
     return lines;
   }
-
-  /**
-   * Escapes literal `</ax-tree>` inside AX tree content so compaction
-   * regex does not stop prematurely.
-   */
-  static escapeAxTreeContent(content: string): string {
-    return content.replace(/<\/ax-tree>/gi, "&lt;/ax-tree&gt;");
-  }
 }

package/src/daemon/lifecycle.ts

@@ -26,13 +26,18 @@ import { closeSentry, initSentry } from "../instrument.js";
 import { disableLogfire, initLogfire } from "../logfire.js";
 import { getMcpServerManager } from "../mcp/manager.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
+import { expireAllPendingCanonicalRequests } from "../memory/canonical-guardian-store.js";
 import {
   deleteMessageById,
   getConversationThreadType,
   getMessages,
 } from "../memory/conversation-crud.js";
 import { initializeDb } from "../memory/db.js";
-import { selectEmbeddingBackend } from "../memory/embedding-backend.js";
+import {
+  selectEmbeddingBackend,
+  SPARSE_EMBEDDING_VERSION,
+} from "../memory/embedding-backend.js";
+import { enqueueMemoryJob } from "../memory/jobs-store.js";
 import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
 import { initQdrantClient } from "../memory/qdrant-client.js";
 import { QdrantManager } from "../memory/qdrant-manager.js";
@@ -162,9 +167,28 @@ export async function runDaemon(): Promise<void> {
     // Backfill oauth_connection rows for manual-token providers (Telegram,
     // Slack channel) that already have keychain credentials from before the
     // oauth_connection migration. Safe to call on every startup.
-    await backfillManualTokenConnections();
+    try {
+      await backfillManualTokenConnections();
+    } catch (err) {
+      log.warn(
+        { err },
+        "Manual-token connection backfill failed — continuing startup",
+      );
+    }
     log.info("Daemon startup: DB initialized");
 
+    // Expire any pending canonical guardian requests left over from before
+    // this process started.  Their in-memory pending-interaction session
+    // references are gone, so they can never be completed.  The agent loop
+    // will re-request tool approvals on the next turn.
+    const expiredCount = expireAllPendingCanonicalRequests();
+    if (expiredCount > 0) {
+      log.info(
+        { event: "startup_expired_stale_requests", expiredCount },
+        `Expired ${expiredCount} stale pending canonical request(s) from previous process`,
+      );
+    }
+
     // Ensure a vellum guardian binding exists and mint the CLI edge token
     // as an actor token bound to the guardian principal.
     let guardianPrincipalId: string | undefined;
@@ -305,9 +329,9 @@ export async function runDaemon(): Promise<void> {
       await qdrantManager.start();
       const embeddingSelection = selectEmbeddingBackend(config);
       const embeddingModel = embeddingSelection.backend
-        ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}`
+        ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}:sparse-v${SPARSE_EMBEDDING_VERSION}`
         : undefined;
-      initQdrantClient({
+      const qdrantClient = initQdrantClient({
         url: qdrantUrl,
         collection: config.memory.qdrant.collection,
         vectorSize: config.memory.qdrant.vectorSize,
@@ -315,6 +339,17 @@ export async function runDaemon(): Promise<void> {
         quantization: config.memory.qdrant.quantization,
         embeddingModel,
       });
+
+      // Eagerly ensure the collection exists so we detect migrations
+      // (unnamed→named vectors, dimension/model changes) at startup.
+      // If a destructive migration occurred, enqueue a rebuild_index job
+      // to re-embed all memory items from the SQLite cache.
+      const { migrated } = await qdrantClient.ensureCollection();
+      if (migrated) {
+        enqueueMemoryJob("rebuild_index", {});
+        log.info("Qdrant collection was migrated — enqueued rebuild_index job");
+      }
+
       log.info("Qdrant vector store initialized");
     } catch (err) {
       log.warn(

package/src/daemon/mcp-reload-service.ts

@@ -1,8 +1,8 @@
 /**
  * Shared MCP reload business logic.
  *
- * Used by the HTTP route (`runtime/routes/mcp-routes.ts`) so the reload
- * behaviour is defined in exactly one place.
+ * Called by the ConfigWatcher when config.json changes or a reload signal
+ * file is detected, so the daemon automatically reconnects MCP servers.
  */
 
 import { getConfig, invalidateConfigCache } from "../config/loader.js";

package/src/daemon/message-types/computer-use.ts

@@ -1,4 +1,4 @@
-// Computer use, task routing, and watch observation types.
+// Computer use and watch observation types.
 
 import type { CommandIntent, UserMessageAttachment } from "./shared.js";
 
@@ -89,16 +89,6 @@ export interface RecordingResume {
   recordingId: string;
 }
 
-export interface TaskRouted {
-  type: "task_routed";
-  sessionId: string;
-  interactionType: "computer_use" | "text_qa";
-  /** The task text passed to the escalated session. */
-  task?: string;
-  /** Set when a text_qa session escalates to computer_use. */
-  escalatedFrom?: string;
-}
-
 export interface WatchStarted {
   type: "watch_started";
   sessionId: string;
@@ -121,7 +111,6 @@ export type _ComputerUseClientMessages =
   | RecordingStatus;
 
 export type _ComputerUseServerMessages =
-  | TaskRouted
   | WatchStarted
   | WatchCompleteRequest
   | RecordingStart

package/src/daemon/message-types/memory.ts

@@ -11,7 +11,6 @@ export interface MemoryRecalledCandidateDebug {
   type: string;
   kind: string;
   finalScore: number;
-  lexical: number;
   semantic: number;
   recency: number;
 }
@@ -21,18 +20,14 @@ export interface MemoryRecalled {
   provider: string;
   model: string;
   degradation?: MemoryRecalledDegradation;
-  lexicalHits: number;
   semanticHits: number;
   recencyHits: number;
-  entityHits: number;
-  relationSeedEntityCount?: number;
-  relationTraversedEdgeCount?: number;
-  relationNeighborEntityCount?: number;
-  relationExpandedItemCount?: number;
-  earlyTerminated?: boolean;
+  tier1Count: number;
+  tier2Count: number;
+  hybridSearchLatencyMs: number;
+  sparseVectorUsed: boolean;
   mergedCount: number;
   selectedCount: number;
-  rerankApplied: boolean;
   injectedTokens: number;
   latencyMs: number;
   topCandidates: MemoryRecalledCandidateDebug[];
@@ -46,13 +41,6 @@ export interface MemoryStatus {
   reason?: string;
   provider?: string;
   model?: string;
-  conflictsPending: number;
-  conflictsResolved: number;
-  oldestPendingConflictAgeMs: number | null;
-  cleanupResolvedJobsPending: number;
-  cleanupSupersededJobsPending: number;
-  cleanupResolvedJobsCompleted24h: number;
-  cleanupSupersededJobsCompleted24h: number;
 }
 
 // --- Domain-level union aliases (consumed by the barrel file) ---

package/src/daemon/message-types/messages.ts

@@ -290,6 +290,7 @@ export interface AssistantActivityState {
     | "tool_result_received"
     | "confirmation_requested"
     | "confirmation_resolved"
+    | "context_compacting"
     | "message_complete"
     | "generation_cancelled"
     | "error_terminal";

package/src/daemon/message-types/sessions.ts

@@ -85,35 +85,6 @@ export interface ImageGenModelSetRequest {
   model: string;
 }
 
-export interface HistoryRequest {
-  type: "history_request";
-  sessionId: string;
-  /** Max messages to return. When omitted, all messages are returned (unlimited). */
-  limit?: number;
-  /** Pagination cursor: return messages with timestamp before this value. */
-  beforeTimestamp?: number;
-  /** Pagination cursor tie-breaker: exclude this message ID when beforeTimestamp matches. */
-  beforeMessageId?: string;
-  /** Include attachment base64 data. Defaults to false in light mode. */
-  includeAttachments?: boolean;
-  /** Include tool screenshot base64 data. Defaults to false in light mode. */
-  includeToolImages?: boolean;
-  /** Include surface HTML payloads. Defaults to false in light mode. */
-  includeSurfaceData?: boolean;
-  /** Shorthand: 'light' = all include flags false (default), 'full' = all include flags true. */
-  mode?: "light" | "full";
-  /** Truncate message text fields beyond this character limit. When omitted, full text is returned. */
-  maxTextChars?: number;
-  /** Truncate tool result strings beyond this character limit. When omitted, full results are returned. */
-  maxToolResultChars?: number;
-}
-
-export interface MessageContentRequest {
-  type: "message_content_request";
-  sessionId: string;
-  messageId: string;
-}
-
 export interface MessageContentResponse {
   type: "message_content_response";
   sessionId: string;
@@ -145,16 +116,6 @@ export interface SessionsClearRequest {
   type: "sessions_clear";
 }
 
-export interface ConversationSearchRequest {
-  type: "conversation_search";
-  /** The search query string. */
-  query: string;
-  /** Maximum number of conversations to return. Defaults to 20. */
-  limit?: number;
-  /** Maximum number of matching messages to return per conversation. Defaults to 3. */
-  maxMessagesPerConversation?: number;
-}
-
 export interface ReorderThreadsRequest {
   type: "reorder_threads";
   updates: Array<{
@@ -394,6 +355,8 @@ export type SessionErrorCode =
   | "PROVIDER_RATE_LIMIT"
   | "PROVIDER_API"
   | "PROVIDER_BILLING"
+  | "PROVIDER_ORDERING"
+  | "PROVIDER_WEB_SEARCH"
   | "CONTEXT_TOO_LARGE"
   | "SESSION_ABORTED"
   | "SESSION_PROCESSING_FAILED"
@@ -407,6 +370,8 @@ export interface SessionErrorMessage {
   userMessage: string;
   retryable: boolean;
   debugDetails?: string;
+  /** Machine-readable error category for log report metadata and triage. */
+  errorCategory?: string;
 }
 
 /** Server push — broadcast when a schedule creates a conversation, so the client can show it as a chat thread. */
@@ -427,7 +392,6 @@ export type _SessionsClientMessages =
   | ModelGetRequest
   | ModelSetRequest
   | ImageGenModelSetRequest
-  | HistoryRequest
   | UndoRequest
   | RegenerateRequest
   | UsageRequest
@@ -436,8 +400,6 @@ export type _SessionsClientMessages =
   | SessionSwitchRequest
   | SessionRenameRequest
   | SessionsClearRequest
-  | ConversationSearchRequest
-  | MessageContentRequest
   | ReorderThreadsRequest;
 
 export type _SessionsServerMessages =

package/src/daemon/server.ts

@@ -663,8 +663,13 @@ export class DaemonServer {
         );
       }
       if (!session.isProcessing() || !session.hostCuProxy) {
-        session.setHostCuProxy(new HostCuProxy(session.getCurrentSender()));
+        session.setHostCuProxy(
+          new HostCuProxy(session.getCurrentSender(), (requestId) => {
+            pendingInteractions.resolve(requestId);
+          }),
+        );
       }
+      session.addPreactivatedSkillId("computer-use");
     } else if (!session.isProcessing()) {
       session.setHostBashProxy(undefined);
       session.setHostFileProxy(undefined);

package/src/daemon/session-agent-loop-handlers.ts

@@ -57,6 +57,8 @@ export interface EventHandlerState {
   orderingErrorDetected: boolean;
   deferredOrderingError: string | null;
   contextTooLargeDetected: boolean;
+  /** The raw error message from the provider when context_too_large is detected. */
+  contextTooLargeErrorMessage: string | null;
   providerErrorUserMessage: string | null;
   lastAssistantMessageId: string | undefined;
   readonly pendingToolResults: Map<string, PendingToolResult>;
@@ -121,6 +123,7 @@ export function createEventHandlerState(): EventHandlerState {
     orderingErrorDetected: false,
     deferredOrderingError: null,
     contextTooLargeDetected: false,
+    contextTooLargeErrorMessage: null,
     providerErrorUserMessage: null,
     lastAssistantMessageId: undefined,
     pendingToolResults: new Map(),
@@ -595,12 +598,22 @@ export function handleError(
     state.deferredOrderingError = event.error.message;
   } else if (isContextTooLarge(event.error.message)) {
     state.contextTooLargeDetected = true;
+    state.contextTooLargeErrorMessage = event.error.message;
   } else {
     const classified = classifySessionError(event.error, {
       phase: "agent_loop",
     });
     if (classified.code === "CONTEXT_TOO_LARGE") {
       state.contextTooLargeDetected = true;
+      state.contextTooLargeErrorMessage = event.error.message;
+    } else if (
+      classified.code === "PROVIDER_ORDERING" ||
+      classified.code === "PROVIDER_WEB_SEARCH"
+    ) {
+      // Ordering errors detected via classifySessionError (e.g. from ProviderError
+      // with statusCode 400 and ordering message) — trigger the retry path.
+      state.orderingErrorDetected = true;
+      state.deferredOrderingError = event.error.message;
     } else {
       deps.onEvent(
         buildSessionErrorMessage(deps.ctx.conversationId, classified),
@@ -831,6 +844,31 @@ export async function dispatchAgentEvent(
         deps.reqId,
         statusText,
       );
+      // Emit tool_use_start so the client renders a tool chip (like other tools)
+      deps.onEvent({
+        type: "tool_use_start",
+        toolName: event.name,
+        input: event.input,
+        sessionId: deps.ctx.conversationId,
+        toolUseId: event.toolUseId,
+      });
+      break;
+    }
+    case "server_tool_complete": {
+      deps.ctx.emitActivityState(
+        "streaming",
+        "tool_result_received",
+        "assistant_turn",
+        deps.reqId,
+      );
+      deps.onEvent({
+        type: "tool_result",
+        toolName: "",
+        result: "",
+        isError: false,
+        sessionId: deps.ctx.conversationId,
+        toolUseId: event.toolUseId,
+      });
       break;
     }
     case "error":