@vellumai/assistant 0.8.5 → 0.8.6

package/src/daemon/conversation-agent-loop.ts

@@ -59,6 +59,7 @@ import { commitAppTurnChanges } from "../memory/app-git-service.js";
 import { getApp, listAppFiles, resolveAppDir } from "../memory/app-store.js";
 import { enqueueAutoAnalysisOnCompaction } from "../memory/auto-analysis-enqueue.js";
 import {
+  deleteMessageById,
   getConversation,
   getConversationOriginChannel,
   getConversationOriginInterface,
@@ -79,7 +80,10 @@ import {
 } from "../memory/conversation-title-service.js";
 import { isBackgroundConversationType } from "../memory/conversation-types.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
-import { backfillMessageIdOnLogs } from "../memory/llm-request-log-store.js";
+import {
+  backfillMessageIdOnLogs,
+  recordSyntheticAgentErrorMessageLog,
+} from "../memory/llm-request-log-store.js";
 import { recordMemoryRecallLog } from "../memory/memory-recall-log-store.js";
 import { enqueueMemoryRetrospectiveOnCompaction } from "../memory/memory-retrospective-enqueue.js";
 import { PKB_WORKSPACE_SCOPE } from "../memory/pkb/types.js";
@@ -216,16 +220,37 @@ import type {
 } from "./message-protocol.js";
 import type { MemoryRecalled } from "./message-types/memory.js";
 import type { ConfirmationStateChanged } from "./message-types/messages.js";
-import {
-  conversationMetadataSyncTag,
-  SYNC_TAGS,
-} from "./message-types/sync.js";
+import { conversationMetadataSyncTag } from "./message-types/sync.js";
 import { parseActualTokensFromError } from "./parse-actual-tokens-from-error.js";
 import type { TraceEmitter } from "./trace-emitter.js";
 import type { TrustContext } from "./trust-context.js";
 import { stripHistoricalWebSearchResults } from "./web-search-history.js";
 
 const log = getLogger("conversation-agent-loop");
+
+/**
+ * Best-effort persistence of the history-stripped marker after an
+ * injection-strip event (compaction / overflow recovery). The marker is a
+ * durability hint, not turn-critical state — a transient SQLite write failure
+ * (SQLITE_BUSY, disk-full, read-only FS) must not abort the turn. Logs a
+ * warning and continues on failure, preserving the long-standing non-fatal
+ * contract for this metadata write.
+ */
+function markHistoryStrippedBestEffort(
+  conversationId: string,
+  strippedAt: number,
+  logger: ReturnType<typeof getLogger>,
+): void {
+  try {
+    setConversationHistoryStrippedAt(conversationId, strippedAt);
+  } catch (err) {
+    logger.warn(
+      { err },
+      "Failed to persist history-stripped marker after compaction strip (non-fatal)",
+    );
+  }
+}
+
 const DISK_PRESSURE_ERROR_CODE = "DISK_SPACE_CRITICAL" as const;
 const DISK_PRESSURE_ERROR_CATEGORY = "disk_pressure";
 
@@ -513,7 +538,12 @@ export interface AgentLoopConversationContext {
     surfaceType: SurfaceType;
     title?: string;
     data: SurfaceData;
-    actions?: Array<{ id: string; label: string; style?: string }>;
+    actions?: Array<{
+      id: string;
+      label: string;
+      style?: string;
+      data?: Record<string, unknown>;
+    }>;
     display?: string;
     persistent?: boolean;
   }>;
@@ -541,12 +571,6 @@ export interface AgentLoopConversationContext {
    * turn start.
    */
   toolRoutedProfile?: string;
-  /**
-   * True when the user has explicitly selected an inference profile for this
-   * conversation (via the composer profile picker). When set, tool-based
-   * auto-routing is suppressed — the user's explicit choice takes precedence.
-   */
-  hasExplicitProfileOverride?: boolean;
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   trustContext?: TrustContext;
   /** Task-run scope for the current turn. Cleared at turn end so queued/drained turns don't inherit it. */
@@ -724,8 +748,6 @@ export async function runAgentLoopImpl(
     options?.overrideProfile ??
     getConversationOverrideProfileFromRow(turnStartConversation);
 
-  ctx.hasExplicitProfileOverride = !!userExplicitOverride;
-
   const config = getConfig();
 
   // Tool-based auto-routing: the switch_inference_profile tool lets the model
@@ -746,12 +768,14 @@ export async function runAgentLoopImpl(
     llm: config.llm,
     callSite: turnCallSite,
     overrideProfile: turnOverrideProfile ?? undefined,
+    selectionSeed: ctx.conversationId,
   });
   let currentEffectiveContextWindow: EffectiveContextWindow =
     effectiveContextWindow;
   let currentContextWindowConfig = contextWindowConfigFromEffective(
     resolveCallSiteConfig(turnCallSite, config.llm, {
       overrideProfile: turnOverrideProfile ?? undefined,
+      selectionSeed: ctx.conversationId,
     }).contextWindow,
     currentEffectiveContextWindow,
   );
@@ -770,10 +794,12 @@ export async function runAgentLoopImpl(
         llm: config.llm,
         callSite: turnCallSite,
         overrideProfile: currentOverrideProfile,
+        selectionSeed: ctx.conversationId,
       });
       currentContextWindowConfig = contextWindowConfigFromEffective(
         resolveCallSiteConfig(turnCallSite, config.llm, {
           overrideProfile: currentOverrideProfile,
+          selectionSeed: ctx.conversationId,
         }).contextWindow,
         currentEffectiveContextWindow,
       );
@@ -1028,10 +1054,7 @@ export async function runAgentLoopImpl(
           });
           onEvent({
             type: "sync_changed",
-            tags: [
-              SYNC_TAGS.conversationsList,
-              conversationMetadataSyncTag(ctx.conversationId),
-            ],
+            tags: [conversationMetadataSyncTag(ctx.conversationId)],
           });
         },
       };
