@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/plugins/defaults/memory/__tests__/memory-retrospective-accounting.test.ts

@@ -10,6 +10,7 @@ import { getDb } from "../../../../persistence/db-connection.js";
 import { initializeDb } from "../../../../persistence/db-init.js";
 import { messages } from "../../../../persistence/schema/index.js";
 import {
+  countRetrospectiveMessagesAfter,
   getRetrospectiveMessagesAfter,
   hasQualifyingUserMessageAfter,
   messagesHaveUserActivity,
@@ -28,12 +29,61 @@ const MIXED = JSON.stringify([
   { type: "text", text: "note" },
 ]);
 
+/** A kept camera frame's row: a user-role image the call sampled by itself. */
+const SIGHT_FRAME_CONTENT = JSON.stringify([
+  { type: "text", text: "(camera frame)" },
+  {
+    type: "image",
+    source: {
+      type: "workspace_ref",
+      media_type: "image/jpeg",
+      attachmentId: "att-frame",
+      sizeBytes: 1024,
+    },
+  },
+]);
+
+/**
+ * What `persistLiveVoiceSightFrame` writes: the gate sampled this, nobody
+ * spoke it, so `scripted` rides along with the tag.
+ */
+function sightFrameMetadata(attachmentId: string): string {
+  return JSON.stringify({
+    voiceSessionTurn: true,
+    provenanceTrustClass: "guardian",
+    scripted: true,
+    sightFrameAttachmentIds: [attachmentId],
+  });
+}
+
+/**
+ * What the voice bridge writes when a parked frame rides real speech
+ * (`calls/voice-session-bridge.ts`, matching its persist test's shape). The
+ * bridge leaves `scripted` absent for a genuine turn and the persist stamps
+ * the `false` default durably, which is what tells the two apart.
+ */
+function riddenTurnMetadata(attachmentId: string): string {
+  return JSON.stringify({
+    voiceSessionTurn: true,
+    provenanceTrustClass: "guardian",
+    scripted: false,
+    sightFrameAttachmentIds: [attachmentId],
+  });
+}
+
+/** An auto-sent row with no camera involvement, e.g. an onboarding prompt. */
+const SCRIPTED_UNTAGGED_METADATA = JSON.stringify({
+  provenanceTrustClass: "guardian",
+  scripted: true,
+});
+
 let seq = 0;
 function insertRaw(opts: {
   role: string;
   content: string;
   createdAt: number;
   id?: string;
+  metadata?: string;
 }): string {
   const id = opts.id ?? `msg-${String(++seq).padStart(4, "0")}`;
   getDb()
@@ -44,7 +94,7 @@ function insertRaw(opts: {
       role: opts.role,
       content: opts.content,
       createdAt: opts.createdAt,
-      metadata: null,
+      metadata: opts.metadata ?? null,
     })
     .run();
   return id;
@@ -269,3 +319,118 @@ describe("getRetrospectiveMessagesAfter", () => {
     expect(slice.map((row) => row.id)).not.toContain(streaming);
   });
 });
