mixdog 1.0.2 → 1.0.4

package/src/runtime/agent/orchestrator/tools/builtin/lib/grep-pattern-fanout.mjs

@@ -9,6 +9,7 @@ import { GREP_AUTO_CONTEXT_LINES, trueCasePath } from '../path-utils.mjs';
 import { buildGrepRgArgs } from '../search-builders.mjs';
 import { runRgWindowedLines } from '../native-search-runner.mjs';
 import { statReachable } from '../fs-reachability.mjs';
+import { runSharedNativeScan } from './shared-native-scan.mjs';
 import {
   dedupeFanoutMatchLines,
   formatGrepFanoutSections,
@@ -67,13 +68,15 @@ async function fanoutPrefilterCandidates(request) {
       multilineMode,
       withFilename: false,
     });
-    const pre = await request.runWindowedLines(
-      prefilterArgs,
-      { cwd: scope.cwd, signal: options.signal },
+    const pre = await runSharedNativeScan(request.runWindowedLines, {
+      cwd: scope.cwd,
+      argv: prefilterArgs,
       // Whole-scope fallback pass: the broad admission lane keeps it
       // from competing with interactive searches for disk bandwidth.
-      { offset: 0, limit: GREP_FANOUT_PREFILTER_FILE_CAP, summaryLimit: 0, bulkHint: true }
-    );
+      window: { offset: 0, limit: GREP_FANOUT_PREFILTER_FILE_CAP, summaryLimit: 0, bulkHint: true },
+      scopes: [grepResolvedPath],
+      signal: options.signal,
+    });
     return pre.complete && !pre.partial ? pre.lines : null;
   } catch {
     options.signal?.throwIfAborted();
@@ -245,11 +248,13 @@ async function streamCombinedLines(request, scope) {
   const combinedCap = Math.min(4000, Math.max(400, perPatternWindow * patterns.length));
   const combinedBulkHint = request.normalizedGlobPatterns.length === 0 && !request.fileType;
   try {
-    return await request.runWindowedLines(
-      combinedArgs,
-      { cwd: scope.cwd, signal: options.signal },
-      { offset: 0, limit: combinedCap, summaryLimit: 0, bulkHint: combinedBulkHint }
-    );
+    return await runSharedNativeScan(request.runWindowedLines, {
+      cwd: scope.cwd,
+      argv: combinedArgs,
+      window: { offset: 0, limit: combinedCap, summaryLimit: 0, bulkHint: combinedBulkHint },
+      scopes: [request.grepResolvedPath],
+      signal: options.signal,
+    });
   } catch {
     options.signal?.throwIfAborted();
     return null;

package/src/runtime/agent/orchestrator/tools/builtin/lib/grep-request.mjs

@@ -90,7 +90,7 @@ function rebaseAbsoluteGlob(glob, rootFwd) {
   };
 }
 
-async function resolveGrepScope(args, workDir) {
+export async function resolveGrepScope(args, workDir) {
   let searchPath = args.path || '.';
   const rawGlobs = uniqueStrings(stringList(args.glob).map(normalizeInputPath));
   if (hasGlobMagic(searchPath)) {

package/src/runtime/agent/orchestrator/tools/builtin/lib/shared-native-scan.mjs

@@ -0,0 +1,12 @@
+// Shares only identical in-flight native scans (no persistent result). The
+// existing single-flight layer isolates subscriber cancellation and detaches
+// a scan after a mutation without interrupting its current readers.
+import { runResultCacheInFlight } from '../cache-layers.mjs';
+
+export function runSharedNativeScan(runWindowedLines, { cwd, argv, window, scopes, signal }) {
+  return runResultCacheInFlight(
+    `grep-path-scan:${JSON.stringify([cwd, argv, window])}`,
+    ({ signal: sharedSignal }) => runWindowedLines(argv, { cwd, signal: sharedSignal }, window),
+    { signal, scopes }
+  );
+}

package/src/runtime/agent/orchestrator/tools/builtin/read-source-windows.mjs

@@ -1,6 +1,8 @@
 import { open } from 'node:fs/promises';
 import { hashText } from './hash-utils.mjs';
+import { runResultCacheInFlight } from './cache-layers.mjs';
 import {
+  canonicalCachePath,
   getReadRangeIndex,
   nearestReadRangeAnchor,
   maybeRecordReadRangeAnchor,
@@ -13,6 +15,18 @@ import { READ_MAX_SCAN_BYTES, READ_STREAM_TIMEOUT_MS } from './read-constants.mj
 export async function readSourceWindows(path, intervals, { signal } = {}) {
   signal?.throwIfAborted();
   if (!intervals.length) return new Map();
+  const snapshot = intervals.map(({ start, end }) => ({ start, end }));
+  const key = `source-windows:${canonicalCachePath(path)}:${JSON.stringify(snapshot.map((w) => [w.start, w.end]))}`;
+  const shared = await runResultCacheInFlight(
+    key,
+    ({ signal: sharedSignal }) => scanSourceWindows(path, snapshot, sharedSignal),
+    { signal, scopes: [path] }
+  );
+  return new Map(shared);
+}
+
+async function scanSourceWindows(path, intervals, signal) {
+  signal?.throwIfAborted();
   const handle = await open(path, 'r');
   try {
     const st = await handle.stat();

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,30 +1,30 @@
 {
-  "version": "0.1.30",
+  "version": "0.1.31",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-darwin-arm64",
-      "sha256": "cf306f716eeacb46b4a6a99b94ceb97f20be6facc7e4c6aa3274124e38a13efc"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-darwin-arm64",
+      "sha256": "7fbbb99fd98da1fee7d3cdb90c73c9b4ec663a8ea108bbc0f7ee30e194571ed1"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-darwin-x64",
-      "sha256": "2ed1d6d98bee1db750c5b9df86ee2affa59f0afce28e2753772dca1dcdf9dd6d"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-darwin-x64",
+      "sha256": "8cdbcdf3e207ead5ba274b87363ba1e8acc2c68d5912d95a29cd89cbecdc3c46"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-linux-arm64",
-      "sha256": "9963d0fb086bcd99341436458b207b6e521e9750bf75f817f0e6e99ebf7a30db"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-linux-arm64",
+      "sha256": "704361e56ee605d6dd5edcb014e3cc0c3e11b7909639d5d8cacc9d75ad1134d2"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-linux-x64",
-      "sha256": "79c6811c6bb3e05f4e048ebbe98bf28429e4b82763106c488d929668a2326cba"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-linux-x64",
+      "sha256": "ef80b2bb372e98e5e71f11cf720fc709ec79f187d95c00bcef3b3c8d23f22f47"
     },
     "win32-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-win32-arm64.exe",
-      "sha256": "8a1c8d623ee6e54948da2c77f5a8def5c9eafc3c6f2866c0c46c91bdaae393d0"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-win32-arm64.exe",
+      "sha256": "8fe669f56b6bd17705cdd24e16e705a40dc4ffe210fad0e9692d51c365a9a072"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-win32-x64.exe",
-      "sha256": "8d123e5044aee4b41e820361bd0dd1012a09a2da93a0074d21774602505784f4"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-win32-x64.exe",
+      "sha256": "ca2e4045fd4757b4b4e39de9d4df7790d9bcccc083ffca96a6f0cffbb1130f1d"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/patch/apply-patch/codex-batch.mjs

@@ -2,6 +2,7 @@
 // target), then apply it in one shot under path locks with all-or-nothing
 // rollback.
 import { parsePatch } from 'diff';
+import { throwIfAborted } from '../../../../../shared/abort-race.mjs';
 import { withBuiltinPathLocks } from '../../builtin.mjs';
 import { withAdvisoryLocks } from '../../builtin/advisory-lock.mjs';
 import { wrapPatchMutationOutput } from '../mutation-output.mjs';
@@ -155,7 +156,7 @@ export async function runCodexBatch({ batch, basePath, v4aConvertOpts, rejectedV
 // it whenever the batch fails — by returned Error text OR by a thrown error
 // (V4A rename, persistence) — so mode:"atomic" really is all-or-nothing
 // instead of leaving an earlier commit in place.
-export function applyCodexBatchWithRollback({ batch, basePath, dryRun, readStateScope, options, runBatch }) {
+export function applyCodexBatchWithRollback({ batch, basePath, dryRun, readStateScope, abortSignal, options, runBatch }) {
   const { lockPaths, v4aRenamePlan } = batch;
   const registerUiDiff = (rollbackSnapshots) =>
     registerCommittedPatchUiDiff({
@@ -168,6 +169,7 @@ export function applyCodexBatchWithRollback({ batch, basePath, dryRun, readState
     });
   return withBuiltinPathLocks(lockPaths, () =>
     withAdvisoryLocks(lockPaths, async () => {
+      throwIfAborted(abortSignal);
       let rollbackSnapshots = [];
       if (!dryRun) {
         try {

package/src/runtime/agent/orchestrator/tools/patch/dispatch.mjs

@@ -8,6 +8,7 @@ import { countLabel, formatNativeSummary, kindLabel, traceNativeApply } from './
 import { unlink } from 'node:fs/promises';
 import { dirname as pathDirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
+import { throwIfAborted } from '../../../../shared/abort-race.mjs';
 import {
   normalizeOutputPath,
   invalidateBuiltinResultCache,
@@ -154,6 +155,7 @@ export async function dispatchNativePatch({
         dryRun,
         fuzzy: fuzz > 0,
         readStateScope,
+        signal,
       });
       if (!/^Error:/i.test(String(recovered || '').trimStart())) {
         return `${recovered}\n[native transport unavailable; create-only patch completed with the JS engine]`;
@@ -326,19 +328,19 @@ function findParsedForRow(row, parsed, basePath) {
   return null;
 }
 
-async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope }) {
+async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope, signal }) {
   const kind = classifyEntry(entry);
   const headerName = entryHeaderName(entry, kind);
   const fullPath = resolveEntryPath(basePath, headerName);
   const displayPath = normalizeOutputPath(stripDiffPrefix(headerName));
-  if (kind === 'create') await applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readStateScope });
-  else if (kind === 'delete') await applyJsDeleteEntry(fullPath, displayPath, { dryRun, readStateScope });
-  else await applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy, readStateScope });
+  if (kind === 'create') await applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readStateScope, signal });
+  else if (kind === 'delete') await applyJsDeleteEntry(fullPath, displayPath, { dryRun, readStateScope, signal });
+  else await applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy, readStateScope, signal });
   const { added, removed } = countHunkChanges(entry.hunks);
   return { kind, fullPath, displayPath, added, removed };
 }
 
-async function applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readStateScope }) {
+async function applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readStateScope, signal }) {
   // Add File is create-only. atomicWrite checks the absent-target
   // expectation again so a file appearing after preflight is not replaced.
   assertAddTargetAbsent(fullPath, displayPath);
@@ -350,9 +352,11 @@ async function applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readSt
   }
   const content = joinTextLinesForPatch(addedLines);
   if (dryRun) return;
+  throwIfAborted(signal);
   mkdirSync(pathDirname(fullPath), { recursive: true });
   try {
     await atomicWrite(fullPath, content, {
+      signal,
       sessionId: readStateScope,
       expectedTargetSnapshot: { exists: false },
     });
@@ -369,16 +373,17 @@ async function applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readSt
   recordReadSnapshotForPath(fullPath, readStateScope, { source: 'apply_patch_js', isPartialView: false });
 }
 
-async function applyJsDeleteEntry(fullPath, displayPath, { dryRun, readStateScope }) {
+async function applyJsDeleteEntry(fullPath, displayPath, { dryRun, readStateScope, signal }) {
   lstatRegularPatchFile(fullPath, displayPath);
   if (dryRun) return;
+  throwIfAborted(signal);
   await unlink(fullPath);
   invalidateBuiltinResultCache([fullPath]);
   markCodeGraphDirtyPaths([fullPath]);
   clearReadSnapshotForPath(fullPath, readStateScope);
 }
 
-async function applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy, readStateScope }) {
+async function applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy, readStateScope, signal }) {
   const preMutationStat = lstatRegularPatchFile(fullPath, displayPath);
   const { writePath, snapshotStat } = resolvePatchWriteTarget(fullPath, displayPath, preMutationStat);
   // Rewrite path: decode by BOM, re-encode into the same codec, and keep every
@@ -393,11 +398,13 @@ async function applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy,
   });
   const content = encodePatchTargetContent(joinTextLinesForPatch(updatedLines), rawEnc);
   if (dryRun) return;
+  throwIfAborted(signal);
   // The expected-target snapshot closes the read→write window: if anything
   // rewrote this file after we read it, the write fails instead of silently
   // clobbering it (and instead of inheriting a stale "body delivered" claim).
   try {
     await atomicWrite(writePath, content, {
+      signal,
       sessionId: readStateScope,
       expectedTargetSnapshot: snapshotStat
         ? {
@@ -427,13 +434,14 @@ async function applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy,
   });
 }
 
-export async function dispatchJsPatchEntries({ rows, parsed, basePath, dryRun, fuzzy, readStateScope }) {
+export async function dispatchJsPatchEntries({ rows, parsed, basePath, dryRun, fuzzy, readStateScope, signal }) {
   const applied = [];
   for (const row of rows || []) {
     const entry = findParsedForRow(row, parsed, basePath);
     if (!entry) throw new Error(`apply_patch: missing parsed entry for ${row.displayPath}`);
     try {
-      applied.push(await applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope }));
+      throwIfAborted(signal);
+      applied.push(await applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope, signal }));
     } catch (err) {
       return `Error: ${err?.message || String(err)}`;
     }

package/src/runtime/agent/orchestrator/tools/patch/orchestrator.mjs

@@ -66,6 +66,7 @@ async function apply_patch(rawArgs, cwd, options = {}) {
     basePath,
     dryRun,
     readStateScope,
+    abortSignal,
     options,
     runBatch: () =>
       runCodexBatch({

package/src/runtime/agent/orchestrator/tools/patch/wave.mjs

@@ -2,6 +2,7 @@
 // JS writer split. Both the Codex batch and the ordered sequence share these
 // apply semantics.
 import { parsePatch } from 'diff';
+import { throwIfAborted } from '../../../../shared/abort-race.mjs';
 import { symlinkWriteTarget } from '../builtin/atomic-write.mjs';
 import { dispatchNativePatch, dispatchJsPatchEntries } from './dispatch.mjs';
 import { patchTargetUsesUtf16 } from './matcher.mjs';
@@ -33,6 +34,7 @@ export function parseConvertedUnifiedPatch(unified) {
 // whether earlier waves already committed to disk.
 export async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewrites: whr }, basePath, opts) {
   const { fuzz, rejectPartial, dryRun, fuzzy, readStateScope, abortSignal } = opts;
+  throwIfAborted(abortSignal);
   // Create entries use the JS atomic writer even inside the base path. Its
   // expected-absent snapshot makes Add File create-only under external races;
   // the native patch engine intentionally supports overwrite-style additions.
@@ -47,6 +49,7 @@ export async function applyParsedWave({ parsed: wparsed, entries: wentries, head
   // binary that predates this build's byte-fidelity contract is not used at
   // all — everything takes the JS writer instead.
   const engineContractOk = await nativePatchSessionSatisfiesContract();
+  throwIfAborted(abortSignal);
   // Codec routing only concerns entries that REWRITE bytes; a delete does not.
   // An unverified engine, however, must receive no work at all — deletes
   // included — so the whole wave takes the JS writer.
@@ -117,6 +120,7 @@ export async function applyParsedWave({ parsed: wparsed, entries: wentries, head
       dryRun,
       fuzzy,
       readStateScope,
+      signal: abortSignal,
     });
     if (isPatchErrorText(jsResult)) return { executor, error: jsResult };
     resultParts.push(jsResult);

package/src/runtime/browser-bridge/input-fields.mjs

@@ -404,7 +404,7 @@ export const BROWSER_INPUT_FIELDS = {
     background: {
       type: 'boolean',
       description:
-        'true creates/targets a hidden support page; false reveals it; omitted never promotes a named one. open without true keeps it for user handoff.',
+        'true creates/targets a hidden support page; false reveals it until task end; omitted never promotes a named one. open without true keeps it for user handoff.',
     },
   },
 };

package/src/runtime/browser-bridge/tool-defs.mjs

@@ -22,7 +22,7 @@ import { BROWSER_INPUT_FIELDS } from './input-fields.mjs';
 const BROWSER_DESCRIPTION =
   "Drive Mixdog's in-app Chromium directly for rendered, signed-in or interactive pages; public page text uses web_fetch, external windows computer. " +
   'Load the browser-use skill before first use. ' +
-  'Background for results; open retains a handoff, background:false reveals temporarily. Respect user-closed panels. ' +
+  'Background by default; reveal only via open for a deliverable or handoff. Respect user-closed panels. ' +
   'Task end cleans owned pages/restores temporary panels; user pages persist. ' +
   'hide folds the panel; close_tab closes named background pages only. ' +
   'Pages are session-local; sign-in/storage shared; never provide session_id. ' +

package/src/runtime/computer-bridge/actions.mjs

@@ -72,19 +72,6 @@ for (const name of [
       'key',
     ].includes(name),
     focusGuard: ['invoke', 'set_value', 'toggle'].includes(name),
-    focusContinuation: [
-      'invoke',
-      'click',
-      'double_click',
-      'right_click',
-      'middle_click',
-      'triple_click',
-      'mouse_down',
-      'mouse_up',
-      'mouse_move',
-      'drag',
-      'scroll',
-    ].includes(name),
     policy: 'act',
   });
 }

package/src/runtime/media/adapters/antigravity-image.mjs

@@ -11,6 +11,7 @@ import { randomUUID } from 'node:crypto';
 import { resolveAntigravityAuth } from '../auth.mjs';
 import { timeoutSignal } from '../bounded-signal.mjs';
 import { upstreamError } from '../upstream-error.mjs';
+import { geminiUsage } from '../media-usage.mjs';
 import { geminiImageRequestBody, pickGeminiImagePart } from './gemini-image.mjs';
 import { CONTENT_ENDPOINTS, antigravityHeaders } from '../../agent/orchestrator/providers/antigravity-oauth-tokens.mjs';
 import { frameAndParseSse } from '../../agent/orchestrator/providers/lib/sse-framing.mjs';
@@ -35,6 +36,7 @@ function antigravityImageRequestBody({ projectId, model, prompt, options = {}, r
 export function antigravityImageParts(sseText) {
   const parts = [];
   let failure = null;
+  let usageMetadata = null;
   for (const event of frameAndParseSse(sseText).events) {
     if (event.error) continue;
     const value = event.value;
@@ -43,10 +45,12 @@ export function antigravityImageParts(sseText) {
     const chunk = value?.response && typeof value.response === 'object' ? value.response : value;
     const candidate = chunk?.candidates?.[0];
     parts.push(...(candidate?.content?.parts || []));
+    // usageMetadata is cumulative; the last chunk that carries it is the total.
+    if (chunk?.usageMetadata) usageMetadata = chunk.usageMetadata;
     const blocked = chunk?.promptFeedback?.blockReason;
     if (blocked && !failure) failure = `prompt blocked (${blocked})`;
   }
-  return { parts, failure };
+  return { parts, failure, usage: geminiUsage(usageMetadata) };
 }
 
 export async function generateImage(
@@ -68,6 +72,6 @@ export async function generateImage(
     signal: timeoutSignal(signal, REQUEST_TIMEOUT_MS),
   });
   if (!res.ok) throw upstreamError('Antigravity image', res.status, await res.text().catch(() => ''));
-  const { parts, failure } = antigravityImageParts(await res.text());
-  return pickGeminiImagePart(parts, 'Antigravity', failure);
+  const { parts, failure, usage } = antigravityImageParts(await res.text());
+  return pickGeminiImagePart(parts, 'Antigravity', failure, usage);
 }

package/src/runtime/media/adapters/codex-image.mjs

@@ -12,6 +12,7 @@ import { timeoutSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
+import { responsesUsage, withReportedUsage } from '../media-usage.mjs';
 import { CODEX_OAUTH_ORIGINATOR, CODEX_RESPONSES_URL } from '../../agent/orchestrator/providers/openai-oauth.mjs';
 import {
   codexUserAgent,
@@ -32,6 +33,12 @@ function imageTool(options = {}) {
 
 function collectImage(event, state) {
   const item = event?.item;
+  // Terminal Responses events carry the orchestrator's token usage. It does
+  // not include the hosted image tool's own tokens.
+  if (['response.completed', 'response.failed', 'response.incomplete'].includes(event?.type)) {
+    state.usage = responsesUsage(event?.response?.usage) || state.usage;
+    return;
+  }
   if (event?.type === 'response.output_item.done' && item?.type === 'image_generation_call') {
     if (typeof item.result === 'string' && item.result.length > 0) state.final = item.result;
     if (typeof item.model === 'string') state.actualModel = item.model;
@@ -142,12 +149,16 @@ export async function generateImage(
 
   const b64 = state.final || state.partial;
   if (!b64) {
-    throw mediaError(`ChatGPT returned no image data${failure ? `: ${failure}` : ''}`, 'MEDIA_EMPTY_RESULT', 502);
+    throw withReportedUsage(
+      mediaError(`ChatGPT returned no image data${failure ? `: ${failure}` : ''}`, 'MEDIA_EMPTY_RESULT', 502),
+      state.usage
+    );
   }
   return {
     bytes: decodeBase64Media(b64, 'ChatGPT image'),
     mime: 'image/png',
     revisedPrompt: state.revisedPrompt,
     actualModel: state.actualModel || null,
+    usage: state.usage || null,
   };
 }

package/src/runtime/media/adapters/gemini-image.mjs

@@ -11,6 +11,7 @@ import { timeoutSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
+import { geminiUsage, withReportedUsage } from '../media-usage.mjs';
 
 const BASE_URL = 'https://generativelanguage.googleapis.com/v1beta/models';
 const REQUEST_TIMEOUT_MS = 180_000;
@@ -51,20 +52,25 @@ async function post(model, key, body, signal, fetchFn) {
  * First inline image among a candidate's parts. A text-only answer is the
  * model's refusal and surfaces as such; it is never retried.
  */
-export function pickGeminiImagePart(parts, label, failure = null) {
+export function pickGeminiImagePart(parts, label, failure = null, usage = null) {
   const image = parts.find((part) => part?.inlineData?.data);
   if (!image) {
     const refusal = failure || parts.find((part) => typeof part?.text === 'string' && part.text.trim())?.text || '';
-    throw mediaError(
-      `${label} returned no image data${refusal ? `: ${String(refusal).slice(0, 200)}` : ''}`,
-      'MEDIA_EMPTY_RESULT',
-      502
+    throw withReportedUsage(
+      mediaError(
+        `${label} returned no image data${refusal ? `: ${String(refusal).slice(0, 200)}` : ''}`,
+        'MEDIA_EMPTY_RESULT',
+        502
+      ),
+      usage
     );
   }
   return {
     bytes: decodeBase64Media(image.inlineData.data, `${label} image`),
     mime: image.inlineData.mimeType || 'image/png',
     revisedPrompt: null,
+    // Without reported tokens the one image is priced per image, if the catalog lists it.
+    usage: usage || { images: 1 },
   };
 }
 
@@ -76,5 +82,10 @@ export async function generateImage(
   const res = await post(model, key, geminiImageRequestBody(prompt, options, references), signal, fetchFn);
   if (!res.ok) throw upstreamError('Gemini image', res.status, await res.text().catch(() => ''));
   const data = await res.json();
-  return pickGeminiImagePart(data?.candidates?.[0]?.content?.parts || [], 'Gemini');
+  return pickGeminiImagePart(
+    data?.candidates?.[0]?.content?.parts || [],
+    'Gemini',
+    null,
+    geminiUsage(data?.usageMetadata)
+  );
 }

package/src/runtime/media/adapters/gemini-video.mjs

@@ -12,7 +12,9 @@ import { boundedSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media, downloadGeminiMedia } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
+import { interactionsUsage, withReportedUsage } from '../media-usage.mjs';
 
+const VEO_DEFAULT_SECONDS = 8;
 const BASE_URL = 'https://generativelanguage.googleapis.com/v1beta';
 const OMNI_TIMEOUT_MS = 600_000;
 const POLL_INTERVAL_MS = 8_000;
@@ -54,14 +56,15 @@ async function generateViaOmni({ model, prompt, options, references = [], signal
   });
   if (!res.ok) throw upstreamError('Gemini Omni video', res.status, await res.text().catch(() => ''));
   const data = await res.json();
+  const usage = interactionsUsage(data?.usage);
   for (const step of data?.steps || []) {
     const content = Array.isArray(step?.content) ? step.content : [step?.content].filter(Boolean);
     const video = content.find((item) => item?.type === 'video' && typeof item?.data === 'string');
     if (video) {
-      return { bytes: decodeBase64Media(video.data, 'Gemini Omni video'), mime: video.mime_type || 'video/mp4' };
+      return { bytes: decodeBase64Media(video.data, 'Gemini Omni video'), mime: video.mime_type || 'video/mp4', usage };
     }
   }
-  throw mediaError('Gemini Omni returned no video data', 'MEDIA_EMPTY_RESULT', 502);
+  throw withReportedUsage(mediaError('Gemini Omni returned no video data', 'MEDIA_EMPTY_RESULT', 502), usage);
 }
 
 async function generateViaVeo({ model, prompt, options, references = [], signal, onProgress, key }) {
@@ -114,13 +117,20 @@ async function generateViaVeo({ model, prompt, options, references = [], signal,
     const sample = data?.response?.generateVideoResponse?.generatedSamples?.[0] || data?.response?.generatedVideos?.[0];
     const uri = sample?.video?.uri || sample?.video?.fileUri;
     if (!uri) throw mediaError('Veo finished without a video URI', 'MEDIA_EMPTY_RESULT', 502);
-    return {
-      // The download is part of the generation budget: unbounded, it held an
-      // active job slot (and the upstream connection) open indefinitely after
-      // the poll loop finished.
-      bytes: await downloadGeminiMedia(uri, { key, signal: boundedSignal(signal, deadline, TOTAL_TIMEOUT_MS) }),
-      mime: 'video/mp4',
-    };
+    // Veo reports no usage; it bills per generated second. The response does
+    // not echo the length, so the requested one (default 8s) is the billed one.
+    // A failed download still leaves the generated seconds billed.
+    const usage = { seconds: parameters.durationSeconds || VEO_DEFAULT_SECONDS, resolution: parameters.resolution || '720p' };
+    // The download is part of the generation budget: unbounded, it held an
+    // active job slot (and the upstream connection) open indefinitely after
+    // the poll loop finished.
+    const bytes = await downloadGeminiMedia(uri, {
+      key,
+      signal: boundedSignal(signal, deadline, TOTAL_TIMEOUT_MS),
+    }).catch((error) => {
+      throw withReportedUsage(error, usage);
+    });
+    return { bytes, mime: 'video/mp4', usage };
   }
 }
 

package/src/runtime/media/adapters/xai-media.mjs

@@ -10,6 +10,7 @@ import { boundedSignal, timeoutSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media, downloadPublicMedia } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
+import { withReportedUsage, xaiUsage } from '../media-usage.mjs';
 
 const POLL_INTERVAL_MS = 4_000;
 const START_TIMEOUT_MS = 60_000;
@@ -72,6 +73,7 @@ export async function generateImage({ lane, model, prompt, options = {}, referen
     bytes: decodeBase64Media(entry.b64_json, 'xAI image'),
     mime: entry.mime_type || 'image/png',
     revisedPrompt: entry.revised_prompt || null,
+    usage: xaiUsage(data?.usage),
   };
 }
 
@@ -114,18 +116,29 @@ export async function generateVideo({ lane, model, prompt, options = {}, referen
     if (typeof data?.progress === 'number' && typeof onProgress === 'function') onProgress(data.progress);
     if (data?.status === 'done') {
       const url = data?.video?.url;
-      if (!url) throw mediaError('xAI video finished without a URL', 'MEDIA_EMPTY_RESULT', 502);
+      // The billed cost (when reported) is the price; seconds + resolution
+      // let the catalog's per-second rate price it otherwise.
+      const seconds = Number(data?.video?.duration) || duration;
+      const usage = { ...xaiUsage(data?.usage), seconds, resolution };
+      if (!url) throw withReportedUsage(mediaError('xAI video finished without a URL', 'MEDIA_EMPTY_RESULT', 502), usage);
+      const bytes = await downloadPublicMedia(url, { signal, label: 'xAI video' }).catch((error) => {
+        throw withReportedUsage(error, usage);
+      });
       return {
-        bytes: await downloadPublicMedia(url, { signal, label: 'xAI video' }),
+        bytes,
         mime: 'video/mp4',
-        durationSeconds: Number(data?.video?.duration) || duration,
+        durationSeconds: seconds,
+        usage,
       };
     }
     if (data?.status === 'failed' || data?.status === 'expired') {
-      throw mediaError(
-        `xAI video ${data.status}${data?.error?.code ? `: ${data.error.code}` : ''}`,
-        'MEDIA_UPSTREAM_FAILED',
-        502
+      throw withReportedUsage(
+        mediaError(
+          `xAI video ${data.status}${data?.error?.code ? `: ${data.error.code}` : ''}`,
+          'MEDIA_UPSTREAM_FAILED',
+          502
+        ),
+        xaiUsage(data?.usage)
       );
     }
   }