@vellumai/assistant 0.8.5 → 0.8.7

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

@@ -388,230 +388,3 @@ export const MemoryV2ConfigSchema = z
   });
 
 export type MemoryV2Config = z.infer<typeof MemoryV2ConfigSchema>;
-
-/**
- * Per-lane system-prompt override for a v3 LLM call site. `override` is an
- * inline prompt string (highest precedence); `path` points at a file whose
- * contents replace the bundled prompt. Both default to `null` (use the bundled
- * prompt). Shared by the filter, descent, and gate entries under
- * `memory.v3.prompts`. The whole object is `.default(...)`-wrapped so an
- * omitted lane parses to `{ override: null, path: null }`.
- */
-const V3PromptOverrideSchema = z
-  .object({
-    override: z
-      .string({ error: "memory.v3.prompts.*.override must be a string" })
-      .nullable()
-      .default(null)
-      .describe(
-        "Optional inline system-prompt string that replaces the bundled prompt for this lane. Takes precedence over `path`. An empty or whitespace-only string is ignored (falls back to `path` / bundled).",
-      ),
-    path: z
-      .string({ error: "memory.v3.prompts.*.path must be a string" })
-      .nullable()
-      .default(null)
-      .describe(
-        "Optional path to a file whose contents replace the bundled prompt for this lane. Absolute paths are used as-is, a leading `~/` expands to the home directory, otherwise the path resolves under the workspace root. If the file is missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
-      ),
-  })
-  .default({ override: null, path: null });
-
-/**
- * Memory v3 (multi-lane, bounded-descent retrieval) configuration.
- *
- * Additive scaffolding only — defaults to `enabled: false` so existing
- * configs are untouched and the v3 retrieval loop stays inert until later
- * PRs wire it up. Every field carries a default and the whole block is
- * `.default(...)`-wrapped so a config that omits `memory.v3` entirely still
- * parses to these documented defaults.
- */
-export const MemoryV3ConfigSchema = z
-  .object({
-    enabled: z
-      .boolean({ error: "memory.v3.enabled must be a boolean" })
-      .default(false)
-      .describe(
-        "Whether the v3 memory subsystem (multi-lane bounded-descent retrieval) is enabled. Off by default until the v3 loop is wired up.",
-      ),
-    shadow: z
-      .boolean({ error: "memory.v3.shadow must be a boolean" })
-      .default(false)
-      .describe(
-        "Live-shadow toggle: when on, the v3 retrieval loop runs alongside the active path for comparison without affecting injected context. Consumed by a later PR.",
-      ),
-    passCap: z
-      .number({ error: "memory.v3.passCap must be a number" })
-      .int("memory.v3.passCap must be an integer")
-      .default(3)
-      .describe(
-        "Maximum number of retrieval passes (router → descent rounds) the v3 loop may run per turn.",
-      ),
-    breadthBudget: z
-      .number({ error: "memory.v3.breadthBudget must be a number" })
-      .int("memory.v3.breadthBudget must be an integer")
-      .default(6)
-      .describe(
-        "Per-pass breadth budget — the number of frontier candidates the v3 loop may expand at each step.",
-      ),
-    maxDepth: z
-      .number({ error: "memory.v3.maxDepth must be a number" })
-      .int("memory.v3.maxDepth must be an integer")
-      .default(6)
-      .describe(
-        "Maximum descent depth the v3 loop traverses through the memory tree before stopping.",
-      ),
-    denseQuota: z
-      .object({
-        activeDomain: z
-          .number({
-            error: "memory.v3.denseQuota.activeDomain must be a number",
-          })
-          .describe(
-            "Dense-lane candidate quota allocated to the conversation's active domain.",
-          ),
-        offDomain: z
-          .number({ error: "memory.v3.denseQuota.offDomain must be a number" })
-          .describe(
-            "Dense-lane candidate quota allocated to off-domain (exploratory) retrieval.",
-          ),
-      })
-      .default({ activeDomain: 30, offDomain: 8 })
-      .describe(
-        "Dense-lane candidate quotas split between the active domain and off-domain exploration.",
-      ),
-    hotLimit: z
-      .number({ error: "memory.v3.hotLimit must be a number" })
-      .int("memory.v3.hotLimit must be an integer")
-      .positive("memory.v3.hotLimit must be positive")
-      .default(50)
-      .describe(
-        "Top-N cap on the hot scout lane, ranked by injection-frequency EMA. Hot hits are sticky (kept past the gate), so this bounds how many always-on pages the lane forces into the selection. Without a cap a mature corpus — where nearly every page has been injected at some point — surfaces the entire corpus.",
-      ),
-    lanes: z
-      .object({
-        hot: z
-          .boolean()
-          .default(true)
-          .describe("Whether the hot (recently-touched) retrieval lane is on."),
-        sparse: z
-          .boolean()
-          .default(true)
-          .describe("Whether the sparse (BM25-style keyword) lane is on."),
-        dense: z
-          .boolean()
-          .default(true)
-          .describe("Whether the dense (embedding-similarity) lane is on."),
-        tree: z
-          .boolean()
-          .default(true)
-          .describe("Whether the tree (hierarchical descent) lane is on."),
-        edges: z
-          .boolean()
-          .default(true)
-          .describe("Whether the edges (graph-adjacency) lane is on."),
-      })
-      .default({
-        hot: true,
-        sparse: true,
-        dense: true,
-        tree: true,
-        edges: true,
-      })
-      .describe(
-        "Per-lane on/off toggles for the v3 multi-lane retrieval fanout. All lanes on by default.",
-      ),
-    ks: z
-      .array(z.number({ error: "memory.v3.ks entries must be numbers" }))
-      .default([5, 10, 25, 50])
-      .describe(
-        "Evaluation top-K cutoffs the v3 loop reports metrics at (e.g. recall@K).",
-      ),
-    write: z
-      .object({
-        enabled: z
-          .boolean({ error: "memory.v3.write.enabled must be a boolean" })
-          .default(false)
-          .describe(
-            "Whether v3 consolidation owns the shared-buffer drain + tree build. Off by default — v2 consolidation stays the sole buffer-drainer. Does NOT introduce a separate buffer.",
-          ),
-        consolidateIntervalMs: z
-          .number({
-            error: "memory.v3.write.consolidateIntervalMs must be a number",
-          })
-          .int("memory.v3.write.consolidateIntervalMs must be an integer")
-          .positive("memory.v3.write.consolidateIntervalMs must be positive")
-          .default(3600000)
-          .describe(
-            "Interval, in milliseconds, between scheduled v3 consolidation runs once the v3 write path owns the drain. Default 1 hour.",
-          ),
-        coactivation: z
-          .boolean({ error: "memory.v3.write.coactivation must be a boolean" })
-          .default(false)
-          .describe(
-            "Whether v3 consolidation learns co-activation edges during the tree build. Off by default; consumed by a later PR.",
-          ),
-      })
-      .default({
-        enabled: false,
-        consolidateIntervalMs: 3600000,
-        coactivation: false,
-      })
-      .describe(
-        "Memory v3 write-path configuration. All default-off scaffolding — controls whether v3 consolidation owns the shared-buffer drain + tree build. Consumed by later PRs.",
-      ),
-    prompts: z
-      .object({
-        filter: V3PromptOverrideSchema.describe(
-          "Override for the dense-hit filter lane's system prompt.",
-        ),
-        descent: V3PromptOverrideSchema.describe(
-          "Override for the tree-walk descent driver's system prompt.",
-        ),
-        gate: V3PromptOverrideSchema.describe(
-          "Override for the selection gate's system prompt.",
-        ),
-      })
-      .default({
-        filter: { override: null, path: null },
-        descent: { override: null, path: null },
-        gate: { override: null, path: null },
-      })
-      .describe(
-        "Per-lane system-prompt overrides for the three v3 LLM call sites (filter, descent, gate). Each entry takes an inline `override` string (highest precedence) and/or a file `path` whose contents replace the bundled prompt; absolute paths are used as-is, a leading `~/` expands to the home directory, otherwise the path resolves under the workspace root. An empty/whitespace inline override or a missing/unreadable/empty file falls back to the bundled prompt. Lets the prompts be iterated at runtime without a rebuild/restart — mirroring `memory.v2.router.router_prompt_path`.",
-      ),
-    gateCandidateSummaries: z
-      .boolean({
-        error: "memory.v3.gateCandidateSummaries must be a boolean",
-      })
-      .default(false)
-      .describe(
-        "When true, the selection gate sees each candidate as `slug — summary` instead of the bare slug, so it can judge relevance on page content. Off by default: with the bundled (precision-leaning) gate prompt this makes the gate more selective. It pays off paired with a recall-leaning gate prompt override, where the summaries let the gate recognize non-obvious associative/emotional matches it would otherwise pass over. Adds the candidate summaries to the gate prompt (larger input).",
-      ),
-  })
-  .default({
-    enabled: false,
-    shadow: false,
-    passCap: 3,
-    breadthBudget: 6,
-    maxDepth: 6,
-    denseQuota: { activeDomain: 30, offDomain: 8 },
-    hotLimit: 50,
-    lanes: { hot: true, sparse: true, dense: true, tree: true, edges: true },
-    ks: [5, 10, 25, 50],
-    write: {
-      enabled: false,
-      consolidateIntervalMs: 3600000,
-      coactivation: false,
-    },
-    prompts: {
-      filter: { override: null, path: null },
-      descent: { override: null, path: null },
-      gate: { override: null, path: null },
-    },
-    gateCandidateSummaries: false,
-  })
-  .describe(
-    "Memory v3 — multi-lane bounded-descent retrieval. Additive scaffolding, disabled by default.",
-  );
-
-export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+/**
+ * Memory v3 (topic-tree routing) working-set configuration.
+ *
+ * The working set is the per-conversation set of concept pages carried
+ * forward across turns. Eviction keeps it bounded: pages unseen for longer
+ * than `evictWindow` turns are dropped, and the set is capped at `maxPages`.
+ */
+export const MemoryV3WorkingSetSchema = z
+  .object({
+    maxPages: z
+      .number({ error: "memory.v3.workingSet.maxPages must be a number" })
+      .int("memory.v3.workingSet.maxPages must be an integer")
+      .positive("memory.v3.workingSet.maxPages must be a positive integer")
+      .default(150)
+      .describe(
+        "Upper bound on the number of pages retained in the working set. Once exceeded, the least-salient non-pinned pages are evicted until the set fits.",
+      ),
+    evictWindow: z
+      .number({ error: "memory.v3.workingSet.evictWindow must be a number" })
+      .int("memory.v3.workingSet.evictWindow must be an integer")
+      .positive("memory.v3.workingSet.evictWindow must be a positive integer")
+      .default(5)
+      .describe(
+        "Number of turns a non-pinned page may go unseen before it is evicted from the working set.",
+      ),
+  })
+  .describe("Memory v3 working-set retention/eviction tuning.");
+
+export const MemoryV3ConfigSchema = z
+  .object({
+    workingSet: MemoryV3WorkingSetSchema.default(
+      MemoryV3WorkingSetSchema.parse({}),
+    ),
+  })
+  .describe("Memory v3 — topic-tree routing with a carry-forward working set");
+
+export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

