@vellumai/assistant 0.8.0 → 0.8.2

package/src/daemon/conversation-error.ts

@@ -16,6 +16,35 @@ export interface ClassifiedConversationError {
   debugDetails?: string;
   /** Machine-readable error category for log report metadata and triage. */
   errorCategory: string;
+  /**
+   * Name of the `provider_connections` row in play when the error
+   * occurred. Forwarded to the wire `ConversationErrorMessage` so chat
+   * banners can point users at the specific slot to fix. Only set by
+   * classifiers / callers that have the resolved connection in scope —
+   * generic regex fallbacks leave it undefined.
+   */
+  connectionName?: string;
+  /**
+   * Name of the resolved profile (`llm.activeProfile` / per-call override)
+   * in play when the error occurred. Forwarded to the wire message so
+   * banners can name the profile when the connection identifier is
+   * generic (e.g. the canonical managed connection). Optional for the
+   * same reason as `connectionName`.
+   */
+  profileName?: string;
+}
+
+/**
+ * Optional resolved-config context that callers can attach to error
+ * classification so the resulting `ConversationErrorMessage` can name the
+ * exact connection / profile in play. Used in particular by the chat
+ * dispatch sites to make `PROVIDER_INVALID_KEY` and `PROVIDER_NOT_CONFIGURED`
+ * actionable (the macOS banner reads these to render "Invalid API key for
+ * profile X" instead of a generic "API key required").
+ */
+export interface ConversationErrorAttribution {
+  connectionName?: string;
+  profileName?: string;
 }
 
 // Network-level error patterns (connection refused, timeout, DNS, reset)
@@ -120,6 +149,13 @@ const STREAMING_ERROR_PATTERNS = [
 ];
 
 // User-initiated cancellation patterns — these should NOT produce conversation_error
+// Image-input validation patterns — Anthropic 400s with this message when an image
+// block exceeds the per-side pixel cap. Distinct classification matters because
+// retrying with the same oversized image is futile; the user needs to resize.
+const IMAGE_DIMENSIONS_TOO_LARGE_PATTERNS = [
+  /image dimensions? exceeds? max allowed size/i,
+];
+
 const CANCEL_PATTERNS = [/abort/i, /cancel/i];
 
 /**
@@ -130,6 +166,20 @@ export interface ErrorContext {
   phase: "agent_loop" | "regenerate" | "handler" | "persist";
   /** Whether the abort signal was active when the error occurred. */
   aborted?: boolean;