@@ -2312,7 +2335,7 @@ export async function runAgentLoopImpl(
       // so we compact the "raw" persistent messages.
       const rawHistory = stripInjectionsForCompaction(updatedHistory);
       ctx.messages = rawHistory;
-      setConversationHistoryStrippedAt(ctx.conversationId, Date.now());
+      markHistoryStrippedBestEffort(ctx.conversationId, Date.now(), rlog);
 
       ctx.emitActivityState(
         "thinking",
@@ -2596,7 +2619,7 @@ export async function runAgentLoopImpl(
 
       if (updatedHistory.length > preRunHistoryLength) {
         ctx.messages = stripInjectionsForCompaction(updatedHistory);
-        setConversationHistoryStrippedAt(ctx.conversationId, Date.now());
+        markHistoryStrippedBestEffort(ctx.conversationId, Date.now(), rlog);
         convergenceStripped = true;
         preRepairMessages = updatedHistory;
         preRunHistoryLength = updatedHistory.length;
@@ -2841,7 +2864,7 @@ export async function runAgentLoopImpl(
           // pre-rerun messages.
           if (updatedHistory.length > preRunHistoryLength) {
             ctx.messages = stripInjectionsForCompaction(updatedHistory);
-            setConversationHistoryStrippedAt(ctx.conversationId, Date.now());
+            markHistoryStrippedBestEffort(ctx.conversationId, Date.now(), rlog);
             convergenceStripped = true;
             preRepairMessages = updatedHistory;
             preRunHistoryLength = updatedHistory.length;
@@ -3110,8 +3133,12 @@ export async function runAgentLoopImpl(
         assistantMessageInterface:
           capturedTurnInterfaceContext.assistantMessageInterface,
       };
+      let yieldNoticePersistedId: string | null = null;
       try {
-        await runPipeline<PersistArgs, PersistResult>(
+        const yieldPersistResult = (await runPipeline<
+          PersistArgs,
+          PersistResult
+        >(
           "persistence",
           getMiddlewaresFor("persistence"),
           defaultPersistenceTerminal,
@@ -3124,7 +3151,8 @@ export async function runAgentLoopImpl(
           },
           buildPluginTurnContext(ctx, reqId),
           DEFAULT_TIMEOUTS.persistence,
-        );
+        )) as PersistAddResult;
+        yieldNoticePersistedId = yieldPersistResult.message.id;
       } catch (err) {
         // Non-fatal — a DB hiccup must not escalate a budget-yield exit into
         // a turn-level throw. The live SSE event was already emitted, so the
@@ -3134,6 +3162,48 @@ export async function runAgentLoopImpl(
           "Failed to persist budget_yield_unrecovered notice (non-fatal)",
         );
       }
+      // Record a synthetic `llm_request_logs` row for the yield so the
+      // inspector's call rail surfaces a clickable, distinctly-rendered
+      // entry for the failure itself. Without this row, the loop yields
+      // silently — the user sees the notice in chat but the inspector
+      // call list ends at the last actual LLM call with no way to scope
+      // the "what compactions led to this failure?" question to the
+      // yield event.
+      //
+      // Recorded *before* emitTerminalExit so the synthetic row exists
+      // by the time the dispatcher's post-loop hook runs. The row
+      // already carries `agent_loop_exit_reason` at insert time, so
+      // `setAgentLoopExitReasonOnLatestLog`'s IS NULL guard skips it
+      // and stamps the prior real mainAgent call instead — preserving
+      // the existing "latest LLM call carries the exit reason"
+      // invariant other consumers depend on.
+      //
+      // `preparedRequest` snapshots the best-known LLM request state
+      // at yield time — `updatedHistory` (the conversation state the
+      // next call would have been built from) plus the input-token
+      // budget that just failed. Mirrors the role of `request_payload`
+      // on real LLM-call rows; the notice text lives on
+      // `response_payload`.
+      if (yieldNoticePersistedId !== null && budgetYieldClassification) {
+        try {
+          recordSyntheticAgentErrorMessageLog({
+            conversationId: ctx.conversationId,
+            messageId: yieldNoticePersistedId,
+            exitReason: "budget_yield_unrecovered",
+            noticeText: budgetYieldClassification.userMessage,
+            preparedRequest: {
+              messages: updatedHistory,
+              maxInputTokensBudget: resolveCurrentMaxInputTokens() ?? null,
+            },
+            createdAt: Date.now(),
+          });
+        } catch (err) {
+          rlog.warn(
+            { err },
+            "Failed to record budget_yield_unrecovered synthetic call log (non-fatal)",
+          );
+        }
+      }
       await emitTerminalExit?.("budget_yield_unrecovered");
     }
 
@@ -3154,6 +3224,34 @@ export async function runAgentLoopImpl(
       !abortController.signal.aborted &&
       !yieldedForHandoff
     ) {
+      // Drop any reservation stranded by the failed LLM call before
+      // inserting the synthetic error message. The B3 pre-allocation
+      // path reserves an empty assistant row at `llm_call_started`;
+      // when the call exits through the provider-error branch (no
+      // `message_complete`), `assistantRowAwaitingFinalization` stays
+      // true. Without this delete the transcript would carry both the
+      // empty reserved row AND the error message — and downstream sync
+      // (`syncLastAssistantMessageToDisk`) would mis-target the empty
+      // row. After delete we set `lastAssistantMessageId` to the new
+      // error row's id so the post-loop emission paths still point at
+      // a real message.
+      if (
+        state.assistantRowAwaitingFinalization &&
+        state.lastAssistantMessageId
+      ) {
+        // Direct `deleteMessageById` (not via the `persistence` pipeline):
+        // see the same rationale on the matching cleanup in
+        // `handleLlmCallStarted` — an unfinalized reservation has no
+        // observable history for plugins.
+        try {
+          deleteMessageById(state.lastAssistantMessageId);
+        } catch (err) {
+          rlog.warn(
+            { err, messageId: state.lastAssistantMessageId },
+            "Failed to clean up stranded reserved assistant row on provider-error path (non-fatal)",
+          );
+        }
+      }
       const errChannelMeta = {
         ...provenanceFromTrustContext(ctx.trustContext),
         userMessageChannel: capturedTurnChannelContext.userMessageChannel,
@@ -3181,6 +3279,15 @@ export async function runAgentLoopImpl(
         DEFAULT_TIMEOUTS.persistence,
       )) as PersistAddResult;
       persistedErrorAssistantMessage = true;
+      // Repoint `lastAssistantMessageId` at the synthetic error row so the
+      // post-loop sync, attachment resolution, and `message_complete`/
+      // `generation_handoff` emissions all reference a real, persisted
+      // message id. The previous reservation (if any) was already deleted
+      // above. Mark finalization complete so the next LLM call in this run
+      // (or a downstream handler) doesn't try to clean up an id that
+      // already corresponds to a finalized row.
+      state.lastAssistantMessageId = errorPersistResult.message.id;
+      state.assistantRowAwaitingFinalization = false;
       newMessages.push(errorAssistantMessage);
       // Pipe the just-assigned message id into any orphaned LLM request log
       // row(s) for this turn. The success path links rows via
@@ -3446,10 +3553,7 @@ export async function runAgentLoopImpl(
           });
           onEvent({
             type: "sync_changed",
-            tags: [
-              SYNC_TAGS.conversationsList,
-              conversationMetadataSyncTag(ctx.conversationId),
-            ],
+            tags: [conversationMetadataSyncTag(ctx.conversationId)],
           });
         },
         signal: abortController.signal,
@@ -3694,7 +3798,7 @@ export async function applyCompactionResult(
     result.summaryText,
     ctx.contextCompactedMessageCount,
   );
-  setConversationHistoryStrippedAt(ctx.conversationId, compactedAt);
+  markHistoryStrippedBestEffort(ctx.conversationId, compactedAt, log);
   if (options.slackContextCompactionWatermarkTs) {
     updateConversationSlackContextWatermark(
       ctx.conversationId,

package/src/daemon/conversation-error.ts

@@ -1,3 +1,4 @@
+import { ConnectionResolutionError } from "../providers/connection-resolution.js";
 import { getProviderRoutingSource } from "../providers/registry.js";
 import { isAbortReason } from "../util/abort-reasons.js";
 import { ProviderError, ProviderNotConfiguredError } from "../util/errors.js";
@@ -251,14 +252,28 @@ export function classifyConversationError(
   if (error instanceof ProviderNotConfiguredError) {
     return {
       ...providerNotConfiguredClassification({
-        connectionName:
-          error.connectionName ?? attribution.connectionName,
+        connectionName: error.connectionName ?? attribution.connectionName,
         profileName: error.profileName ?? attribution.profileName,
       }),
       debugDetails,
     };
   }
 
+  if (error instanceof ConnectionResolutionError) {
+    return {
+      code: "PROVIDER_NOT_CONFIGURED",
+      userMessage:
+        "No compatible provider connection found for this profile. Check your provider connections in Settings.",
+      retryable: true,
+      debugDetails,
+      errorCategory: "provider_not_configured",
+      ...(error.connectionName ? { connectionName: error.connectionName } : {}),
+      ...(attribution.profileName
+        ? { profileName: attribution.profileName }
+        : {}),
+    };
+  }
+
   // Phase-specific overrides
   if (ctx.phase === "regenerate") {
     const base = classifyCore(error, message, attribution);
@@ -790,6 +805,21 @@ export function budgetYieldUnrecoveredClassification(): ClassifiedConversationEr
   };
 }
 
+/**
+ * Classify a model response that stopped because the output-token limit was
+ * reached. The turn may have produced useful partial text, so the recovery is
+ * a follow-up user turn rather than a retry of the same request.
+ */
+export function maxTokensReachedClassification(): ClassifiedConversationError {
+  return {
+    code: "MAX_TOKENS_REACHED",
+    userMessage:
+      "I hit the response limit before I could finish. Continue and I'll pick up from where I stopped.",
+    retryable: true,
+    errorCategory: "max_tokens_reached",
+  };
+}
+
 /**
  * Build a `conversation_error` server message from a classified error.
  */
@@ -811,8 +841,6 @@ export function buildConversationErrorMessage(
     ...(classified.connectionName
       ? { connectionName: classified.connectionName }
       : {}),
-    ...(classified.profileName
-      ? { profileName: classified.profileName }
-      : {}),
+    ...(classified.profileName ? { profileName: classified.profileName } : {}),
   };
 }

package/src/daemon/conversation-messaging.ts

@@ -26,6 +26,7 @@ import {
 } from "../memory/attachments-store.js";
 import {
   addMessage,
+  extractImageSourcePaths,
   getConversation,
   provenanceFromTrustContext,
   setConversationOriginChannelIfUnset,
@@ -284,22 +285,44 @@ export function buildSlackMetaForPersistence(params: {
   return writeSlackMetadata(slackMeta);
 }
 
+// ── EnqueueMessageOptions ────────────────────────────────────────────
+
+/** Options for `enqueueMessage`. Only `content` is required; everything
+ *  else has a sensible default or is genuinely optional. */
+export interface EnqueueMessageOptions {
+  content: string;
+  attachments?: UserMessageAttachment[];
+  onEvent?: (msg: ServerMessage) => void;
+  requestId?: string;
+  activeSurfaceId?: string;
+  currentPage?: string;
+  metadata?: Record<string, unknown>;
+  isInteractive?: boolean;
+  displayContent?: string;
+  transport?: ConversationTransportMetadata;
+  clientMessageId?: string;
+}
+
 // ── enqueueMessage ───────────────────────────────────────────────────
 
 export function enqueueMessage(
   ctx: MessagingConversationContext,
-  content: string,
-  attachments: UserMessageAttachment[],
-  onEvent: (msg: ServerMessage) => void,
-  requestId: string,
-  activeSurfaceId?: string,
-  currentPage?: string,
-  metadata?: Record<string, unknown>,
-  options?: { isInteractive?: boolean },
-  displayContent?: string,
-  transport?: ConversationTransportMetadata,
-  clientMessageId?: string,
+  options: EnqueueMessageOptions,
 ): { queued: boolean; requestId: string; rejected?: boolean } {
+  const {
+    content,
+    attachments = [],
+    onEvent,
+    requestId = crypto.randomUUID(),
+    activeSurfaceId,
+    currentPage,
+    metadata,
+    isInteractive,
+    displayContent,
+    transport,
+    clientMessageId,
+  } = options;
+
   if (!ctx.processing) {
     return { queued: false, requestId };
   }
@@ -316,20 +339,20 @@ export function enqueueMessage(
     content,
     attachments,
     requestId,
-    onEvent,
+    onEvent: onEvent ?? (() => {}),
     activeSurfaceId,
     currentPage,
     metadata,
     turnChannelContext,
     turnInterfaceContext,
-    isInteractive: options?.isInteractive,
+    isInteractive,
     transport,
     displayContent,
     sentAt: Date.now(),
     clientMessageId,
   });
   if (!accepted) {
-    onEvent({
+    onEvent?.({
       type: "error",
       conversationId: ctx.conversationId,
       message:
@@ -341,16 +364,26 @@ export function enqueueMessage(
   return { queued: true, requestId };
 }
 
+// ── PersistMessageOptions ────────────────────────────────────────────
+
+/** Shared options for `persistUserMessage` and `persistQueuedMessageBody`. */
+export interface PersistMessageOptions {
+  content: string;
+  attachments?: UserMessageAttachment[];
+  requestId?: string;
+  metadata?: Record<string, unknown>;
+  displayContent?: string;
+  clientMessageId?: string;
+}
+
 // ── persistUserMessage ───────────────────────────────────────────────
 
 export async function persistUserMessage(
   ctx: MessagingConversationContext,
-  content: string,
-  attachments: UserMessageAttachment[],
-  requestId?: string,
-  metadata?: Record<string, unknown>,
-  displayContent?: string,
-): Promise<string> {
+  options: PersistMessageOptions,
+): Promise<{ id: string; deduplicated: boolean }> {
+  const { content, attachments = [] } = options;
+
   if (ctx.processing) {
     throw new Error("Conversation is already processing a message");
   }
@@ -359,20 +392,23 @@ export async function persistUserMessage(
     throw new Error("Message content or attachments are required");
   }
 
-  const reqId = requestId ?? uuid();
+  const reqId = options.requestId ?? uuid();
   ctx.currentRequestId = reqId;
   ctx.processing = true;
   ctx.abortController = new AbortController();
 
   try {
-    return await persistQueuedMessageBody(
-      ctx,
-      content,
+    const result = await persistQueuedMessageBody(ctx, {
+      ...options,
       attachments,
-      reqId,
-      metadata,
-      displayContent,
-    );
+      requestId: reqId,
+    });
+    if (result.deduplicated) {
+      ctx.processing = false;
+      ctx.abortController = null;
+      ctx.currentRequestId = undefined;
+    }
+    return result;
   } catch (err) {
     ctx.processing = false;
     ctx.abortController = null;
@@ -394,12 +430,16 @@ export async function persistUserMessage(
  */
 export async function persistQueuedMessageBody(
   ctx: MessagingConversationContext,
-  content: string,
-  attachments: UserMessageAttachment[],
-  requestId: string,
-  metadata: Record<string, unknown> | undefined,
-  displayContent: string | undefined,
-): Promise<string> {
+  options: PersistMessageOptions,
+): Promise<{ id: string; deduplicated: boolean }> {
+  const {
+    content,
+    attachments = [],
+    requestId = uuid(),
+    metadata,
+    displayContent,
+    clientMessageId,
+  } = options;
   const attachmentInputs = attachments.map((attachment) => ({
     id: attachment.id,
     filename: attachment.filename,
@@ -431,13 +471,7 @@ export async function persistQueuedMessageBody(
     const turnIfCtx =
       extractTurnInterfaceContext(metadata) ?? ctx.getTurnInterfaceContext();
     const provenance = provenanceFromTrustContext(ctx.trustContext);
-    const imageSourcePaths: Record<string, string> = {};
-    for (let i = 0; i < attachments.length; i++) {
-      const a = attachments[i];
-      if (a.filePath && a.mimeType.toLowerCase().startsWith("image/")) {
-        imageSourcePaths[`${i}:${a.filename}`] = a.filePath;
-      }
-    }
+    const imageSourcePaths = extractImageSourcePaths(attachments);
 
     // Strip the transient `slackInbound` carrier key from the persisted
     // metadata — it's an in-memory plumbing field, not a stored column value.
@@ -468,7 +502,7 @@ export async function persistQueuedMessageBody(
             assistantMessageInterface: turnIfCtx.assistantMessageInterface,
           }
         : {}),
-      ...(Object.keys(imageSourcePaths).length > 0 ? { imageSourcePaths } : {}),
+      ...(imageSourcePaths ? { imageSourcePaths } : {}),
       ...(slackMeta ? { slackMeta } : {}),
     };
 
@@ -486,8 +520,15 @@ export async function persistQueuedMessageBody(
       "user",
       contentToPersist,
       mergedMetadata,
+      undefined,
+      clientMessageId,
     );
 
+    if (persistedUserMessage.deduplicated) {
+      ctx.messages.pop();
+      return { id: persistedUserMessage.id, deduplicated: true };
+    }
+
     if (turnCtx) {
       setConversationOriginChannelIfUnset(
         ctx.conversationId,
@@ -569,7 +610,7 @@ export async function persistQueuedMessageBody(
       );
     }
 
-    return persistedUserMessage.id;
+    return { id: persistedUserMessage.id, deduplicated: false };
   } catch (err) {
     ctx.messages.pop();
     throw err;