package/src/config/schemas/memory.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import {
   MemoryCleanupConfigSchema,
   MemoryJobsConfigSchema,
+  MemoryMaintenanceConfigSchema,
   MemoryRetentionConfigSchema,
 } from "./memory-lifecycle.js";
 import {
@@ -16,7 +17,8 @@ import {
   MemorySegmentationConfigSchema,
   QdrantConfigSchema,
 } from "./memory-storage.js";
-import { MemoryV2ConfigSchema, MemoryV3ConfigSchema } from "./memory-v2.js";
+import { MemoryV2ConfigSchema } from "./memory-v2.js";
+import { MemoryV3ConfigSchema } from "./memory-v3.js";
 
 export const MemoryConfigSchema = z
   .object({
@@ -43,6 +45,9 @@ export const MemoryConfigSchema = z
     cleanup: MemoryCleanupConfigSchema.default(
       MemoryCleanupConfigSchema.parse({}),
     ),
+    maintenance: MemoryMaintenanceConfigSchema.default(
+      MemoryMaintenanceConfigSchema.parse({}),
+    ),
     extraction: MemoryExtractionConfigSchema.default(
       MemoryExtractionConfigSchema.parse({}),
     ),

package/src/config/schemas/services.ts

@@ -46,13 +46,17 @@ const ImageGenerationServiceSchema = BaseServiceSchema.extend({
 });
 
 const WebSearchServiceSchema = BaseServiceSchema.extend({
+  // Provider choice for app-executed search in Your Own mode, or the native
+  // hosted-search preference when set to `inference-provider-native`. In
+  // Managed mode, non-native inference providers can still use the platform
+  // managed search proxy through the app-executed `web_search` tool.
   provider: z
     .enum(VALID_WEB_SEARCH_PROVIDERS)
     .default("inference-provider-native"),
 });
 
 const GoogleOAuthServiceSchema = BaseServiceSchema.extend({
-  mode: ServiceModeSchema.default("your-own"),
+  mode: ServiceModeSchema.default("managed"),
 });
 
 const OutlookOAuthServiceSchema = BaseServiceSchema.extend({
@@ -68,7 +72,7 @@ const GitHubOAuthServiceSchema = BaseServiceSchema.extend({
 });
 
 const NotionOAuthServiceSchema = BaseServiceSchema.extend({
-  mode: ServiceModeSchema.default("your-own"),
+  mode: ServiceModeSchema.default("managed"),
 });
 
 const TwitterOAuthServiceSchema = BaseServiceSchema.extend({

package/src/config/schemas/timeouts.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 
+import { DEFAULT_TOOL_EXECUTION_TIMEOUT_SEC } from "../../api/constants/tool-execution.js";
+
 export const TimeoutConfigSchema = z
   .object({
     shellMaxTimeoutSec: z
@@ -30,7 +32,7 @@ export const TimeoutConfigSchema = z
       .number({ error: "timeouts.toolExecutionTimeoutSec must be a number" })
       .finite("timeouts.toolExecutionTimeoutSec must be finite")
       .positive("timeouts.toolExecutionTimeoutSec must be a positive number")
-      .default(120)
+      .default(DEFAULT_TOOL_EXECUTION_TIMEOUT_SEC)
       .describe("Default timeout for tool execution in seconds"),
     providerStreamTimeoutSec: z
       .number({ error: "timeouts.providerStreamTimeoutSec must be a number" })

package/src/config/seed-inference-profiles.ts

@@ -1,7 +1,6 @@
 import type { DrizzleDb } from "../memory/db-connection.js";
 import {
   createConnection,
-  disableManagedConnectionsForByokHatch,
   getConnection,
   MANAGED_CONNECTION_NAMES,
   PROVIDERS_REQUIRING_BASE_URL_AND_MODELS,
@@ -123,9 +122,18 @@ const USER_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
   },
 };
 
-export const MANAGED_PROFILE_NAMES = new Set(
-  Object.keys(MANAGED_PROFILE_TEMPLATES),
-);
+/**
+ * The "auto" profile key. When active, the daemon injects the
+ * `switch_inference_profile` tool and lets the model self-select a profile
+ * per query. No provider/model — the resolver falls through to the call-site
+ * default (balanced or custom-balanced for BYOK).
+ */
+export const AUTO_PROFILE_KEY = "auto";
+
+export const MANAGED_PROFILE_NAMES = new Set([
+  ...Object.keys(MANAGED_PROFILE_TEMPLATES),
+  AUTO_PROFILE_KEY,
+]);
 
 export type SeedInferenceProfilesOptions = {
   /**
@@ -263,21 +271,28 @@ export function seedInferenceProfiles(
     profiles[name] = next as ProfileEntry;
   }
 
+  // 1b. Auto profile — a metadata-only profile with no provider/model. When
+  //     the user selects "Auto", the resolver falls through to the call-site
+  //     default (balanced or custom-balanced), and the agent loop injects the
+  //     switch_inference_profile tool so the model can self-select per query.
+  if (!preservedProfileNames.has(AUTO_PROFILE_KEY)) {
+    const previousAuto = readObject(profiles[AUTO_PROFILE_KEY]);
+    const autoEntry: Record<string, unknown> = {
+      source: "managed",
+      label: "Auto",
+      description:
+        "Automatically routes each query to the best profile — fast for simple questions, capable for complex ones",
+    };
+    if (previousAuto) {
+      if ("label" in previousAuto) autoEntry.label = previousAuto.label;
+      if ("status" in previousAuto) autoEntry.status = previousAuto.status;
+    }
+    profiles[AUTO_PROFILE_KEY] = autoEntry as ProfileEntry;
+  }
+
   // 2. User profiles — only at hatch time for off-platform installations.
   let userConnectionName: string | undefined;
   if (options.isHatch && !isPlatform) {
-    // BYOK hatch: disable canonical managed connections so the picker doesn't
-    // surface unusable platform-auth options on day one. If the hatch overlay
-    // selected a managed profile, leave that connection active; the user has
-    // already chosen managed inference. Runs only here, only at hatch —
-    // `seedCanonicalConnections` leaves `status` alone on subsequent boots so
-    // a post-hatch user re-enable persists.
-    if (options.db) {
-      disableManagedConnectionsForByokHatch(options.db, {
-        excludeConnection: hatchSelectedManagedConnection,
-      });
-    }
-
     const hatchProvider = readString(readObject(llm.default)?.provider);
     if (
       hatchProvider &&
@@ -336,10 +351,15 @@ export function seedInferenceProfiles(
   }
 
   // Profile ordering — ensure all seeded profiles appear in the order array.
+  // "auto" is prepended so it appears first in the picker.
   const profileOrder = Array.isArray(llm.profileOrder)
     ? (llm.profileOrder as string[])
     : [];
   const orderSet = new Set(profileOrder);
+  if (!orderSet.has(AUTO_PROFILE_KEY)) {
+    profileOrder.unshift(AUTO_PROFILE_KEY);
+    orderSet.add(AUTO_PROFILE_KEY);
+  }
   for (const name of Object.keys(MANAGED_PROFILE_TEMPLATES)) {
     if (!orderSet.has(name)) {
       profileOrder.push(name);

package/src/context/compactor.ts

@@ -22,6 +22,7 @@ import { optimizeImageForTransport } from "../agent/image-optimize.js";
 import type { CompactionConfig } from "../config/schemas/compaction.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { stripInjectionsForCompaction } from "../daemon/conversation-runtime-assembly.js";
+import { filterMessagesForUntrustedActor } from "../daemon/message-provenance.js";
 import {
   getAttachmentContent,
   getAttachmentMetadataForMessage,
@@ -36,6 +37,10 @@ import type {
   ProviderResponse,
   ToolDefinition,
 } from "../providers/types.js";
+import {
+  isUntrustedTrustClass,
+  type TrustClass,
+} from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
 import { estimatePromptTokens } from "./token-estimator.js";
 
@@ -181,6 +186,13 @@ export interface CompactionRunArgs {
   force?: boolean;
   signal?: AbortSignal;
   overrideProfile?: string | null;
+  /**
+   * Trust class of the actor whose turn triggered compaction. When the
+   * actor is untrusted, the image manifest is filtered to exclude
+   * guardian-only attachments so they cannot be retained back into the
+   * untrusted actor's context.
+   */
+  actorTrustClass?: TrustClass;
   /**
    * Number of leading non-persisted messages (e.g. inherited summary from a
    * parent fork). Compacted-persisted-count subtracts this so the DB
@@ -337,9 +349,21 @@ interface ManifestEntry {
  * `filename` is the attachment's `originalFilename`; collisions across
  * messages are kept as separate entries (the model can disambiguate via
  * the timestamp it sees in the manifest).
+ *
+ * For untrusted actors the rows are first filtered through
+ * {@link filterMessagesForUntrustedActor} — the same provenance filter
+ * `loadFromDb` applies when assembling history — so guardian-only images
+ * never enter the manifest and therefore can never be retained back into
+ * an untrusted actor's view.
  */
-export function collectImageManifest(conversationId: string): ManifestEntry[] {
-  const rows = getMessages(conversationId);
+export function collectImageManifest(
+  conversationId: string,
+  actorTrustClass?: TrustClass,
+): ManifestEntry[] {
+  const allRows = getMessages(conversationId);
+  const rows = isUntrustedTrustClass(actorTrustClass)
+    ? filterMessagesForUntrustedActor(allRows)
+    : allRows;
   const entries: ManifestEntry[] = [];
   for (const row of rows) {
     const atts = getAttachmentMetadataForMessage(row.id);
@@ -682,7 +706,12 @@ export async function runAssistantDrivenCompaction(
 
   // Build image manifest from the DB before invoking the model so the
   // instruction message carries a faithful picture of available images.
-  const manifest = collectImageManifest(args.conversationId);
+  // Filtered by actor trust so untrusted turns never see guardian-only
+  // attachments.
+  const manifest = collectImageManifest(
+    args.conversationId,
+    args.actorTrustClass,
+  );
   const manifestText = renderImageManifest(manifest);
   const instruction = buildInstructionMessage(
     args.compaction.prompt ?? null,
@@ -695,21 +724,18 @@ export async function runAssistantDrivenCompaction(
 
   let response: ProviderResponse;
   try {
-    response = await args.provider.sendMessage(
-      requestMessages,
-      args.tools,
-      args.systemPrompt,
-      {
-        signal: args.signal,
-        config: {
-          callSite: COMPACTION_CALL_SITE,
-          usageTracking: "manual",
-          ...(args.overrideProfile
-            ? { overrideProfile: args.overrideProfile }
-            : {}),
-        },
+    response = await args.provider.sendMessage(requestMessages, {
+      tools: args.tools,
+      systemPrompt: args.systemPrompt,
+      signal: args.signal,
+      config: {
+        callSite: COMPACTION_CALL_SITE,
+        usageTracking: "manual",
+        ...(args.overrideProfile
+          ? { overrideProfile: args.overrideProfile }
+          : {}),
       },
-    );
+    });
   } catch (err) {
     log.warn({ err }, "Compaction provider call failed");
     return {
@@ -1068,21 +1094,18 @@ export async function runEmergencyCompaction(
 
   let response: ProviderResponse;
   try {
-    response = await args.provider.sendMessage(
-      requestMessages,
-      args.tools,
-      args.systemPrompt,
-      {
-        signal: args.signal,
-        config: {
-          callSite: COMPACTION_CALL_SITE,
-          usageTracking: "manual",
-          ...(args.overrideProfile
-            ? { overrideProfile: args.overrideProfile }
-            : {}),
-        },
+    response = await args.provider.sendMessage(requestMessages, {
+      tools: args.tools,
+      systemPrompt: args.systemPrompt,
+      signal: args.signal,
+      config: {
+        callSite: COMPACTION_CALL_SITE,
+        usageTracking: "manual",
+        ...(args.overrideProfile
+          ? { overrideProfile: args.overrideProfile }
+          : {}),
       },
-    );
+    });
   } catch (err) {
     log.warn({ err }, "Emergency compaction provider call failed");
     return {

package/src/context/token-estimator.ts

@@ -1,3 +1,7 @@
+import {
+  estimateGeminiAudioTokens,
+  normalizeGeminiAudioMime,
+} from "../providers/gemini/inline-media.js";
 import type {
   ContentBlock,
   Message,
@@ -116,6 +120,16 @@ function estimateFileDataTokens(
     return estimateAnthropicPdfTokens(block.source.data);
   }
 
+  // Gemini hears audio natively (inline base64) but bills it at ~32 tokens/sec.
+  // Estimate from duration, not payload size, to avoid a ~170x over-count that
+  // would trigger spurious compaction.
+  if (
+    providerName === "gemini" &&
+    normalizeGeminiAudioMime(block.source.media_type) !== null
+  ) {
+    return estimateGeminiAudioTokens(block.source.data);
+  }
+
   // Gemini sends certain file types inline as base64
   if (
     providerName === "gemini" &&
@@ -154,11 +168,16 @@ function estimateGeminiImageTokens(width: number, height: number): number {
   ) {
     return GEMINI_IMAGE_TOKENS_PER_TILE;
   }
-  // Gemini resizes images so the longest side is ≤3072px before tiling.
-  const clampedWidth = Math.min(width, GEMINI_IMAGE_MAX_DIMENSION);
-  const clampedHeight = Math.min(height, GEMINI_IMAGE_MAX_DIMENSION);
-  const tilesWide = Math.ceil(clampedWidth / GEMINI_IMAGE_TILE_SIZE);
-  const tilesHigh = Math.ceil(clampedHeight / GEMINI_IMAGE_TILE_SIZE);
+  // Gemini rescales both dimensions by a single aspect-preserving factor so
+  // the longest side is ≤3072px before tiling. Clamping each side
+  // independently would over-count tiles for extreme aspect ratios
+  // (e.g. 10000×1000 → 3072×307, not 3072×1000).
+  const scale = Math.min(
+    1,
+    GEMINI_IMAGE_MAX_DIMENSION / Math.max(width, height),
+  );
+  const tilesWide = Math.ceil((width * scale) / GEMINI_IMAGE_TILE_SIZE);
+  const tilesHigh = Math.ceil((height * scale) / GEMINI_IMAGE_TILE_SIZE);
   return tilesWide * tilesHigh * GEMINI_IMAGE_TOKENS_PER_TILE;
 }
 
@@ -220,6 +239,11 @@ export function estimateContentBlockTokens(
             tokens += estimateContentBlockTokens(cb, options);
           } else if (cb.type === "image" && !anthropicDropsErrorImage) {
             tokens += estimateContentBlockTokens(cb, options);
+          } else if (cb.type === "file") {
+            // Audio file sub-blocks (e.g. file_read on an .mp3) are sent inline
+            // to Gemini; estimateFileDataTokens charges the ~32 tok/sec audio
+            // rate for Gemini and ~0 for providers that drop the block.
+            tokens += estimateContentBlockTokens(cb, options);
           }
         }
       }