@vellumai/assistant 0.6.4 → 0.6.5

package/src/daemon/conversation-attachments.ts

@@ -107,7 +107,7 @@ export async function approveHostAttachmentRead(
   const response = await prompter.prompt(
     toolName,
     input,
-    await classifyRisk(toolName, input, workingDir),
+    (await classifyRisk(toolName, input, workingDir)).level,
     await generateAllowlistOptions(toolName, input),
     generateScopeOptions(workingDir, toolName),
     undefined,
@@ -116,8 +116,7 @@ export async function approveHostAttachmentRead(
   );
 
   if (
-    (response.decision === "always_allow" ||
-      response.decision === "always_allow_high_risk") &&
+    response.decision === "always_allow" &&
     response.selectedPattern &&
     response.selectedScope
   ) {
@@ -127,9 +126,6 @@ export async function approveHostAttachmentRead(
       response.selectedScope,
       "allow",
       100,
-      response.decision === "always_allow_high_risk"
-        ? { allowHighRisk: true }
-        : undefined,
     );
   }
   if (

package/src/daemon/conversation-error.ts

@@ -86,6 +86,14 @@ const WEB_SEARCH_ORDERING_PATTERNS = [
   /web_search.*tool_result/i,
 ];
 
+// Stale/invalid opaque `encrypted_content` token in replayed web-search results.
+// Anthropic's tokens have bounded validity; the daemon replaces historical
+// `web_search_tool_result` blocks with text summaries to avoid this, but this
+// classifier remains as defense-in-depth for any path that bypasses the strip.
+const STALE_WEB_SEARCH_CONTENT_PATTERNS = [
+  /invalid\s+`?encrypted_content`?\s+in\s+`?(?:web_)?search_result`?\s+block/i,
+];
+
 // Streaming corruption patterns (Anthropic SDK throws non-HTTP errors for SSE issues)
 const STREAMING_ERROR_PATTERNS = [
   /unexpected event order/i,
@@ -113,7 +121,7 @@ export interface ErrorContext {
  * instead of `conversation_error`.
  *
  * Provider SDKs wrap the underlying AbortError in their own error class
- * (e.g. `ProviderError("Anthropic API error (undefined): Request was aborted.")`),
+ * (e.g. `ProviderError("Anthropic API error: Request was aborted.")`),
  * which erases the `AbortError` name. To compensate, the daemon tags every
  * `controller.abort(reason)` call with an `AbortReason` object — when the
  * wrapped `ProviderError` carries that tagged reason, we treat it as a user
@@ -302,6 +310,15 @@ function classifyCore(
           errorCategory: "web_search_ordering",
         };
       }
+      if (isStaleWebSearchContent(message)) {
+        return {
+          code: "PROVIDER_WEB_SEARCH",
+          userMessage:
+            "Stale web-search results in conversation history. Please try again.",
+          retryable: true,
+          errorCategory: "stale_web_search_content",
+        };
+      }
       if (isOrderingError(message)) {
         return {
           code: "PROVIDER_ORDERING",
@@ -354,6 +371,15 @@ export function isWebSearchOrderingError(message: string): boolean {
   return WEB_SEARCH_ORDERING_PATTERNS.some((p) => p.test(message));
 }
 
+/**
+ * Check whether an error message indicates a stale/invalid `encrypted_content`
+ * opaque token in a replayed `web_search_tool_result`. See
+ * `stripHistoricalWebSearchResults()` for the proactive mitigation.
+ */
+export function isStaleWebSearchContent(message: string): boolean {
+  return STALE_WEB_SEARCH_CONTENT_PATTERNS.some((p) => p.test(message));
+}
+
 /** Check whether an error message indicates a tool_use/tool_result ordering failure. */
 export function isOrderingError(message: string): boolean {
   return ORDERING_ERROR_PATTERNS.some((p) => p.test(message));
@@ -414,6 +440,15 @@ function classifyByMessage(
       errorCategory: "web_search_ordering",
     };
   }
+  if (isStaleWebSearchContent(message)) {
+    return {
+      code: "PROVIDER_WEB_SEARCH",
+      userMessage:
+        "Stale web-search results in conversation history. Please try again.",
+      retryable: true,
+      errorCategory: "stale_web_search_content",
+    };
+  }
 
   // General tool_use/tool_result ordering errors
   if (isOrderingError(message)) {

package/src/daemon/conversation-lifecycle.ts

@@ -25,10 +25,7 @@ import {
   type TrustClass,
 } from "../runtime/actor-trust-resolver.js";
 import { unregisterConversationSender } from "../tools/browser/browser-screencast.js";
-import {
-  type AbortReason,
-  createAbortReason,
-} from "../util/abort-reasons.js";
+import { type AbortReason, createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import {
   unregisterCallNotifiers,
@@ -65,7 +62,9 @@ function parseProvenanceTrustClass(
   return undefined;
 }
 
-function filterMessagesForUntrustedActor(messages: MessageRow[]): MessageRow[] {
+export function filterMessagesForUntrustedActor(
+  messages: MessageRow[],
+): MessageRow[] {
   return messages.filter((m) => {
     const provenanceTrustClass = parseProvenanceTrustClass(m.metadata);
     return (
@@ -191,7 +190,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
 
   const parsedMessages: Message[] = dbMessages
     .slice(ctx.contextCompactedMessageCount)
-    .map((m) => {
+    .map((m, index, arr) => {
       const role = m.role as "user" | "assistant";
       let content: ContentBlock[];
       try {
@@ -214,6 +213,24 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
       if (role === "user" && m.metadata) {
         try {
           const meta = JSON.parse(m.metadata);
+          const isTail = index === arr.length - 1;
+
+          // turn_context and system_reminder rehydrate for historical rows
+          // only; the tail gets fresh blocks via applyRuntimeInjections on
+          // the next turn. All three rehydration steps are prepends — the
+          // ordering below (system_reminder first, memory second,
+          // turn_context last) builds the documented shape right-to-left,
+          // since each prepend shifts previously-prepended blocks one slot
+          // right:
+          //   [<turn_context>, <memory __injected>, <system_reminder>, ...original]
+          if (!isTail && typeof meta.pkbSystemReminderBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.pkbSystemReminderBlock },
+              ...content,
+            ];
+          }
+
+          // Memory remains rehydrated on all rows (existing behavior).
           if (typeof meta.memoryInjectedBlock === "string") {
             content = [
               {
@@ -223,6 +240,13 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
               ...content,
             ];
           }
+
+          if (!isTail && typeof meta.turnContextBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.turnContextBlock },
+              ...content,
+            ];
+          }
         } catch {
           /* ignore parse errors — metadata may be malformed */
         }

package/src/daemon/conversation-messaging.ts

@@ -32,11 +32,16 @@ import {
   syncMessageToDisk,
   updateMetaFile,
 } from "../memory/conversation-disk-view.js";
+import {
+  type SlackMessageMetadata,
+  writeSlackMetadata,
+} from "../messaging/providers/slack/message-metadata.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 import type { MessageQueue } from "./conversation-queue-manager.js";
 import type { TrustContext } from "./conversation-runtime-assembly.js";
+import type { SlackInboundMessageMetadata } from "./handlers/shared.js";
 import type {
   ServerMessage,
   UserMessageAttachment,
@@ -100,17 +105,17 @@ const INGRESS_SECRET_TARGETS: Record<string, IngressSecretTarget> = {
     label: "SendGrid API Key",
   },
   "Slack Bot Token": {
-    service: "slack",
+    service: "slack_channel",
     field: "bot_token",
     label: "Slack Bot Token",
   },
   "Slack User Token": {
-    service: "slack",
+    service: "slack_channel",
     field: "user_token",
     label: "Slack User Token",
   },
   "Slack Webhook": {
-    service: "slack",
+    service: "slack_channel",
     field: "webhook_url",
     label: "Slack Webhook URL",
   },
@@ -210,6 +215,53 @@ function extractTurnInterfaceContext(
   return { userMessageInterface, assistantMessageInterface };
 }
 
+/**
+ * Build the Slack metadata envelope persisted under the `slackMeta` key on a
+ * user message's `metadata` JSON. Returns `null` (do not include the key) when
+ * the turn is not Slack-originated or the channel ingress did not supply
+ * Slack-specific metadata.
+ *
+ * The conversation is the source of truth for the inbound channel for this
+ * turn — `userMessageChannel` is set by `Server.processMessage` from
+ * `transport.channelId`. Guarding on this ensures non-Slack flows (telegram,
+ * voice, etc.) never get a `slackMeta` key even if a stale plumbing field
+ * leaks through.
+ */
+export function buildSlackMetaForPersistence(params: {
+  slackInbound: unknown;
+  turnChannel: string | undefined;
+}): string | null {
+  if (params.turnChannel !== "slack") {
+    return null;
+  }
+  const inbound = params.slackInbound;
+  if (
+    inbound === null ||
+    typeof inbound !== "object" ||
+    Array.isArray(inbound)
+  ) {
+    return null;
+  }
+  const candidate = inbound as Partial<SlackInboundMessageMetadata>;
+  if (
+    typeof candidate.channelId !== "string" ||
+    !candidate.channelId ||
+    typeof candidate.channelTs !== "string" ||
+    !candidate.channelTs
+  ) {
+    return null;
+  }
+  const slackMeta: SlackMessageMetadata = {
+    source: "slack",
+    channelId: candidate.channelId,
+    channelTs: candidate.channelTs,
+    eventKind: "message",
+    ...(candidate.threadTs ? { threadTs: candidate.threadTs } : {}),
+    ...(candidate.displayName ? { displayName: candidate.displayName } : {}),
+  };
+  return writeSlackMetadata(slackMeta);
+}
+
 // ── enqueueMessage ───────────────────────────────────────────────────
 
 export function enqueueMessage(
@@ -224,6 +276,7 @@ export function enqueueMessage(
   options?: { isInteractive?: boolean },
   displayContent?: string,
   transport?: ConversationTransportMetadata,
+  clientMessageId?: string,
 ): { queued: boolean; requestId: string; rejected?: boolean } {
   if (!ctx.processing) {
     return { queued: false, requestId };
@@ -251,6 +304,7 @@ export function enqueueMessage(
     transport,
     displayContent,
     sentAt: Date.now(),
+    clientMessageId,
   });
   if (!accepted) {
     onEvent({
@@ -362,8 +416,22 @@ export async function persistQueuedMessageBody(
       }
     }
 
+    // Strip the transient `slackInbound` carrier key from the persisted
+    // metadata — it's an in-memory plumbing field, not a stored column value.
+    // The caller-supplied metadata may include it (channel ingress threads it
+    // through `Server.processMessage`); we materialize it into the typed
+    // `slackMeta` sub-key below when the turn channel is Slack.
+    const { slackInbound: rawSlackInbound, ...metadataWithoutSlackInbound } =
+      (metadata ?? {}) as Record<string, unknown> & {
+        slackInbound?: SlackInboundMessageMetadata;
+      };
+    const slackMeta = buildSlackMetaForPersistence({
+      slackInbound: rawSlackInbound,
+      turnChannel: turnCtx?.userMessageChannel,
+    });
+
     const mergedMetadata = {
-      ...(metadata ?? {}),
+      ...metadataWithoutSlackInbound,
       ...provenance,
       ...(turnCtx
         ? {
@@ -378,6 +446,7 @@ export async function persistQueuedMessageBody(
           }
         : {}),
       ...(Object.keys(imageSourcePaths).length > 0 ? { imageSourcePaths } : {}),
+      ...(slackMeta ? { slackMeta } : {}),
     };
 
     // When displayContent is provided (e.g. original text before recording

package/src/daemon/conversation-process.ts

@@ -20,6 +20,7 @@ import {
   type TurnInterfaceContext,
 } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ContextWindowResult } from "../context/window-manager.js";
 import { listPendingRequestsByConversationScope } from "../memory/canonical-guardian-store.js";
 import {
@@ -140,6 +141,7 @@ export interface ProcessConversationContext {
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
+      callSite?: LLMCallSite;
     },
   ): Promise<void>;
   getTurnChannelContext(): TurnChannelContext | null;
@@ -259,9 +261,9 @@ function buildSlashContext(
     messageCount: conversation.messages.length,
     inputTokens: conversation.usageStats.inputTokens,
     outputTokens: conversation.usageStats.outputTokens,
-    maxInputTokens: config.contextWindow.maxInputTokens,
-    model: config.services.inference.model,
-    provider: config.services.inference.provider,
+    maxInputTokens: config.llm.default.contextWindow.maxInputTokens,
+    model: config.llm.default.model,
+    provider: config.llm.default.provider,
     estimatedCost: conversation.usageStats.estimatedCost,
     userMessageInterface: turnInterface?.userMessageInterface,
   };
@@ -798,6 +800,7 @@ async function drainSingleMessage(
     conversationId: conversation.conversationId,
     messageId: userMessageId,
     requestId: next.requestId,
+    clientMessageId: next.clientMessageId,
   });
 
   // Set the active surface for the dequeued message so runAgentLoop can inject context
@@ -1148,6 +1151,7 @@ async function drainBatch(
       conversationId: conversation.conversationId,
       messageId: lastUserMessageId,
       requestId: qm.requestId,
+      clientMessageId: qm.clientMessageId,
     });
 
     // Persist succeeded. Update last-successful markers so a later tail
@@ -1291,7 +1295,7 @@ export async function processMessage(
   requestId?: string,
   activeSurfaceId?: string,
   currentPage?: string,
-  options?: { isInteractive?: boolean },
+  options?: { isInteractive?: boolean; callSite?: LLMCallSite },
   displayContent?: string,
 ): Promise<string> {
   await conversation.ensureActorScopedHistory();
@@ -1647,11 +1651,13 @@ export async function processMessage(
     isInteractive?: boolean;
     isUserMessage?: boolean;
     titleText?: string;
+    callSite?: LLMCallSite;
   } = { isUserMessage: true };
   if (options?.isInteractive !== undefined)
     loopOptions.isInteractive = options.isInteractive;
   if (agentLoopContent !== resolvedContent)
     loopOptions.titleText = resolvedContent;
+  if (options?.callSite !== undefined) loopOptions.callSite = options.callSite;
 
   await conversation.runAgentLoop(
     agentLoopContent,

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

@@ -36,6 +36,9 @@ export interface QueuedMessage {
   displayContent?: string;
   /** Wall-clock time (ms since epoch) when the message was enqueued, used as the display timestamp. */
   sentAt: number;
+  /** Client-generated correlation nonce. Echoed back on `user_message_echo`
+   *  so the originating client can dedupe its optimistic row. */
+  clientMessageId?: string;
 }
 
 /**