@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/agent/loop.ts

@@ -1,5 +1,3 @@
-import * as Sentry from "@sentry/node";
-
 import { getConfig } from "../config/loader.js";
 import { isMemoryV3Live } from "../config/memory-v3-gate.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
@@ -14,7 +12,7 @@ import {
 import { spoolAndStubOversizedToolResults } from "../context/tool-result-spool.js";
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import { parseActualTokensFromError } from "../daemon/parse-actual-tokens-from-error.js";
-import type { TrustContext } from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import type {
   AgentLoopExitReason,
   PostCompactInputContext,
@@ -45,6 +43,7 @@ import type {
   ToolResultContent,
 } from "../providers/types.js";
 import { isContextOverflowError } from "../providers/types.js";
+import { getTool } from "../tools/registry.js";
 import type { SensitiveOutputBinding } from "../tools/sensitive-output-placeholders.js";
 import {
   applyStreamingSubstitution,
@@ -52,7 +51,6 @@ import {
 } from "../tools/sensitive-output-placeholders.js";
 import { ProviderError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
-import { isRetryableNetworkError } from "../util/retry.js";
 import { CompactionCircuit } from "./compaction-circuit.js";
 
 const log = getLogger("agent-loop");
@@ -242,7 +240,15 @@ export type AgentEvent =
   | { type: "llm_call_started"; callSite?: LLMCallSite }
   | { type: "text_delta"; text: string }
   | { type: "thinking_delta"; thinking: string }
-  | { type: "message_complete"; message: Message }
+  /**
+   * Emitted once per LLM call when the assistant message is finalized.
+   * `model` is the provider-reported model that served the call
+   * (`response.model`) — the same value `llm_usage` records — so downstream
+   * persistence can attribute the message to the model that actually ran,
+   * including per-call reroutes by a `pre-model-call` hook. Absent on
+   * synthesized emissions that have no provider response.
+   */
+  | { type: "message_complete"; message: Message; model?: string }
   | { type: "max_tokens_reached"; stopReason: string }
   | {
       type: "tool_use";
@@ -337,8 +343,8 @@ export type AgentEvent =
        * has the same `provider` column value as a successful `usage` row.
        *
        * Re-thrown by the inner LLM-call try/catch after emission so the
-       * outer agent-loop catch still handles abort, Sentry capture, the
-       * existing `error` event, and the loop break.
+       * outer agent-loop catch still handles abort, the existing `error`
+       * event, and the loop break.
        */
       type: "provider_error";
       rawRequest: unknown;
@@ -521,42 +527,6 @@ function hasVisibleText(content: ReadonlyArray<ContentBlock>): boolean {
   );
 }
 
-/**
- * User-config HTTP status codes that should never page the on-call: billing
- * exhaustion (402), invalid credentials (401), and forbidden/plan-gated (403).
- * The user-facing error path already surfaces an actionable message (e.g.
- * credits_exhausted); a Sentry issue adds noise without engineering signal.
- */
-const USER_CONFIG_STATUS_CODES = new Set([401, 402, 403]);
-
-/**
- * Whether an agent-loop error should be reported to Sentry. Suppresses:
- *
- *  - `ProviderError` carrying a user-config status code (401/402/403) — these
- *    are bad API keys, exhausted billing, or plan gates, not engineering bugs.
- *  - Retry-exhausted transient network errors (`retriesExhausted === true` +
- *    still categorized as retryable network) — the retry loop already tried
- *    its best; the user's network was flaky, not our code.
- *
- * Everything else (5xx with no retry-exhaustion tag, surprise errors, tool
- * failures, etc.) still pages.
- */
-export function shouldCaptureAgentLoopError(err: Error): boolean {
-  if (
-    err instanceof ProviderError &&
-    err.statusCode !== undefined &&
-    USER_CONFIG_STATUS_CODES.has(err.statusCode)
-  ) {
-    return false;
-  }
-  const exhausted = (err as Error & { retriesExhausted?: boolean })
-    .retriesExhausted;
-  if (exhausted === true && isRetryableNetworkError(err)) {
-    return false;
-  }
-  return true;
-}
-
 type AgentLoopContextWindowResolver = () => {
   maxInputTokens: number;
   overflowRecovery: { enabled: boolean; safetyMarginRatio: number };
@@ -747,14 +717,6 @@ export interface AgentLoopConstructorOptions {
   tools?: ToolDefinition[];
   toolExecutor?: LoopToolExecutor;
   resolveTools?: (history: Message[]) => ToolDefinition[];
-  /**
-   * Decide whether a tool runs exclusively in its turn (see
-   * {@link ToolDefinition.exclusive}). When it returns true for a tool present
-   * in a multi-call turn, the loop runs only that tool and defers the siblings
-   * un-run. Injected by the conversation wiring, which can read the tool
-   * registry; lightweight loops that omit it never defer.
-   */
-  isExclusiveTool?: (toolName: string) => boolean;
   /**
    * Conversation this loop drives. Scopes the loop-held compaction circuit
    * breaker and is the source of truth the loop's pipeline contexts and
@@ -780,7 +742,6 @@ export class AgentLoop {
   private tools: ToolDefinition[];
   private resolveTools: ((history: Message[]) => ToolDefinition[]) | null;
   private toolExecutor: LoopToolExecutor | null;
-  private isExclusiveTool: ((toolName: string) => boolean) | null;
 
   /**
    * Conversation this loop drives. Source of truth for the `conversationId`
@@ -810,7 +771,6 @@ export class AgentLoop {
       tools,
       toolExecutor,
       resolveTools,
-      isExclusiveTool,
       conversationId,
       resolveConversationDir,
     } = options;
@@ -820,7 +780,6 @@ export class AgentLoop {
     this.tools = tools ?? [];
     this.resolveTools = resolveTools ?? null;
     this.toolExecutor = toolExecutor ?? null;
-    this.isExclusiveTool = isExclusiveTool ?? null;
     this.conversationId = conversationId;
     this.resolveConversationDir = resolveConversationDir ?? null;
     this.compactionCircuit = new CompactionCircuit(this.conversationId);
@@ -1719,8 +1678,8 @@ export class AgentLoop {
         // provider rejections. On provider failure we emit `provider_error`
         // with the loop-level raw request so consumers can persist it as an
         // `llm_request_logs` row, then re-throw so the existing outer catch
-        // continues to handle abort sync, Sentry capture, the `error` event,
-        // and the loop break unchanged.
+        // continues to handle abort sync, the `error` event, and the loop
+        // break unchanged.
         // Latency: the request is about to leave for the provider. The span
         // from here to the first streamed token is time-to-first-token.
         latencyTracker?.mark("request_sent");
@@ -1951,6 +1910,7 @@ export class AgentLoop {
             await onEvent({
               type: "message_complete",
               message: safeAssistantMessage,
+              model: response.model,
             });
             history = maxTokensMessages;
             continue;
@@ -1963,6 +1923,7 @@ export class AgentLoop {
           await onEvent({
             type: "message_complete",
             message: safeAssistantMessage,
+            model: response.model,
           });
           await stopTurn("max_tokens_reached");
           break;
@@ -2047,7 +2008,11 @@ export class AgentLoop {
 
         history.push(assistantMessage);
 
-        await onEvent({ type: "message_complete", message: assistantMessage });
+        await onEvent({
+          type: "message_complete",
+          message: assistantMessage,
+          model: response.model,
+        });
 
         if (toolUseBlocks.length === 0 || !this.toolExecutor) {
           // The model stopped requesting tools and `post-model-call` settled on
@@ -2108,9 +2073,9 @@ export class AgentLoop {
         // the siblings with a benign, un-run result so the model re-issues them
         // next turn if still needed. Every tool_use still gets a matching
         // tool_result, so history stays well-formed.
-        const exclusiveBlock = this.isExclusiveTool
-          ? toolUseBlocks.find((block) => this.isExclusiveTool!(block.name))
-          : undefined;
+        const exclusiveBlock = toolUseBlocks.find(
+          (block) => getTool(block.name)?.exclusive === true,
+        );
         const deferSiblings =
           exclusiveBlock !== undefined && toolUseBlocks.length > 1;
         if (deferSiblings) {
@@ -2499,9 +2464,6 @@ export class AgentLoop {
           { err, turn: toolUseTurns, messageCount: history.length },
           "Agent loop error during turn processing",
         );
-        if (shouldCaptureAgentLoopError(err)) {
-          Sentry.captureException(err);
-        }
         onEvent({ type: "error", error: err });
         // Catch-block fallback. A break site that stamped a more specific
         // reason before unwinding here keeps it; the guard makes this a no-op.

package/src/api/responses/conversation-message.ts

@@ -2,7 +2,6 @@
  * Wire contract for the conversation history / messages endpoints.
  *
  *   - `GET /v1/assistants/:id/messages` → `{ messages: ConversationMessage[] }`
- *   - `POST /v1/messages` send acks echo an `assistantMessage: ConversationMessage`
  *
  * Holds the canonical history-row shape produced by the daemon's
  * `renderHistoryContent` + conversation-routes serializer and consumed by
@@ -153,6 +152,15 @@ export const ConversationMessageToolCallSchema = z.object({
   imageData: z.string().optional(),
   /** Base64-encoded image data from tool contentBlocks (e.g. browser_screenshot, image generation). */
   imageDataList: z.array(z.string()).optional(),
+  /**
+   * Workspace attachment ids for tool-result images persisted as workspace
+   * references. When present, clients fetch the image bytes by id on render
+   * (lazy) rather than embedding base64 in the history wire. Positionally
+   * aligned with the tool's rendered images; a row emits either these ids
+   * (referenced media) or `imageDataList` (legacy inline base64), not both for
+   * the same image.
+   */
+  imageAttachmentIds: z.array(z.string()).optional(),
   /** Unix ms when the tool started executing (the `tool_use_start` time). */
   startedAt: z.number().optional(),
   /**
@@ -471,20 +479,6 @@ export const ConversationMessageSchema = z.object({
    * scaffolding, never a displayed turn.
    */
   role: z.enum(["user", "assistant"]),
-  /**
-   * @deprecated Superseded by `contentBlocks`. Flat plain-text body (joined
-   * text segments). Redundant with `textSegments`/`contentOrder` for clients
-   * that render from the positional arrays (web, CLI). The serializer always
-   * emits it — do not remove without auditing clients that read it directly.
-   */
-  content: z
-    .string()
-    .meta({
-      deprecated: true,
-      description:
-        "Deprecated: superseded by contentBlocks. Flat plain-text body (joined text segments).",
-    })
-    .optional(),
   /** Display timestamp as an ISO-8601 string. */
   timestamp: z.string(),
   /**

package/src/approvals/guardian-expiry-notifier.ts

@@ -25,6 +25,7 @@
 import type { CanonicalGuardianRequest } from "../contacts/canonical-guardian-store.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { deliverChannelReply } from "../runtime/gateway-client.js";
+import { introductionMode } from "../runtime/introduction-policy.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { getLogger } from "../util/logger.js";
 import { resolveDeliverCallbackUrlForChannel } from "./guardian-channel-delivery.js";
@@ -44,6 +45,11 @@ export async function notifyExpiredGuardianRequest(
         releaseExpiredInteraction(request);
         return;
       case "access_request":
+        // Admitted-mode nudges expire silently for the requester — the
+        // sender made no request and keeps whatever access the floor grants.
+        if (!introductionMode(request.trigger).notifyRequesterOnExpiry) {
+          break;
+        }
         await notifyRequesterOfExpiry(
           request,
           "Your access request expired before it was reviewed. " +

package/src/approvals/guardian-request-resolvers.ts

@@ -43,6 +43,7 @@ import {
 } from "../runtime/channel-approval-types.js";
 import { deliverChannelReply } from "../runtime/gateway-client.js";
 import {
+  introductionMode,
   parseRequesterSignals,
   resolveTrustBinding,
 } from "../runtime/introduction-policy.js";
@@ -592,6 +593,13 @@ async function notifyRequesterOfDenial(params: {
   deniedPayload: TrustedContactDecisionPayload;
   requestId: string;
   conversationId: string | null;
+  /**
+   * Admitted-mode introduction nudges never send the requester a denial
+   * text — the sender made no request and (for leave-unverified) keeps
+   * whatever access the floor grants. Guardian-facing decision signals
+   * still emit.
+   */
+  suppressRequesterNotice?: boolean;
 }): Promise<void> {
   const {
     channel,
@@ -603,17 +611,20 @@ async function notifyRequesterOfDenial(params: {
     deniedPayload,
     requestId,
     conversationId,
+    suppressRequesterNotice,
   } = params;
 
-  await deliverRequesterNotice({
-    channel,
-    requesterChatId,
-    requesterExternalUserId,
-    assistantId,
-    channelDeliveryContext,
-    desktopDeliverUrl,
-    text: "Your access request has been denied.",
-  });
+  if (!suppressRequesterNotice) {
+    await deliverRequesterNotice({
+      channel,
+      requesterChatId,
+      requesterExternalUserId,
+      assistantId,
+      channelDeliveryContext,
+      desktopDeliverUrl,
+      text: "Your access request has been denied.",
+    });
+  }
 
   if (channelDeliveryContext) {
     void emitNotificationSignal({
@@ -712,6 +723,9 @@ const accessRequestResolver: GuardianRequestResolver = {
       decidedByContactResult?.contact.displayName ?? null;
 
     const signals = parseRequesterSignals(request.requesterSignals);
+    // Requester-facing lifecycle notices are mode-gated: an admitted-mode
+    // nudge's sender made no request. See introductionMode().
+    const mode = introductionMode(request.trigger);
     let outcome: IntroductionOutcome = OUTCOME_BY_ACTION[decision.action];
 
     // A bot cannot return a verification code, so a handshake approval on a
@@ -772,16 +786,19 @@ const accessRequestResolver: GuardianRequestResolver = {
         deniedPayload,
         requestId: request.id,
         conversationId: request.conversationId,
+        suppressRequesterNotice: !mode.notifyRequesterOnDeny,
       });
 
       return {
         ok: true,
         applied: true,
         // Desktop actors (vellum channel) receive inline reply text; channel
-        // actors get replies delivered via the channel delivery context.
+        // actors get replies delivered via the channel delivery context. An
+        // admitted sender keeps whatever access the floor grants.
         ...(ctx.actor.channel === "vellum"
           ? {
-              guardianReplyText: `${requesterLabel} will stay unverified. They won't be able to message the assistant.`,
+              guardianReplyText:
+                mode.leaveUnverifiedGuardianReply(requesterLabel),
             }
           : {}),
       };
@@ -826,6 +843,7 @@ const accessRequestResolver: GuardianRequestResolver = {
         deniedPayload,
         requestId: request.id,
         conversationId: request.conversationId,
+        suppressRequesterNotice: !mode.notifyRequesterOnDeny,
       });
 
       return {
@@ -956,16 +974,19 @@ const accessRequestResolver: GuardianRequestResolver = {
         "Access request resolver: direct trust — contact activated without handshake",
       );
 
-      // Notify the requester they're in.
-      await deliverRequesterNotice({
-        channel,
-        requesterChatId,
-        requesterExternalUserId,
-        assistantId,
-        channelDeliveryContext,
-        desktopDeliverUrl,
-        text: "Your access request has been approved. You can message the assistant here.",
-      });
+      // Notify the requester they're in. Admitted-mode nudges skip this —
+      // the sender was already conversing and made no request.
+      if (mode.notifyRequesterOnTrust) {
+        await deliverRequesterNotice({
+          channel,
+          requesterChatId,
+          requesterExternalUserId,
+          assistantId,
+          channelDeliveryContext,
+          desktopDeliverUrl,
+          text: "Your access request has been approved. You can message the assistant here.",
+        });
+      }
 
       return {
         ok: true,

package/src/background-wake/wake-intent-hooks.test.ts

@@ -29,14 +29,6 @@ mock.module("./platform-client.js", () => ({
   clearBackgroundWakeIntent: mockClearBackgroundWakeIntent,
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 // Replace `publishSchedulesChanged` while keeping the rest of the module REAL
 // — a partial mock that drops the other exports breaks any transitively loaded
 // module that imports them (the conversation write paths reach this module
@@ -61,6 +53,8 @@ mock.module("../util/platform.js", () => ({
   getDataDir: () => workspacePath("data"),
   getConfigQuarantineNoticePath: () =>
     workspacePath("data", "config-quarantine-notice.json"),
+  getConfigValidationResetNoticePath: () =>
+    workspacePath("data", "config-validation-reset-notice.json"),
   getDbPath: () => workspacePath("data", "db", "assistant.db"),
   ensureDataDir: () => {
     mkdirSync(workspacePath("data", "db"), { recursive: true });
@@ -95,8 +89,6 @@ mock.module("../util/platform.js", () => ({
   getProfilerRunsDir: () => workspacePath("data", "profiler", "runs"),
   getProfilerRunDir: (runId: string) =>
     workspacePath("data", "profiler", "runs", runId),
-  getSkillRuntimePath: () => undefined,
-  getBundledBunPath: () => undefined,
 }));
 
 const {