@vellumai/assistant 0.5.1 → 0.5.2

package/src/config/schema-utils.ts

@@ -1,8 +1,34 @@
 import type { z } from "zod";
 
+/**
+ * Unwrap a Zod schema to reach its inner object shape, handling:
+ * - default/optional/nullable wrappers (innerType)
+ * - pipe/transform wrappers (in — the input side)
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function unwrapToShape(schema: any): any {
+  let current = schema;
+  while (current && !current.shape) {
+    const def = current._zod?.def;
+    if (!def) break;
+    // Pipe/transform: follow the input side to get the pre-transform schema
+    if (def.type === "pipe" && def.in) {
+      current = def.in;
+      continue;
+    }
+    // Default/optional/nullable: follow innerType
+    if (def.innerType) {
+      current = def.innerType;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+
 /**
  * Navigate a Zod schema by dotted path, unwrapping wrapper types
- * (default, optional, nullable) to reach inner object shapes.
+ * (default, optional, nullable, pipe/transform) to reach inner object shapes.
  * Returns the Zod schema at the given path, or null if the path is invalid.
  */
 export function getSchemaAtPath(
@@ -13,12 +39,7 @@ export function getSchemaAtPath(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let current: any = schema;
   for (const key of keys) {
-    // Unwrap default/optional/nullable wrappers to find inner object shape
-    while (current && !current.shape) {
-      const inner = current._zod?.def?.innerType;
-      if (!inner) break;
-      current = inner;
-    }
+    current = unwrapToShape(current);
     if (!current || !current.shape) return null;
     current = current.shape[key];
     if (!current) return null;

package/src/config/schema.ts

@@ -38,6 +38,7 @@ export type { ElevenLabsConfig } from "./schemas/elevenlabs.js";
 export {
   DEFAULT_ELEVENLABS_VOICE_ID,
   ElevenLabsConfigSchema,
+  VALID_CONVERSATION_TIMEOUTS,
 } from "./schemas/elevenlabs.js";
 export type { HeartbeatConfig } from "./schemas/heartbeat.js";
 export { HeartbeatConfigSchema } from "./schemas/heartbeat.js";
@@ -321,6 +322,13 @@ export const AssistantConfigSchema = z
       .boolean()
       .default(true)
       .describe("Whether to send diagnostic/crash reports"),
+    maxStepsPerSession: z
+      .number({ error: "maxStepsPerSession must be a number" })
+      .int("maxStepsPerSession must be an integer")
+      .min(1, "maxStepsPerSession must be >= 1")
+      .max(200, "maxStepsPerSession must be <= 200")
+      .default(50)
+      .describe("Maximum number of computer-use steps per session"),
   })
   .superRefine((config, ctx) => {
     if (

package/src/config/schemas/elevenlabs.ts

@@ -5,6 +5,9 @@ import { z } from "zod";
 // Mirrored in: clients/macos/.../OpenAIVoiceService.swift (defaultVoiceId)
 export const DEFAULT_ELEVENLABS_VOICE_ID = "ZF6FPAbjXT4488VcRRnw";
 
+/** Valid conversation timeout values (seconds). Shared with voice-config-update tool. */
+export const VALID_CONVERSATION_TIMEOUTS = [5, 10, 15, 30, 60] as const;
+
 export const ElevenLabsConfigSchema = z
   .object({
     voiceId: z
@@ -42,6 +45,21 @@ export const ElevenLabsConfigSchema = z
       .describe(
         "How closely the output matches the original voice — higher values increase similarity",
       ),
+    conversationTimeoutSeconds: z
+      .number({
+        error: "elevenlabs.conversationTimeoutSeconds must be a number",
+      })
+      .refine(
+        (v) =>
+          VALID_CONVERSATION_TIMEOUTS.includes(
+            v as (typeof VALID_CONVERSATION_TIMEOUTS)[number],
+          ),
+        {
+          message: `elevenlabs.conversationTimeoutSeconds must be one of: ${VALID_CONVERSATION_TIMEOUTS.join(", ")}`,
+        },
+      )
+      .default(30)
+      .describe("Seconds of silence before voice conversation auto-ends"),
   })
   .describe("ElevenLabs text-to-speech configuration");
 

package/src/config/schemas/memory-lifecycle.ts

@@ -68,8 +68,10 @@ export const MemoryCleanupConfigSchema = z
       .nonnegative(
         "memory.cleanup.conversationRetentionDays must be non-negative",
       )
-      .default(90)
-      .describe("Number of days to retain conversation data before cleanup"),
+      .default(0)
+      .describe(
+        "Number of days to retain conversation data before cleanup (0 disables pruning)",
+      ),
   })
   .describe("Automatic memory cleanup and garbage collection settings");
 

package/src/config/schemas/memory-storage.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-const VALID_MEMORY_EMBEDDING_PROVIDERS = [
+export const VALID_MEMORY_EMBEDDING_PROVIDERS = [
   "auto",
   "local",
   "openai",

package/src/config/schemas/services.ts

@@ -20,15 +20,18 @@ export const VALID_WEB_SEARCH_PROVIDERS = [
   "inference-provider-native",
 ] as const;
 
-export const InferenceServiceSchema = z.object({
+export const BaseServiceSchema = z.object({
   mode: ServiceModeSchema.default("your-own"),
+});
+export type BaseService = z.infer<typeof BaseServiceSchema>;
+
+export const InferenceServiceSchema = BaseServiceSchema.extend({
   provider: z.enum(VALID_INFERENCE_PROVIDERS).default("anthropic"),
   model: z.string().default("claude-opus-4-6"),
 });
 export type InferenceService = z.infer<typeof InferenceServiceSchema>;
 
-export const ImageGenerationServiceSchema = z.object({
-  mode: ServiceModeSchema.default("your-own"),
+export const ImageGenerationServiceSchema = BaseServiceSchema.extend({
   provider: z.enum(VALID_IMAGE_GEN_PROVIDERS).default("gemini"),
   model: z.string().default("gemini-3.1-flash-image-preview"),
 });
@@ -36,15 +39,14 @@ export type ImageGenerationService = z.infer<
   typeof ImageGenerationServiceSchema
 >;
 
-export const WebSearchServiceSchema = z.object({
-  mode: ServiceModeSchema.default("your-own"),
+export const WebSearchServiceSchema = BaseServiceSchema.extend({
   provider: z
     .enum(VALID_WEB_SEARCH_PROVIDERS)
     .default("inference-provider-native"),
 });
 export type WebSearchService = z.infer<typeof WebSearchServiceSchema>;
 
-export const GoogleOAuthServiceSchema = z.object({
+export const GoogleOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("managed"),
 });
 export type GoogleOAuthService = z.infer<typeof GoogleOAuthServiceSchema>;

package/src/contacts/contact-store.ts

@@ -295,21 +295,28 @@ function syncChannels(
       .get();
 
     if (existing) {
+      // Preserve guardian blocks: if the channel is blocked, do not overwrite
+      // its status/policy — mirrors the guard in the cross-contact reassignment
+      // path so a blocked channel cannot be unblocked via a same-contact sync.
+      const isBlocked = existing.status === "blocked";
+
       const updateSet: Record<string, unknown> = {};
       if (ch.isPrimary !== undefined) updateSet.isPrimary = ch.isPrimary;
       if (ch.externalUserId !== undefined)
         updateSet.externalUserId = ch.externalUserId;
       if (ch.externalChatId !== undefined)
         updateSet.externalChatId = ch.externalChatId;
-      if (ch.status !== undefined) updateSet.status = ch.status;
-      if (ch.policy !== undefined) updateSet.policy = ch.policy;
+      if (!isBlocked) {
+        if (ch.status !== undefined) updateSet.status = ch.status;
+        if (ch.policy !== undefined) updateSet.policy = ch.policy;
+        if (ch.revokedReason !== undefined)
+          updateSet.revokedReason = ch.revokedReason;
+        if (ch.blockedReason !== undefined)
+          updateSet.blockedReason = ch.blockedReason;
+      }
       if (ch.verifiedAt !== undefined) updateSet.verifiedAt = ch.verifiedAt;
       if (ch.verifiedVia !== undefined) updateSet.verifiedVia = ch.verifiedVia;
       if (ch.inviteId !== undefined) updateSet.inviteId = ch.inviteId;
-      if (ch.revokedReason !== undefined)
-        updateSet.revokedReason = ch.revokedReason;
-      if (ch.blockedReason !== undefined)
-        updateSet.blockedReason = ch.blockedReason;
 
       if (Object.keys(updateSet).length > 0) {
         updateSet.updatedAt = now;

package/src/contacts/contacts-write.ts

@@ -145,7 +145,6 @@ export function upsertContactChannel(params: {
   policy?: string;
   status?: string;
   inviteId?: string;
-  sourceConversationId?: string;
   verifiedAt?: number;
   verifiedVia?: string;
   role?: ContactRole;

package/src/context/window-manager.ts

@@ -681,13 +681,24 @@ function countPersistedMessages(messages: Message[]): number {
   }).length;
 }
 
-/** A user message that contains ONLY tool_result blocks (no text or other content). */
+function isSystemNoticeBlock(block: ContentBlock): boolean {
+  if (block.type !== "text") return false;
+  const text = (block as { text?: string }).text ?? "";
+  return (
+    text.startsWith("<system_notice>") && text.endsWith("</system_notice>")
+  );
+}
+
+/** A user message that contains ONLY tool_result blocks (no text or other content).
+ *  System notice text blocks (retry nudges, progress checks) do not count as user content. */
 function isToolResultOnly(message: Message): boolean {
   return (
     message.content.length > 0 &&
     message.content.every(
       (block) =>
-        block.type === "tool_result" || block.type === "web_search_tool_result",
+        block.type === "tool_result" ||
+        block.type === "web_search_tool_result" ||
+        isSystemNoticeBlock(block),
     )
   );
 }

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

@@ -15,11 +15,16 @@ import type {
 } from "../channels/types.js";
 import {
   addMessage,
+  getConversation,
   getMessageById,
   provenanceFromTrustContext,
   updateMessageContent,
 } from "../memory/conversation-crud.js";
-import { recordRequestLog } from "../memory/llm-request-log-store.js";
+import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
+import {
+  backfillMessageIdOnLogs,
+  recordRequestLog,
+} from "../memory/llm-request-log-store.js";
 import type { ContentBlock, ImageContent } from "../providers/types.js";
 import type { DirectiveRequest } from "./assistant-attachments.js";
 import {
@@ -48,6 +53,8 @@ export interface EventHandlerState {
   llmCallStartedEmitted: boolean;
   pendingDirectiveDisplayBuffer: string;
   firstAssistantText: string;
+  /** Most recent resolved provider for the current exchange's usage accounting. */
+  exchangeProviderName: string | undefined;
   exchangeInputTokens: number;
   exchangeCacheCreationInputTokens: number;
   exchangeCacheReadInputTokens: number;
@@ -114,6 +121,7 @@ export function createEventHandlerState(): EventHandlerState {
     llmCallStartedEmitted: false,
     pendingDirectiveDisplayBuffer: "",
     firstAssistantText: "",
+    exchangeProviderName: undefined,
     exchangeInputTokens: 0,
     exchangeCacheCreationInputTokens: 0,
     exchangeCacheReadInputTokens: 0,
@@ -167,6 +175,12 @@ export function emitLlmCallStartedIfNeeded(
   );
 }
 
+// ── Client Payload Size Caps ─────────────────────────────────────────
+// tool_input_delta streams accumulated JSON as tools run. For non-app
+// tools the client discards it (extractCodePreview only handles app tools),
+// so we skip forwarding entirely to avoid transport/decode overhead.
+const APP_TOOL_NAMES = new Set(["app_create"]);
+
 // ── Friendly Tool Names ──────────────────────────────────────────────
 
 const TOOL_FRIENDLY_NAMES: Record<string, string> = {
@@ -183,11 +197,9 @@ const TOOL_FRIENDLY_NAMES: Record<string, string> = {
   browser_scroll: "browser",
   browser_wait: "browser",
   app_create: "app",
-  app_update: "app",
+  app_refresh: "app refresh",
   skill_load: "skill",
   skill_execute: "skill",
-  app_file_edit: "app file",
-  app_file_write: "app file",
 };
 
 function friendlyToolName(name: string): string {
@@ -385,6 +397,10 @@ export function handleInputJsonDelta(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: "input_json_delta" }>,
 ): void {
+  // Only forward input deltas for app tools — the client only uses this
+  // stream for app_create/app_update code previews. Non-app tools would
+  // send large cumulative JSON on every delta with no benefit.
+  if (!APP_TOOL_NAMES.has(event.toolName)) return;
   deps.onEvent({
     type: "tool_input_delta",
     toolName: event.toolName,
@@ -627,12 +643,21 @@ export async function handleMessageComplete(
       assistantMessageInterface:
         deps.turnInterfaceContext.assistantMessageInterface,
     };
-    await addMessage(
+    const toolResultMsg = await addMessage(
       deps.ctx.conversationId,
       "user",
       JSON.stringify(toolResultBlocks),
       toolResultMetadata,
     );
+    // Sync tool-result user message to disk view
+    const convForToolResult = getConversation(deps.ctx.conversationId);
+    if (convForToolResult) {
+      syncMessageToDisk(
+        deps.ctx.conversationId,
+        toolResultMsg.id,
+        convForToolResult.createdAt,
+      );
+    }
     for (const id of state.pendingToolResults.keys()) {
       state.persistedToolUseIds.add(id);
     }
@@ -697,6 +722,18 @@ export async function handleMessageComplete(
   );
   state.lastAssistantMessageId = assistantMsg.id;
 
+  // Backfill message_id on all LLM request logs from this turn.
+  // The agent loop is single-threaded per conversation, so all rows with
+  // message_id IS NULL belong to the current turn.
+  try {
+    backfillMessageIdOnLogs(deps.ctx.conversationId, assistantMsg.id);
+  } catch (err) {
+    deps.rlog.warn(
+      { err },
+      "Failed to backfill message_id on LLM request logs (non-fatal)",
+    );
+  }
+
   deps.ctx.currentTurnSurfaces = [];
 
   // Emit trace event
@@ -724,6 +761,8 @@ export function handleUsage(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: "usage" }>,
 ): void {
+  const providerName = event.actualProvider ?? deps.ctx.provider.name;
+  state.exchangeProviderName = providerName;
   state.exchangeInputTokens += event.inputTokens;
   state.exchangeCacheCreationInputTokens += event.cacheCreationInputTokens ?? 0;
   state.exchangeCacheReadInputTokens += event.cacheReadInputTokens ?? 0;
@@ -739,6 +778,8 @@ export function handleUsage(
         deps.ctx.conversationId,
         JSON.stringify(event.rawRequest),
         JSON.stringify(event.rawResponse),
+        undefined,
+        providerName,
       );
     } catch (err) {
       deps.rlog.warn({ err }, "Failed to persist LLM request log (non-fatal)");
@@ -749,12 +790,12 @@ export function handleUsage(
 
   deps.ctx.traceEmitter.emit(
     "llm_call_finished",
-    `LLM call to ${deps.ctx.provider.name} finished`,
+    `LLM call to ${providerName} finished`,
     {
       requestId: deps.reqId,
       status: "success",
       attributes: {
-        provider: deps.ctx.provider.name,
+        provider: providerName,
         model: event.model,
         inputTokens: event.inputTokens,
         outputTokens: event.outputTokens,

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

@@ -32,7 +32,7 @@ import {
   setSentryConversationContext,
 } from "../instrument.js";
 import { commitAppTurnChanges } from "../memory/app-git-service.js";
-import { getApp, listAppFiles } from "../memory/app-store.js";
+import { getApp, listAppFiles, resolveAppDir } from "../memory/app-store.js";
 import {
   addMessage,
   deleteMessageById,
@@ -43,6 +43,10 @@ import {
   updateConversationContextWindow,
   updateConversationTitle,
 } from "../memory/conversation-crud.js";
+import {
+  rebuildConversationDiskViewFromDbState,
+  syncMessageToDisk,
+} from "../memory/conversation-disk-view.js";
 import {
   isReplaceableTitle,
   queueGenerateConversationTitle,
@@ -77,7 +81,6 @@ import {
 } from "./conversation-agent-loop-handlers.js";
 import {
   approveHostAttachmentRead,
-  formatAttachmentWarnings,
   resolveAssistantAttachments,
 } from "./conversation-attachments.js";
 import {
@@ -173,11 +176,9 @@ const TOOL_FRIENDLY_LABEL: Record<string, string> = {
   browser_scroll: "Browser",
   browser_wait: "Browser",
   app_create: "Create App",
-  app_update: "Update App",
+  app_refresh: "Refresh App",
   skill_load: "Load Skill",
   skill_execute: "Run Skill Tool",
-  app_file_edit: "Edit App File",
-  app_file_write: "Write App File",
 };
 
 type GitServiceInitializer = {
@@ -604,6 +605,7 @@ export async function runAgentLoopImpl(
           if (app) {
             activeSurface.appId = app.id;
             activeSurface.appName = app.name;
+            activeSurface.appDirName = resolveAppDir(app.id).dirName;
             activeSurface.appSchemaJson = app.schemaJson;
             activeSurface.appFiles = listAppFiles(app.id);
             if (app.pages && Object.keys(app.pages).length > 0) {
@@ -801,7 +803,16 @@ export async function runAgentLoopImpl(
           mode: currentInjectionMode,
         });
 
-        if (step.estimatedTokens <= preflightBudget) break;
+        // Re-estimate with injections included — step.estimatedTokens was
+        // computed on bare history (ctx.messages) and doesn't account for
+        // tokens added by runtime injections.
+        const postInjectionTokens = estimatePromptTokens(
+          runMessages,
+          ctx.systemPrompt,
+          { providerName: ctx.provider.name, toolTokenBudget },
+        );
+
+        if (postInjectionTokens <= preflightBudget) break;
       }
     }
 
@@ -1173,6 +1184,7 @@ export async function runAgentLoopImpl(
         preRepairMessages = runMessages;
         preRunHistoryLength = runMessages.length;
         state.contextTooLargeDetected = false;
+        yieldedForBudget = false;
 
         updatedHistory = await ctx.agentLoop.run(
           runMessages,
@@ -1195,6 +1207,15 @@ export async function runAgentLoopImpl(
             "Post-convergence rerun still yielded at checkpoint — continuing reduction",
           );
           state.contextTooLargeDetected = true;
+
+          // Fold rerun progress into ctx.messages so the next reducer
+          // tier operates on up-to-date history instead of stale
+          // pre-rerun messages.
+          if (updatedHistory.length > preRunHistoryLength) {
+            ctx.messages = stripInjectedContext(updatedHistory);
+            preRepairMessages = updatedHistory;
+            preRunHistoryLength = updatedHistory.length;
+          }
         }
       }
 
@@ -1514,16 +1535,29 @@ export async function runAgentLoopImpl(
       state.exchangeCacheCreationInputTokens,
       state.exchangeCacheReadInputTokens,
       collapseRawResponses(state.exchangeRawResponses),
+      state.exchangeProviderName,
     );
 
     void getHookManager().trigger("post-message", {
       conversationId: ctx.conversationId,
     });
 
+    const syncLastAssistantMessageToDisk = (): void => {
+      if (!state.lastAssistantMessageId) return;
+      const convForDisk = getConversation(ctx.conversationId);
+      if (!convForDisk) return;
+      syncMessageToDisk(
+        ctx.conversationId,
+        state.lastAssistantMessageId,
+        convForDisk.createdAt,
+      );
+    };
+
     // Fast-path: when the user cancelled, skip expensive post-loop work
     // (attachment resolution) and emit the cancellation event immediately
     // so the client can re-enable the UI without delay.
     if (abortController.signal.aborted) {
+      syncLastAssistantMessageToDisk();
       ctx.emitActivityState("idle", "generation_cancelled", "global", reqId);
       ctx.traceEmitter.emit(
         "generation_cancelled",
@@ -1559,17 +1593,7 @@ export async function runAgentLoopImpl(
 
       ctx.lastAssistantAttachments = assistantAttachments;
       ctx.lastAttachmentWarnings = attachmentResult.directiveWarnings;
-
-      const warningText = formatAttachmentWarnings(
-        attachmentResult.directiveWarnings,
-      );
-      if (warningText) {
-        onEvent({
-          type: "assistant_text_delta",
-          text: warningText,
-          conversationId: ctx.conversationId,
-        });
-      }
+      syncLastAssistantMessageToDisk();
 
       // Re-check: the user may have cancelled during attachment resolution
       if (abortController.signal.aborted) {
@@ -1604,6 +1628,9 @@ export async function runAgentLoopImpl(
           ...(emittedAttachments.length > 0
             ? { attachments: emittedAttachments }
             : {}),
+          ...(ctx.lastAttachmentWarnings.length > 0
+            ? { attachmentWarnings: ctx.lastAttachmentWarnings }
+            : {}),
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
@@ -1624,6 +1651,9 @@ export async function runAgentLoopImpl(
           ...(emittedAttachments.length > 0
             ? { attachments: emittedAttachments }
             : {}),
+          ...(ctx.lastAttachmentWarnings.length > 0
+            ? { attachmentWarnings: ctx.lastAttachmentWarnings }
+            : {}),
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
@@ -1739,7 +1769,13 @@ export async function runAgentLoopImpl(
     ctx.commandIntent = undefined;
 
     if (userMessageId) {
-      consolidateAssistantMessages(ctx.conversationId, userMessageId);
+      const didMutateHistory = consolidateAssistantMessages(
+        ctx.conversationId,
+        userMessageId,
+      );
+      if (didMutateHistory) {
+        rebuildConversationDiskViewFromDbState(ctx.conversationId);
+      }
     }
 
     ctx.drainQueue(yieldedForHandoff ? "checkpoint_handoff" : "loop_complete");
@@ -1766,11 +1802,12 @@ function emitUsage(
   cacheCreationInputTokens = 0,
   cacheReadInputTokens = 0,
   rawResponse?: unknown,
+  providerName?: string,
 ): void {
   recordUsage(
     {
       conversationId: ctx.conversationId,
-      providerName: ctx.provider.name,
+      providerName: providerName ?? ctx.provider.name,
       usageStats: ctx.usageStats,
     },
     inputTokens,

package/src/daemon/conversation-attachments.ts

@@ -1,11 +1,8 @@
 import {
+  attachInlineAttachmentToMessage,
   AttachmentUploadError,
-  FILE_BACKED_THRESHOLD_BYTES,
-  linkAttachmentToMessage,
+  getFilePathForAttachment,
   setAttachmentThumbnail,
-  uploadAttachment,
-  uploadFileBackedAttachment,
-  writeAttachmentToDisk,
 } from "../memory/attachments-store.js";
 import {
   check,
@@ -107,12 +104,6 @@ export async function approveHostAttachmentRead(
   return isAllowDecision(response.decision);
 }
 
-export function formatAttachmentWarnings(warnings: string[]): string | null {
-  if (warnings.length === 0) return null;
-  const lines = warnings.map((warning) => `Attachment warning: ${warning}`);
-  return `\n\n${lines.join("\n")}`;
-}
-
 export interface AttachmentResolutionResult {
   assistantAttachments: AssistantAttachmentDraft[];
   emittedAttachments: UserMessageAttachment[];
@@ -211,28 +202,16 @@ export async function resolveAssistantAttachments(
   if (assistantAttachments.length > 0 && lastAssistantMessageId) {
     for (let i = 0; i < assistantAttachments.length; i++) {
       const draft = assistantAttachments[i];
-      const isFileBacked = draft.sizeBytes > FILE_BACKED_THRESHOLD_BYTES;
       let stored;
-      let diskFilePath: string | undefined;
       try {
-        if (isFileBacked) {
-          diskFilePath = writeAttachmentToDisk(
-            draft.dataBase64,
-            draft.filename,
-          );
-          stored = uploadFileBackedAttachment(
-            draft.filename,
-            draft.mimeType,
-            diskFilePath,
-            draft.sizeBytes,
-          );
-        } else {
-          stored = uploadAttachment(
-            draft.filename,
-            draft.mimeType,
-            draft.dataBase64,
-          );
-        }
+        stored = attachInlineAttachmentToMessage(
+          lastAssistantMessageId,
+          i,
+          draft.filename,
+          draft.mimeType,
+          draft.dataBase64,
+          { skipSizeLimit: true },
+        );
       } catch (err) {
         if (err instanceof AttachmentUploadError) {
           log.warn(
@@ -246,11 +225,11 @@ export async function resolveAssistantAttachments(
         }
         throw err;
       }
-      linkAttachmentToMessage(lastAssistantMessageId, stored.id, i);
       const isVideo = draft.mimeType.startsWith("video/");
-      const omitData =
-        isFileBacked ||
-        (isVideo && draft.dataBase64.length > MAX_INLINE_B64_SIZE);
+      // Only omit data for videos — they have an end-to-end lazy-load path
+      // via /v1/attachments/:id/content. Other types (images, PDFs) still need
+      // inline data for thumbnails, preview, and file-save in the client.
+      const omitData = isVideo && draft.dataBase64.length > MAX_INLINE_B64_SIZE;
 
       // Generate and persist a thumbnail for video attachments.
       let thumbnailData: string | undefined;
@@ -259,6 +238,7 @@ export async function resolveAssistantAttachments(
         if (existing) {
           thumbnailData = existing;
         } else {
+          const diskFilePath = getFilePathForAttachment(stored.id);
           const generated = diskFilePath
             ? await generateVideoThumbnailFromPath(diskFilePath)
             : await generateVideoThumbnail(draft.dataBase64);
@@ -274,8 +254,9 @@ export async function resolveAssistantAttachments(
         filename: draft.filename,
         mimeType: draft.mimeType,
         data: omitData ? "" : draft.dataBase64,
+        sourceType: draft.sourceType,
         ...(omitData ? { sizeBytes: draft.sizeBytes } : {}),
-        ...(isFileBacked ? { fileBacked: true } : {}),
+        fileBacked: true,
         ...(thumbnailData ? { thumbnailData } : {}),
       });
     }
@@ -285,6 +266,7 @@ export async function resolveAssistantAttachments(
         filename: draft.filename,
         mimeType: draft.mimeType,
         data: draft.dataBase64,
+        sourceType: draft.sourceType,
       });
     }
   }