+  /**
+   * Optional name of the `provider_connections` row in play. Plumbed by
+   * dispatch sites that know the resolved connection (chat agent loop)
+   * so credential-related classifications (`PROVIDER_INVALID_KEY`,
+   * `PROVIDER_NOT_CONFIGURED`) can name the exact slot to fix.
+   */
+  connectionName?: string;
+  /**
+   * Optional name of the resolved profile in play. Plumbed alongside
+   * `connectionName` by dispatch sites; surfaces in the wire message so
+   * the macOS chat banner can reference the profile even when the
+   * underlying connection name is generic.
+   */
+  profileName?: string;
 }
 
 /**
@@ -188,32 +238,43 @@ export function classifyConversationError(
     (error instanceof Error ? error.stack : undefined) ?? message;
   const debugDetails = truncateDebugDetails(rawDetails);
 
+  // Extract optional attribution (connection / profile names) so
+  // credential-related classifications can name the exact slot to fix.
+  // A `ProviderNotConfiguredError` instance carries its own attribution
+  // (from the throw site) which takes priority over context when present.
+  const attribution: ConversationErrorAttribution = {
+    ...(ctx.connectionName ? { connectionName: ctx.connectionName } : {}),
+    ...(ctx.profileName ? { profileName: ctx.profileName } : {}),
+  };
+
   // Dedicated classification for missing provider API key
   if (error instanceof ProviderNotConfiguredError) {
     return {
-      code: "PROVIDER_NOT_CONFIGURED",
-      userMessage:
-        "No API key configured for inference. Add one in Settings to start chatting.",
-      retryable: true,
-      errorCategory: "provider_not_configured",
+      ...providerNotConfiguredClassification({
+        connectionName:
+          error.connectionName ?? attribution.connectionName,
+        profileName: error.profileName ?? attribution.profileName,
+      }),
       debugDetails,
     };
   }
 
   // Phase-specific overrides
   if (ctx.phase === "regenerate") {
-    const base = classifyCore(error, message);
+    const base = classifyCore(error, message, attribution);
     return {
       code: "REGENERATE_FAILED",
       userMessage: `Could not regenerate the response. ${base.userMessage}`,
       retryable: true,
       debugDetails,
       errorCategory: `regenerate:${base.errorCategory}`,
+      ...(base.connectionName ? { connectionName: base.connectionName } : {}),
+      ...(base.profileName ? { profileName: base.profileName } : {}),
     };
   }
 
   // Classify using statusCode (if ProviderError) then regex fallback
-  const classified = classifyCore(error, message);
+  const classified = classifyCore(error, message, attribution);
   return {
     ...classified,
     debugDetails,
@@ -223,10 +284,16 @@ export function classifyConversationError(
 /**
  * Core classification: check ProviderError.statusCode first for
  * deterministic classification, then fall back to regex patterns.
+ *
+ * `attribution` carries the resolved connection / profile names (when the
+ * caller knows them) so credential-related results can name the exact
+ * slot for the user to fix. Pass an empty object when no attribution is
+ * available — the classifier falls back to a generic message.
  */
 function classifyCore(
   error: unknown,
   message: string,
+  attribution: ConversationErrorAttribution = {},
 ): Omit<ClassifiedConversationError, "debugDetails"> {
   // ProviderError with statusCode — deterministic classification
   if (error instanceof ProviderError && error.statusCode !== undefined) {
@@ -240,39 +307,33 @@ function classifyCore(
       };
     }
     if (error.statusCode === 401 || error.statusCode === 403) {
-      if (
-        /invalid.*api.?key|invalid.*x-api-key|authentication.?error/i.test(
-          message,
-        )
-      ) {
-        // Check if this provider is routed through the managed proxy.
-        // If so, the assistant API key is stale — the client should reprovision.
-        const providerName = error.provider;
-        if (getProviderRoutingSource(providerName) === "managed-proxy") {
-          return {
-            code: "MANAGED_KEY_INVALID",
-            userMessage:
-              "The assistant API key is invalid. Attempting to re-provision…",
-            retryable: true,
-            errorCategory: "managed_key_invalid",
-          };
-        }
+      // Both managed-proxy and user-key 401/403s reach this branch.
+      // Managed-proxy routes through the assistant API key (stale → re-
+      // provision) and emits `MANAGED_KEY_INVALID`; everything else is a
+      // user-set credential that the upstream provider rejected → emit
+      // `PROVIDER_INVALID_KEY` so the macOS chat banner renders an
+      // "Invalid API key" surface (distinct from "API key required"
+      // which only fires when the key is genuinely missing — see
+      // `providerNotConfiguredClassification`).
+      const providerName = error.provider;
+      if (getProviderRoutingSource(providerName) === "managed-proxy") {
         return {
-          code: "PROVIDER_NOT_CONFIGURED",
+          code: "MANAGED_KEY_INVALID",
           userMessage:
-            "Your API key is invalid or expired. Update it in Settings or switch to managed mode.",
-          retryable: false,
-          errorCategory: "provider_not_configured",
+            "The assistant API key is invalid. Attempting to re-provision…",
+          retryable: true,
+          errorCategory: "managed_key_invalid",
         };
       }
+      return invalidApiKeyClassification(attribution);
     }
     if (error.statusCode === 401) {
       return {
-        code: "PROVIDER_NOT_CONFIGURED",
+        code: "PROVIDER_INVALID_KEY",
         userMessage:
           "Your API key is invalid or expired. Update it in Settings or switch to managed mode.",
         retryable: false,
-        errorCategory: "provider_not_configured",
+        errorCategory: "provider_invalid_key",
       };
     }
     if (error.statusCode === 402) {
@@ -362,12 +423,18 @@ function classifyCore(
           message,
         )
       ) {
+        // Mirror the 401/403 branch: a credential-shaped 4xx is an
+        // "invalid key" surface (banner: "Invalid API key"), distinct
+        // from "no key configured" (banner: "API key required").
+        return invalidApiKeyClassification(attribution);
+      }
+      if (isImageDimensionsTooLarge(message)) {
         return {
-          code: "PROVIDER_NOT_CONFIGURED",
+          code: "IMAGE_TOO_LARGE",
           userMessage:
-            "Your API key is invalid. Update it in Settings or switch to managed mode.",
+            "An attached image is too large for the AI provider — image dimensions must be under 8000 pixels per side. Resize the image and try again.",
           retryable: false,
-          errorCategory: "provider_not_configured",
+          errorCategory: "image_dimensions_too_large",
         };
       }
       return {
@@ -388,6 +455,11 @@ export function isContextTooLarge(message: string): boolean {
   return CONTEXT_TOO_LARGE_PATTERNS.some((p) => p.test(message));
 }
 
+/** Check whether an error message indicates an image-input dimension failure. */
+function isImageDimensionsTooLarge(message: string): boolean {
+  return IMAGE_DIMENSIONS_TOO_LARGE_PATTERNS.some((p) => p.test(message));
+}
+
 /** Check whether an error message indicates a web-search-specific ordering failure. */
 function isWebSearchOrderingError(message: string): boolean {
   return WEB_SEARCH_ORDERING_PATTERNS.some((p) => p.test(message));
@@ -456,6 +528,80 @@ function providerBillingClassification(): Omit<
   };
 }
 
+/**
+ * Build a user-facing message that names the exact profile / connection
+ * to fix when one is known, falling back to a generic phrase otherwise.
+ * Profile is preferred because that's the entity the user picks in the
+ * chat picker; connection is shown when no profile is in play (e.g.
+ * `llm.default` direct dispatch) or as a parenthetical when both differ.
+ */
+function describeAttribution(
+  attribution: ConversationErrorAttribution | undefined,
+): string {
+  if (!attribution) return "";
+  const { profileName, connectionName } = attribution;
+  if (profileName && connectionName && profileName !== connectionName) {
+    return ` for profile "${profileName}" (connection "${connectionName}")`;
+  }
+  if (profileName) return ` for profile "${profileName}"`;
+  if (connectionName) return ` for connection "${connectionName}"`;
+  return "";
+}
+
+/**
+ * Classification for an invalid (rejected by the upstream provider, e.g.
+ * Anthropic 401/403) API key. Distinct from `PROVIDER_NOT_CONFIGURED`
+ * (which is for a key that was never set) so the macOS chat banner can
+ * render "Invalid API key" rather than "API key required" — they have
+ * different recovery actions (update vs. add).
+ */
+function invalidApiKeyClassification(
+  attribution?: ConversationErrorAttribution,
+): Omit<ClassifiedConversationError, "debugDetails"> {
+  const target = describeAttribution(attribution);
+  return {
+    code: "PROVIDER_INVALID_KEY",
+    userMessage: target
+      ? `The API key${target} was rejected by the provider. Update it in Settings.`
+      : "Your API key was rejected by the provider. Update it in Settings.",
+    retryable: false,
+    errorCategory: "provider_invalid_key",
+    ...(attribution?.connectionName
+      ? { connectionName: attribution.connectionName }
+      : {}),
+    ...(attribution?.profileName
+      ? { profileName: attribution.profileName }
+      : {}),
+  };
+}
+
+/**
+ * Classification for a genuinely-missing provider credential — vault has
+ * no entry for the resolved connection's `auth.credential`, or no
+ * provider is registered at all. The macOS chat banner renders this as
+ * "API key required" with an "Open Settings" CTA. Distinct from
+ * `PROVIDER_INVALID_KEY` (where a key exists but was rejected).
+ */
+function providerNotConfiguredClassification(
+  attribution?: ConversationErrorAttribution,
+): Omit<ClassifiedConversationError, "debugDetails"> {
+  const target = describeAttribution(attribution);
+  return {
+    code: "PROVIDER_NOT_CONFIGURED",
+    userMessage: target
+      ? `No API key configured${target}. Add one in Settings to start chatting.`
+      : "No API key configured for inference. Add one in Settings to start chatting.",
+    retryable: true,
+    errorCategory: "provider_not_configured",
+    ...(attribution?.connectionName
+      ? { connectionName: attribution.connectionName }
+      : {}),
+    ...(attribution?.profileName
+      ? { profileName: attribution.profileName }
+      : {}),
+  };
+}
+
 function classifyByMessage(
   error: unknown,
   message: string,
@@ -629,5 +775,14 @@ export function buildConversationErrorMessage(
     retryable: classified.retryable,
     debugDetails: classified.debugDetails,
     errorCategory: classified.errorCategory,
+    // Optional attribution — only forwarded when the classifier was able
+    // to pin the failure to a specific provider connection / profile.
+    // The macOS chat banner reads these to render targeted CTAs.
+    ...(classified.connectionName
+      ? { connectionName: classified.connectionName }
+      : {}),
+    ...(classified.profileName
+      ? { profileName: classified.profileName }
+      : {}),
   };
 }

package/src/daemon/conversation-lifecycle.ts

@@ -17,6 +17,8 @@ import {
   type MessageRow,
 } from "../memory/conversation-crud.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
+import { enqueueMemoryRetrospectiveIfEnabled } from "../memory/memory-retrospective-enqueue.js";
+import { shouldExposePersonalMemory } from "../memory/v2/static-context.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { ContentBlock, Message } from "../providers/types.js";
@@ -30,12 +32,14 @@ import { getLogger } from "../util/logger.js";
 import { unregisterCallNotifiers } from "./conversation-notifiers.js";
 import type { MessageQueue } from "./conversation-queue-manager.js";
 import { resetSkillToolProjection } from "./conversation-skill-tools.js";
+import { resolveTrustClass } from "./conversation-tool-setup.js";
 import { repairHistory } from "./history-repair.js";
 import type {
   SurfaceData,
   SurfaceType,
   UsageStats,
 } from "./message-protocol.js";
+import type { TrustContext } from "./trust-context.js";
 
 const log = getLogger("conversation-lifecycle");
 
@@ -112,8 +116,9 @@ export interface LoadFromDbContext {
   usageStats: UsageStats;
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
-  trustContext?: { trustClass: TrustClass };
+  trustContext?: TrustContext;
   loadedHistoryTrustClass?: TrustClass;
+  loadedHistoryPersonalMemoryAllowed?: boolean;
 }
 
 export interface AbortContext {
@@ -183,6 +188,16 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
     ctx.contextCompactedAt = conv?.contextCompactedAt ?? null;
   }
 
+  // Mirror the injection-time gate (`shouldExposePersonalMemory` in
+  // `conversation-agent-loop.ts`) so background/local conversations
+  // (sourceChannel `undefined` or `"vellum"`) can rehydrate the persisted
+  // v2 static memory block. Use `resolveTrustClass` for parity with the
+  // agent loop — it folds in the HTTP-auth-disabled dev bypass so
+  // rehydration and injection agree on the effective trust class.
+  const personalMemoryAllowed = shouldExposePersonalMemory({
+    sourceChannel: ctx.trustContext?.sourceChannel,
+    isTrustedActor: resolveTrustClass(ctx.trustContext) === "guardian",
+  });
   const parsedMessages: Message[] = dbMessages
     .slice(ctx.contextCompactedMessageCount)
     .map((m, index, arr) => {
@@ -210,20 +225,19 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
           const meta = JSON.parse(m.metadata);
           const isTail = index === arr.length - 1;
 
-          // All rehydration steps are prepends — the ordering below
-          // (innermost block first, outermost last) builds the documented
-          // shape right-to-left, since each prepend shifts previously-
-          // prepended blocks one slot right:
-          //   [<workspace>, <turn_context>, <NOW.md>, <memory __injected>,
-          //    <system_reminder>, <knowledge_base>, ...original]
-          //
-          // Persisted non-tail rows rehydrate the full set so Anthropic's
-          // prefix cache keeps matching msg[0] across daemon restarts and
-          // conversation eviction. The tail row gets fresh blocks via
-          // applyRuntimeInjections on the next turn, so rehydration for the
-          // tail is limited to blocks that the next turn's injection pipeline
-          // cannot reconstruct (currently just `memoryInjectedBlock`, which
-          // is not always re-injected on the next turn).
+          // Rehydrate in reverse injection order (innermost block first)
+          // so the resulting layout matches `applyRuntimeInjections`'s
+          // after-memory-prefix splices in ascending injector order
+          // (pkb-context 30, pkb-reminder 35, memory-v2-static 38,
+          // now-md 40 — the v2 static block lands inside the memory
+          // prefix, so now-md splices *after* it):
+          //   [<workspace>, <turn_context>, <memory __injected>,
+          //    <memory>\n…</memory>, <NOW.md>, <system_reminder>,
+          //    <knowledge_base>, ...original]
+          // Required so Anthropic's prefix cache keeps matching msg[0]
+          // across daemon restart and conversation eviction. The tail
+          // row only rehydrates `memoryInjectedBlock` — the next turn
+          // re-injects the rest fresh.
           if (!isTail && typeof meta.pkbContextBlock === "string") {
             content = [
               { type: "text" as const, text: meta.pkbContextBlock },
@@ -238,15 +252,44 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
             ];
           }
 
+          if (!isTail && typeof meta.nowScratchpadBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.nowScratchpadBlock },
+              ...content,
+            ];
+          }
+
+          // The v2 static memory block (essentials/threads/recent/buffer
+          // wrapped in `<memory>…</memory>`) carries personal user memory.
+          // Trust-gated to mirror `shouldExposePersonalMemory` at injection
+          // time — untrusted-actor views must not read persisted personal
+          // memory back through metadata. Skipped on the tail row because
+          // the next turn re-injects fresh content on full-mode turns.
+          if (
+            !isTail &&
+            personalMemoryAllowed &&
+            typeof meta.memoryV2StaticBlock === "string"
+          ) {
+            content = [
+              { type: "text" as const, text: meta.memoryV2StaticBlock },
+              ...content,
+            ];
+          }
+
           // Memory remains rehydrated on all rows (existing behavior).
           // Strip any pre-existing wrapper before re-wrapping so historical
           // rows persisted with the wrapper (v2 path before the
           // injectedBlockText contract was unified with v1's unwrapped form)
-          // don't render double-wrapped after rehydrate.
+          // don't render double-wrapped after rehydrate. Only unwrap when
+          // the full <memory>...</memory> pair is present so we don't mutate
+          // legitimate unwrapped payloads that happen to start with
+          // "<memory>\n" or end with "\n</memory>".
           if (typeof meta.memoryInjectedBlock === "string") {
-            const inner = meta.memoryInjectedBlock
-              .replace(/^<memory>\n/, "")
-              .replace(/\n<\/memory>$/, "");
+            const block = meta.memoryInjectedBlock;
+            const inner =
+              block.startsWith("<memory>\n") && block.endsWith("\n</memory>")
+                ? block.slice("<memory>\n".length, -"\n</memory>".length)
+                : block;
             content = [
               {
                 type: "text" as const,
@@ -256,13 +299,6 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
             ];
           }
 
-          if (!isTail && typeof meta.nowScratchpadBlock === "string") {
-            content = [
-              { type: "text" as const, text: meta.nowScratchpadBlock },
-              ...content,
-            ];
-          }
-
           if (!isTail && typeof meta.turnContextBlock === "string") {
             content = [
               { type: "text" as const, text: meta.turnContextBlock },
@@ -311,6 +347,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
   }
 
   ctx.loadedHistoryTrustClass = trustClass;
+  ctx.loadedHistoryPersonalMemoryAllowed = personalMemoryAllowed;
 
   log.info(
     { conversationId: ctx.conversationId, count: ctx.messages.length },
@@ -398,6 +435,23 @@ export function disposeConversation(ctx: DisposeContext): void {
           // Best-effort — don't block conversation disposal
         }
       }
+
+      try {
+        // Memory-retrospective lifecycle safety-net. The periodic triggers
+        // (interval / message_count / pre-compaction) handle the common
+        // path; lifecycle catches the gap between the last interval fire
+        // and conversation eviction. The job's `no_new_messages` early
+        // return makes this a cheap no-op when the periodic path already
+        // covered things. Lives inside the `!isAutoAnalysis` guard so
+        // auto-analysis conversations don't trigger retrospective enqueues
+        // on disposal — mirrors the indexer-time gate in `indexer.ts`.
+        enqueueMemoryRetrospectiveIfEnabled({
+          conversationId: ctx.conversationId,
+          trigger: "lifecycle",
+        });
+      } catch {
+        // Best-effort — don't block conversation disposal
+      }
     }
 
     try {

package/src/daemon/conversation-messaging.ts

@@ -7,7 +7,10 @@
 
 import { v4 as uuid } from "uuid";
 
-import { enrichMessageWithSourcePaths } from "../agent/attachments.js";
+import {
+  enrichMessageWithSourcePaths,
+  type MessageAttachmentInput,
+} from "../agent/attachments.js";
 import { createUserMessage } from "../agent/message-types.js";
 import type {
   TurnChannelContext,
@@ -191,6 +194,19 @@ export interface MessagingConversationContext {
   getTurnInterfaceContext(): TurnInterfaceContext | null;
 }
 
+export function serializePersistedUserMessageContent(
+  content: string,
+  attachments: MessageAttachmentInput[],
+  displayContent: string | undefined,
+): string {
+  return JSON.stringify(
+    createUserMessage(
+      displayContent !== undefined ? displayContent : content,
+      attachments,
+    ).content,
+  );
+}
+
 function extractTurnChannelContext(
   metadata?: Record<string, unknown>,
 ): TurnChannelContext | null {
@@ -258,6 +274,9 @@ export function buildSlackMetaForPersistence(params: {
     eventKind: "message",
     ...(candidate.threadTs ? { threadTs: candidate.threadTs } : {}),
     ...(candidate.displayName ? { displayName: candidate.displayName } : {}),
+    ...(candidate.actorExternalUserId
+      ? { actorExternalUserId: candidate.actorExternalUserId }
+      : {}),
   };
   return writeSlackMetadata(slackMeta);
 }
@@ -454,11 +473,11 @@ export async function persistQueuedMessageBody(
     // intent stripping), persist that to DB so users see the full message
     // after restart. The in-memory userMessage (sent to the LLM) still uses
     // the stripped content.
-    const contentToPersist = displayContent
-      ? JSON.stringify(
-          createUserMessage(displayContent, attachmentInputs).content,
-        )
-      : JSON.stringify(cleanMessage.content);
+    const contentToPersist = serializePersistedUserMessageContent(
+      content,
+      attachmentInputs,
+      displayContent,
+    );
     const persistedUserMessage = await addMessage(
       ctx.conversationId,
       "user",