+
+describe("ambient camera frames are not retrospective work", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM messages`);
+    db.run(`DELETE FROM conversations`);
+    createConversation({ id: CONV });
+  });
+
+  /** One kept frame, as the live-voice persist writes it. */
+  function insertSightFrame(createdAt: number, attachmentId: string): string {
+    return insertRaw({
+      role: "user",
+      content: SIGHT_FRAME_CONTENT,
+      createdAt,
+      metadata: sightFrameMetadata(attachmentId),
+    });
+  }
+
+  test("a camera-only tail does not qualify as user activity", () => {
+    // A phone lying face up on a desk persists one of these every few
+    // seconds. Nobody said anything, so there is nothing to review.
+    insertSightFrame(1_000, "att-a");
+    insertSightFrame(2_000, "att-b");
+    insertSightFrame(3_000, "att-c");
+
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(false);
+  });
+
+  test("one real message among the frames does qualify", () => {
+    insertSightFrame(1_000, "att-a");
+    insertRaw({ role: "user", content: TEXT, createdAt: 2_000 });
+    insertSightFrame(3_000, "att-b");
+
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(true);
+  });
+
+  test("frames are left out of the count that decides a run is due", () => {
+    insertSightFrame(1_000, "att-a");
+    insertSightFrame(2_000, "att-b");
+
+    expect(countRetrospectiveMessagesAfter(CONV, null)).toBe(0);
+
+    insertRaw({ role: "user", content: TEXT, createdAt: 3_000 });
+
+    expect(countRetrospectiveMessagesAfter(CONV, null)).toBe(1);
+  });
+
+  test("frames are left out of the slice a run would review", () => {
+    insertSightFrame(1_000, "att-a");
+    const real = insertRaw({
+      role: "user",
+      content: TEXT,
+      createdAt: 2_000,
+    });
+    insertSightFrame(3_000, "att-b");
+
+    const slice = getRetrospectiveMessagesAfter(CONV, null);
+
+    // The cutoff lands on the real message, so the frames are neither
+    // reviewed nor skipped over.
+    expect(slice.map((row) => row.id)).toEqual([real]);
+  });
+
+  test("a spoken turn that carried a frame is real work", () => {
+    // Camera mode parks a frame continuously, so in a camera call EVERY
+    // spoken turn carries the tag. Excluding on the tag alone would mean a
+    // conversation held entirely in camera mode never earns a retrospective.
+    const spoken = insertRaw({
+      role: "user",
+      content: TEXT,
+      createdAt: 1_000,
+      metadata: riddenTurnMetadata("att-frame-1"),
+    });
+
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(true);
+    expect(countRetrospectiveMessagesAfter(CONV, null)).toBe(1);
+    expect(getRetrospectiveMessagesAfter(CONV, null).map((r) => r.id)).toEqual([
+      spoken,
+    ]);
+  });
+
+  test("an auto-sent row without the tag is untouched by this exclusion", () => {
+    // `scripted` covers onboarding sends and other machine-authored turns.
+    // They counted before the camera existed and must keep counting.
+    const onboarding = insertRaw({
+      role: "user",
+      content: TEXT,
+      createdAt: 1_000,
+      metadata: SCRIPTED_UNTAGGED_METADATA,
+    });
+
+    expect(countRetrospectiveMessagesAfter(CONV, null)).toBe(1);
+    expect(getRetrospectiveMessagesAfter(CONV, null).map((r) => r.id)).toEqual([
+      onboarding,
+    ]);
+  });
+
+  test("keeps are excluded even among the speech they punctuate", () => {
+    insertSightFrame(1_000, "att-a");
+    const spoken = insertRaw({
+      role: "user",
+      content: TEXT,
+      createdAt: 2_000,
+      metadata: riddenTurnMetadata("att-frame-1"),
+    });
+    insertSightFrame(3_000, "att-b");
+
+    expect(countRetrospectiveMessagesAfter(CONV, null)).toBe(1);
+    expect(getRetrospectiveMessagesAfter(CONV, null).map((r) => r.id)).toEqual([
+      spoken,
+    ]);
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(true);
+  });
+});

package/src/plugins/defaults/memory/__tests__/memory-retrospective-provider-path.test.ts

@@ -338,6 +338,9 @@ function makeForkConversationDouble(): Conversation {
   const conversation = {
     conversationId: FORK_ID,
     messages,
+    // The wake trims its own run input; nothing here is tagged as a camera
+    // frame, so the real pass would return the array unchanged too.
+    trimAgedSightFrames: (msgs: Message[]) => msgs,
     getMessages: () => messages,
     isProcessing: () => false,
     setProcessing: (_on: boolean) => {},

package/src/plugins/defaults/memory/__tests__/memory-retrospective-wake-chain.test.ts

@@ -176,6 +176,9 @@ function makeForkConversationDouble(forkId: string): Conversation {
     provider: scriptedProvider,
     usageStats: {},
     messages,
+    // The wake trims its own run input; nothing here is tagged as a camera
+    // frame, so the real pass would return the array unchanged too.
+    trimAgedSightFrames: (msgs: Message[]) => msgs,
     getMessages: () => messages,
     isProcessing: () => processing,
     setProcessing: (on: boolean) => {

package/src/plugins/defaults/memory/jobs-worker.ts

@@ -192,7 +192,7 @@ export interface MemoryJobsWorker {
 
 /**
  * Daemon-lifecycle entry point: spawn the memory jobs worker as a child of the
- * daemon (`detached: false`, so it appears in `assistant ps` and is torn down
+ * daemon (so it appears in the daemon's process tree and is torn down
  * on shutdown). The worker process is the sole drainer of the memory job queue.
  * Fire-and-forget — a worker failure must never block boot. A worker that comes
  * up late is still the desired sole drainer, so `terminateOnTimeout` is
@@ -205,7 +205,6 @@ export interface MemoryJobsWorker {
 export function startMemoryJobsWorker(): void {
   void spawnMemoryWorkerProcess({
     terminateOnTimeout: false,
-    detached: false,
   })
     .then(({ pid, alreadyRunning }) =>
       log.info(

package/src/plugins/defaults/memory/memory-retrospective-accounting.ts

@@ -16,6 +16,14 @@
 // zero-new-messages early-out) and the job's new-message slice — without
 // touching the generic persistence helpers' semantics for other callers.
 //
+// Ambient camera frames are excluded on the same three paths and for the same
+// reason, one step further out: a live-voice call with the camera up persists
+// a frame every few seconds whether or not anyone speaks, so counting them
+// would let a phone lying face up on a desk keep declaring its conversation
+// worth reviewing, and reviewing them would hand the model a wall to remember.
+// The user-activity probe excludes them too, so a tail of nothing but frames
+// never satisfies the `requireUserActivity` gate.
+//
 // The cursor is never blindly advanced over a card: the job still takes its
 // cutoff from the last NON-card row of the filtered slice, so a real message
 // that lands between the cutoff snapshot and the card insert can never be
@@ -30,10 +38,31 @@ import {
   getMessagesAfter,
   type MessageRow,
 } from "../../../persistence/conversation-crud.js";
+import {
+  messageMetadataIsAmbientSightKeep,
+  SIGHT_FRAME_ATTACHMENT_IDS_KEY,
+} from "../../../persistence/conversation-types.js";
 import { getDb } from "../../../persistence/db-connection.js";
 import { messages } from "../../../persistence/schema/index.js";
 import { SKILL_CARD_MESSAGE_KIND } from "./memory-retrospective-constants.js";
 
+/**
+ * Rows the retrospective must not account for: a prior run's own skill card,
+ * and ambient camera frames.
+ *
+ * A frame is machine-sampled, one every few seconds for as long as the camera
+ * is up, so counting them would let an idle camera pointed at a wall keep
+ * declaring a conversation worth reviewing. They are also the wrong thing to
+ * review: nobody said anything.
+ */
+function isExcludedFromRetrospectiveAccounting(row: {
+  metadata: string | null;
+}): boolean {
+  return (
+    isSkillCardMessage(row) || messageMetadataIsAmbientSightKeep(row.metadata)
+  );
+}
+
 /** True when a message row's metadata carries the skill-card kind. */
 export function isSkillCardMessage(row: { metadata: string | null }): boolean {
   if (!row.metadata) {
@@ -75,7 +104,7 @@ export function getRetrospectiveMessagesAfter(
   const firstUnfinalized = rows.findIndex((row) => row.finalized !== 1);
   const bounded =
     firstUnfinalized === -1 ? rows : rows.slice(0, firstUnfinalized);
-  return bounded.filter((row) => !isSkillCardMessage(row));
+  return bounded.filter((row) => !isExcludedFromRetrospectiveAccounting(row));
 }
 
 /**
@@ -93,8 +122,8 @@ export function countRetrospectiveMessagesAfter(
   if (total === 0) {
     return 0;
   }
-  const cardCount = countSkillCardMessagesAfter(conversationId, afterMessageId);
-  return Math.max(0, total - cardCount);
+  const excluded = countExcludedMessagesAfter(conversationId, afterMessageId);
+  return Math.max(0, total - excluded);
 }
 
 /**
@@ -117,6 +146,12 @@ function blocksCarryNonToolResult(
  * user-role row whose resolved content carries a non-tool_result block. Tool
  * results ride on user-role rows, so a bare role check would count any
  * tool-using assistant stretch as user activity.
+ *
+ * Takes rows rather than reading any itself, and its one caller passes the
+ * slice {@link getRetrospectiveMessagesAfter} already filtered, so ambient
+ * camera frames never reach it. A future caller assembling its own rows has to
+ * filter them first: a frame is a user-role row carrying an image block, which
+ * is indistinguishable from real activity by role and content alone.
  */
 export function messagesHaveUserActivity(
   rows: ReadonlyArray<Pick<MessageRow, "role" | "content">>,
@@ -136,7 +171,9 @@ export function messagesHaveUserActivity(
  *
  * Operates on the raw `content` column: rows that do not parse to a block
  * array (file-backed `{ ref }` rows, legacy plain strings) count as
- * user-authored, so the gate fails toward running the retrospective.
+ * user-authored, so the gate fails toward running the retrospective. Ambient
+ * camera frames are the one user-role row that does NOT count: the camera
+ * sampled them, so they must not be what wakes a review.
  */
 export function hasQualifyingUserMessageAfter(
   conversationId: string,
@@ -171,7 +208,7 @@ export function hasQualifyingUserMessageAfter(
         ]
       : [];
   const rows = db
-    .select({ content: messages.content })
+    .select({ content: messages.content, metadata: messages.metadata })
     .from(messages)
     .where(
       and(
@@ -182,7 +219,11 @@ export function hasQualifyingUserMessageAfter(
     )
     .all();
 
-  return rows.some((row) => rawUserContentCarriesActivity(row.content));
+  return rows.some(
+    (row) =>
+      !messageMetadataIsAmbientSightKeep(row.metadata) &&
+      rawUserContentCarriesActivity(row.content),
+  );
 }
 
 /** Raw-column twin of the block check used by {@link messagesHaveUserActivity}. */
@@ -211,7 +252,7 @@ function rawUserContentCarriesActivity(raw: string | null): boolean {
  * tie-breaker semantics, including the null/`""` "count everything" cases
  * and the vanished-reference "no new work" case.
  */
-function countSkillCardMessagesAfter(
+function countExcludedMessagesAfter(
   conversationId: string,
   afterMessageId: string | null,
 ): number {
@@ -230,7 +271,10 @@ function countSkillCardMessagesAfter(
     .where(
       and(
         eq(messages.conversationId, conversationId),
-        like(messages.metadata, `%"kind":"${SKILL_CARD_MESSAGE_KIND}"%`),
+        or(
+          like(messages.metadata, `%"kind":"${SKILL_CARD_MESSAGE_KIND}"%`),
+          like(messages.metadata, `%"${SIGHT_FRAME_ATTACHMENT_IDS_KEY}"%`),
+        ),
       ),
     )
     .all();
@@ -254,7 +298,7 @@ function countSkillCardMessagesAfter(
 
   let count = 0;
   for (const row of candidates) {
-    if (!isSkillCardMessage(row)) {
+    if (!isExcludedFromRetrospectiveAccounting(row)) {
       continue;
     }
     if (cursorId !== null && ref) {

package/src/plugins/defaults/memory/src/__tests__/memory-worker-routes.test.ts

@@ -4,7 +4,7 @@
  * The route handlers run inside the daemon and manage the worker process. We
  * mock worker-control + the embedding backend so the tests assert handler
  * behaviour:
- *   - start spawns as a daemon child (detached:false) and throws on failure.
+ *   - start spawns the worker and throws on failure.
  *   - stop signals the worker and reports its prior state.
  *   - status reports the worker process liveness + the embedding backend.
  */
@@ -16,7 +16,7 @@ import { getMemoryWorkerPidPath } from "../../../../../util/platform.js";
 class FakeSpawnError extends Error {}
 
 let spawnImpl: () => Promise<{ pid: number; alreadyRunning: boolean }>;
-let spawnArgs: Array<{ detached?: boolean; terminateOnTimeout?: boolean }> = [];
+let spawnArgs: Array<{ terminateOnTimeout?: boolean } | undefined> = [];
 let stopImpl: () => { status: "running" | "not_running"; pid?: number };
 let workerProbe: { status: "running" | "not_running"; pid?: number } = {
   status: "not_running",
@@ -37,10 +37,7 @@ let backendStatus: {
 
 mock.module("../../worker-control.js", () => ({
   MemoryWorkerSpawnError: FakeSpawnError,
-  spawnMemoryWorkerProcess: async (opts: {
-    detached?: boolean;
-    terminateOnTimeout?: boolean;
-  }) => {
+  spawnMemoryWorkerProcess: async (opts: { terminateOnTimeout?: boolean }) => {
     spawnArgs.push(opts);
     return spawnImpl();
   },
@@ -86,7 +83,7 @@ describe("memory_worker_start", () => {
 
     const res = await handler("memory_worker_start")();
 
-    expect(spawnArgs).toEqual([{ detached: false }]);
+    expect(spawnArgs).toEqual([undefined]);
     expect(res).toEqual({
       pid: 4242,
       alreadyRunning: false,

package/src/plugins/defaults/memory/src/memory-worker-routes.ts

@@ -62,7 +62,7 @@ const statusResponseSchema = z.object({
 async function startMemoryWorker() {
   let result: { pid: number; alreadyRunning: boolean };
   try {
-    result = await spawnMemoryWorkerProcess({ detached: false });
+    result = await spawnMemoryWorkerProcess();
   } catch (err) {
     const message =
       err instanceof MemoryWorkerSpawnError || err instanceof Error

package/src/plugins/defaults/memory/v1/job-handlers/index-maintenance.ts

@@ -4,6 +4,7 @@ import {
 } from "@vellumai/plugin-api";
 import { and, eq, isNotNull, like, ne } from "drizzle-orm";
 
+import { messageMetadataIsAmbientSightKeep } from "../../../../../persistence/conversation-types.js";
 import { getDb } from "../../../../../persistence/db-connection.js";
 import { withQdrantBreaker } from "../../../../../persistence/embeddings/qdrant-circuit-breaker.js";
 import {
@@ -66,7 +67,11 @@ export async function rebuildIndexJob(): Promise<void> {
     }
 
     const imageMessages = db
-      .select({ id: messages.id, content: messages.content })
+      .select({
+        id: messages.id,
+        content: messages.content,
+        metadata: messages.metadata,
+      })
       .from(messages)
       .where(
         and(
@@ -76,6 +81,15 @@ export async function rebuildIndexJob(): Promise<void> {
       )
       .all();
     for (const msg of imageMessages) {
+      // Ambient camera keeps were persisted with indexing skipped, and a
+      // rebuild must not be the thing that quietly puts them into memory
+      // after all. `skipIndexing` is a per-write option with no column behind
+      // it, so the row's own tag plus its `scripted` marker is the durable
+      // record of that choice. A spoken turn that merely CARRIED a frame is
+      // indexed by the live path and so is rebuilt like any other message.
+      if (messageMetadataIsAmbientSightKeep(msg.metadata)) {
+        continue;
+      }
       const blocks = extractMediaBlockMeta(msg.content);
       for (const block of blocks) {
         enqueueMemoryJob("embed_attachment", {

package/src/plugins/defaults/memory/worker-control.ts

@@ -37,8 +37,7 @@ export class MemoryWorkerSpawnError extends WorkerProcessSpawnError {}
  * failed to start).
  *
  * See {@link SpawnWorkerProcessOptions} for the generic option semantics. The
- * daemon's boot spawn passes `detached: false` (so the worker appears in
- * `assistant ps` and is torn down with the daemon) and leaves
+ * daemon's boot spawn leaves
  * `terminateOnTimeout` unset (a worker that comes up late is still the desired
  * sole drainer).
  */

package/src/providers/content-block-schema.ts

@@ -74,6 +74,7 @@ const imageContentSchema = z
   .object({
     type: z.literal("image"),
     source: mediaSourceSchema,
+    _attachmentId: z.string().optional(),
   })
   .passthrough();
 

package/src/providers/fireworks/client.ts

@@ -1,4 +1,7 @@
-import { modelEffortCeilings } from "../model-catalog.js";
+import {
+  modelEffortCeilings,
+  modelSupportedEfforts,
+} from "../model-catalog.js";
 import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
 
 export interface FireworksProviderOptions {
@@ -10,6 +13,7 @@ export interface FireworksProviderOptions {
 const DEFAULT_FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
 
 const FIREWORKS_MODEL_EFFORT_CEILINGS = modelEffortCeilings("fireworks");
+const FIREWORKS_MODEL_SUPPORTED_EFFORTS = modelSupportedEfforts("fireworks");
 
 export class FireworksProvider extends OpenAIChatCompletionsProvider {
   constructor(
@@ -39,4 +43,8 @@ export class FireworksProvider extends OpenAIChatCompletionsProvider {
   ): "high" | "xhigh" | "max" {
     return FIREWORKS_MODEL_EFFORT_CEILINGS.get(model) ?? "high";
   }
+
+  protected override resolveSupportedReasoningEfforts(model: string) {
+    return FIREWORKS_MODEL_SUPPORTED_EFFORTS.get(model);
+  }
 }

package/src/providers/gemini/client.ts

@@ -62,23 +62,36 @@ const THINKING_LEVEL_BY_NAME: Record<ThinkingLevelName, ThinkingLevel> = {
  */
 const GEMINI_PRO_DEFAULT_THINKING_LEVEL: ThinkingLevelName = "high";
 
+function normalizeGeminiModelId(model: string): string {
+  return model.startsWith("models/") ? model.slice("models/".length) : model;
+}
+
 /**
  * Gemini 3.x Pro family accepts only `low`/`medium`/`high` (no `"minimal"`) and
  * cannot fully disable thinking. Matches `gemini-3.1-pro-preview`,
  * `gemini-3.1-pro-preview-customtools`, and future `gemini-3*pro*`.
  */
 function isGeminiProModel(model: string): boolean {
-  const normalized = model.startsWith("models/")
-    ? model.slice("models/".length)
-    : model;
-  return /^gemini-3.*pro/.test(normalized);
+  return /^gemini-3.*pro/.test(normalizeGeminiModelId(model));
+}
+
+function findGeminiCatalogModel(model: string) {
+  const normalized = normalizeGeminiModelId(model);
+  return PROVIDER_CATALOG.find(
+    (provider) => provider.id === "gemini",
+  )?.models.find((m) => m.id === normalized);
 }
 
 /**
- * Lowest thinking level the model accepts. Pro's floor is `"low"`; every other
+ * Lowest thinking level the model accepts. Catalog `thinkingFloor` wins when
+ * present. Uncatalogued Gemini 3.x Pro IDs fall back to `"low"`; every other
  * thinking-capable Gemini model accepts `"minimal"`.
  */
 function geminiThinkingFloor(model: string): ThinkingLevelName {
+  const catalogFloor = findGeminiCatalogModel(model)?.thinkingFloor;
+  if (catalogFloor === "low" || catalogFloor === "minimal") {
+    return catalogFloor;
+  }
   return isGeminiProModel(model) ? "low" : "minimal";
 }
 
@@ -102,9 +115,9 @@ function clampThinkingLevelToFloor(
  * Google's per-model default apply (e.g. `gemini-3.5-flash` defaults to
  * dynamic medium-level thinking).
  *
- * - `enabled: false` maps to the model's floor — the most "off" state it
- *   allows (`"minimal"` for most models, `"low"` for Pro, which can't disable
- *   thinking).
+ * - `enabled: false` maps to the model's floor (the most "off" state it
+ *   allows): `"minimal"` for most models, `"low"` for Pro and Gemini 3.7
+ *   Flash, which reject `"minimal"`.
  * - An explicit `level` below the floor is raised to the floor.
  * - When no `level` is pinned, Pro models get the documented default (`"high"`)
  *   because an absent level resolves to the unsupported `"minimal"` upstream;
@@ -161,13 +174,7 @@ function buildThinkingConfig(
  * behavior); only an explicit `supportsThinking: false` suppresses it.
  */
 function geminiModelSupportsThinking(model: string): boolean {
-  const normalized = model.startsWith("models/")
-    ? model.slice("models/".length)
-    : model;
-  const catalogModel = PROVIDER_CATALOG.find(
-    (provider) => provider.id === "gemini",
-  )?.models.find((m) => m.id === normalized);
-  return catalogModel?.supportsThinking !== false;
+  return findGeminiCatalogModel(model)?.supportsThinking !== false;
 }
 
 function stripGeminiHttpOptions(

package/src/providers/media-resolve.ts

@@ -28,13 +28,14 @@ import {
   sniffImageMimeType,
 } from "../util/image-conversion.js";
 import { getLogger } from "../util/logger.js";
-import type {
-  Base64MediaSource,
-  ContentBlock,
-  FileContent,
-  ImageContent,
-  MediaSource,
-  Message,
+import {
+  attachmentIdFragment,
+  type Base64MediaSource,
+  type ContentBlock,
+  type FileContent,
+  type ImageContent,
+  type MediaSource,
+  type Message,
 } from "./types.js";
 
 const log = getLogger("media-resolve");
@@ -143,6 +144,21 @@ export function mediaSourceByteLength(source: MediaSource): number {
   return Math.floor((source.data.length * 3) / 4);
 }
 
+/**
+ * What a media source was, as the text that stands in for it once the bytes are
+ * gone: its media type and payload size.
+ *
+ * Every path that replaces a media block with a text stub naming what it
+ * dropped reports these same two facts, so they are derived once here. Each
+ * stub keeps its own surrounding sentence (which path dropped it, and why) and
+ * embeds this for the what. Reads the size through
+ * {@link mediaSourceByteLength}, so a reference and an inline block describe
+ * themselves the same way.
+ */
+export function mediaSourceDescriptor(source: MediaSource): string {
+  return `${source.media_type}, ${mediaSourceByteLength(source)} bytes`;
+}
+
 /**
  * Resolve a media source to inline base64, reading a reference source back from
  * its workspace location. Returns `null` when a reference can no longer be
@@ -280,9 +296,7 @@ function resolveFileBlock(block: FileContent): ContentBlock {
     ...(block.extracted_text !== undefined
       ? { extracted_text: block.extracted_text }
       : {}),
-    ...(block._attachmentId !== undefined
-      ? { _attachmentId: block._attachmentId }
-      : {}),
+    ...attachmentIdFragment(block._attachmentId),
   };
 }