mixdog 1.0.1 → 1.0.3

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)
       );
     }
   }

package/src/runtime/media/jobs.mjs

@@ -11,6 +11,7 @@ import { MAX_GENERATED_MEDIA_BYTES } from './download.mjs';
 import { mediaError, resolveMediaRequest } from './lanes.mjs';
 import { saveMediaAsset } from './store.mjs';
 import { setMediaDefault } from './defaults.mjs';
+import { recordMediaUsage } from './media-usage.mjs';
 
 const JOBS = new Map();
 // Finished jobs stay readable for a while so a slow poller still sees the
@@ -77,7 +78,16 @@ async function runAdapter({ lane, kind, model, requestModel, prompt, options, re
  * Validate + start one generation. Returns the initial snapshot immediately;
  * the caller polls getMediaJob for progress and the finished asset id.
  */
-export async function startMediaJob({ lane: laneId, kind, model, prompt, options = {}, references = [] } = {}) {
+export async function startMediaJob({
+  lane: laneId,
+  kind,
+  model,
+  prompt,
+  options = {},
+  references = [],
+  sessionId = '',
+  sourceType = '',
+} = {}) {
   const text = String(prompt || '').trim();
   if (!text) throw mediaError('prompt is required', 'MEDIA_PROMPT_REQUIRED');
   if (text.length > MAX_PROMPT_CHARS) throw mediaError('prompt is too long', 'MEDIA_PROMPT_TOO_LONG');
@@ -128,13 +138,31 @@ export async function startMediaJob({ lane: laneId, kind, model, prompt, options
     controller,
   };
   JOBS.set(job.id, job);
-  void runJob(job, resolved, { requestModel: modelEntry?.requestModel, options, references: refs });
+  void runJob(job, resolved, {
+    requestModel: modelEntry?.requestModel,
+    options,
+    references: refs,
+    sessionId,
+    sourceType,
+  });
   return snapshot(job);
 }
 
 /** Drive one started job to a terminal state; never rejects. */
-async function runJob(job, resolved, { requestModel, options, references }) {
+async function runJob(job, resolved, { requestModel, options, references, sessionId, sourceType }) {
   const { controller } = job;
+  // One ledger row per generation. The ChatGPT lane bills the orchestrator
+  // model that ran the hosted tool, not the "auto" image route.
+  const record = (usage) =>
+    recordMediaUsage({
+      lane: job.lane,
+      model: job.model,
+      pricingModel: job.lane === 'openai-oauth' ? requestModel : undefined,
+      usage,
+      sessionId,
+      sourceType,
+      durationMs: Date.now() - job.startedAt,
+    });
   try {
     const result = await runAdapter({
       lane: resolved.lane,
@@ -154,6 +182,8 @@ async function runJob(job, resolved, { requestModel, options, references }) {
         if (next > job.progress) job.progress = next;
       },
     });
+    // Billed once the provider returned a result, whatever happens to the bytes next.
+    await record(result?.usage);
     if (!Buffer.isBuffer(result?.bytes) || !result.bytes.length || result.bytes.length > MAX_GENERATED_MEDIA_BYTES) {
       throw mediaError('generated media exceeds the media size limit', 'MEDIA_RESULT_TOO_LARGE', 502);
     }
@@ -175,6 +205,8 @@ async function runJob(job, resolved, { requestModel, options, references }) {
     job.status = 'done';
   } catch (err) {
     const canceled = controller.signal.aborted || err?.code === 'MEDIA_CANCELED' || err?.name === 'AbortError';
+    // A failure is recorded only when the provider reported usage for it.
+    if (err?.usage) await record(err.usage);
     job.status = canceled ? 'canceled' : 'failed';
     job.error = canceled ? 'canceled' : String(err?.message || err).slice(0, 500);
     job.errorCode = err?.code || null;

package/src/runtime/media/media-usage.mjs

@@ -0,0 +1,126 @@
+/**
+ * Usage ledger rows for media generations.
+ *
+ * Adapters return (or attach to their error) a normalized `usage` object read
+ * from what the upstream response actually reported:
+ *   { inputTokens, outputTokens, cachedTokens, outputImageTokens, outputVideoTokens,
+ *     costUsd, images, seconds, resolution }
+ * `jobs.mjs` records exactly one row per generation through recordMediaUsage.
+ * Nothing here estimates tokens: a field the provider did not report stays absent.
+ */
+import { getUsageLedger, makeUsageRecord } from '../shared/llm/usage-ledger.mjs';
+import { ACCOUNT_PROVIDERS } from '../shared/provider-accounts.mjs';
+import { currentProviderAccountId } from '../shared/provider-auth-binding.mjs';
+
+const count = (value) => (Number.isFinite(Number(value)) && Number(value) > 0 ? Math.trunc(Number(value)) : 0);
+const pick = (source, ...keys) => {
+  for (const key of keys) if (source?.[key] != null) return source[key];
+  return undefined;
+};
+
+const TICKS_PER_USD = 1e10;
+
+/** Token usage when the provider reported any; null otherwise. */
+function tokenUsage(fields) {
+  const usage = Object.fromEntries(Object.entries(fields).filter(([, value]) => value > 0));
+  return Object.keys(usage).length ? usage : null;
+}
+
+/** Gemini `generateContent` / Antigravity `usageMetadata` (camelCase or snake_case). */
+export function geminiUsage(meta) {
+  if (!meta || typeof meta !== 'object') return null;
+  const details = pick(meta, 'candidatesTokensDetails', 'candidates_tokens_details');
+  const imageTokens = (Array.isArray(details) ? details : [])
+    .filter((entry) => String(entry?.modality || '').toUpperCase() === 'IMAGE')
+    .reduce((sum, entry) => sum + count(pick(entry, 'tokenCount', 'token_count')), 0);
+  return tokenUsage({
+    inputTokens: count(pick(meta, 'promptTokenCount', 'prompt_token_count')),
+    cachedTokens: count(pick(meta, 'cachedContentTokenCount', 'cached_content_token_count')),
+    outputTokens:
+      count(pick(meta, 'candidatesTokenCount', 'candidates_token_count')) +
+      count(pick(meta, 'thoughtsTokenCount', 'thoughts_token_count')),
+    outputImageTokens: imageTokens,
+  });
+}
+
+/** Gemini Interactions API `usage` (omni video). */
+export function interactionsUsage(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  const videoTokens = (Array.isArray(usage.output_tokens_by_modality) ? usage.output_tokens_by_modality : [])
+    .filter((entry) => String(entry?.modality || '').toLowerCase() === 'video')
+    .reduce((sum, entry) => sum + count(entry?.tokens), 0);
+  return tokenUsage({
+    inputTokens: count(usage.total_input_tokens),
+    cachedTokens: count(usage.total_cached_tokens),
+    outputTokens: count(usage.total_output_tokens) + count(usage.total_thought_tokens),
+    outputVideoTokens: videoTokens,
+  });
+}
+
+/** OpenAI / Codex Responses `usage` from response.completed. */
+export function responsesUsage(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  return tokenUsage({
+    inputTokens: count(usage.input_tokens),
+    cachedTokens: count(usage.input_tokens_details?.cached_tokens),
+    outputTokens: count(usage.output_tokens),
+  });
+}
+
+/** xAI image/video `usage.cost_in_usd_ticks` (1 USD = 1e10 ticks); the billed cost. */
+export function xaiUsage(usage) {
+  const ticks = usage?.cost_in_usd_ticks;
+  return typeof ticks === 'number' && Number.isFinite(ticks) && ticks >= 0 ? { costUsd: ticks / TICKS_PER_USD } : null;
+}
+
+/** True when the provider reported something billable for the request. */
+export function hasReportedUsage(usage) {
+  if (!usage) return false;
+  // Seconds are only attached once a video generation completed (billed per second).
+  return (
+    typeof usage.costUsd === 'number' ||
+    ['inputTokens', 'outputTokens', 'cachedTokens', 'seconds'].some((k) => usage[k] > 0)
+  );
+}
+
+/** Attach provider-reported usage to a failure so jobs.mjs can still record it. */
+export function withReportedUsage(error, usage) {
+  if (hasReportedUsage(usage)) error.usage = usage;
+  return error;
+}
+
+/**
+ * Append one ledger row for a generation. A ledger failure never fails the
+ * generation; it is logged the way usage-accounting does.
+ */
+export async function recordMediaUsage(args, getLedger = getUsageLedger) {
+  try {
+    const usage = args.usage || {};
+    const row = makeUsageRecord({
+      ts: Date.now(),
+      provider: args.lane,
+      model: args.model,
+      requestedModel: args.model,
+      pricingModel: args.pricingModel,
+      sessionId: args.sessionId,
+      sourceType: args.sourceType,
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+      cacheReadTokens: usage.cachedTokens,
+      costUsd: usage.costUsd,
+      media: {
+        reportedCostUsd: usage.costUsd,
+        outputImageTokens: usage.outputImageTokens,
+        outputVideoTokens: usage.outputVideoTokens,
+        images: usage.images,
+        seconds: usage.seconds,
+        resolution: usage.resolution,
+      },
+      account: ACCOUNT_PROVIDERS.includes(args.lane) ? currentProviderAccountId(args.lane) : '',
+      durationMs: args.durationMs,
+    });
+    await getLedger()?.recordQueued(row);
+  } catch (error) {
+    process.stderr.write(`[usage-ledger] RECORD NOT SAVED: ${String(error?.message || error)}\n`);
+  }
+}

package/src/runtime/media/tool.mjs

@@ -280,7 +280,7 @@ function jobView(job) {
   };
 }
 
-async function generate(args, { cwd, signal, deps }) {
+async function generate(args, { cwd, signal, deps, sessionId, sourceType }) {
   const kind = clean(args.kind);
   if (!MEDIA_KINDS.includes(kind)) throw new MediaToolError(`generate requires kind: ${MEDIA_KINDS.join(' | ')}`);
   const prompt = clean(args.prompt);
@@ -314,7 +314,16 @@ async function generate(args, { cwd, signal, deps }) {
     quality: clean(args.quality),
   });
   const references = await readReferences(args.references, cwd, model.controls);
-  const started = await jobs.startMediaJob({ lane: lane.id, kind, model: modelId, prompt, options, references });
+  const started = await jobs.startMediaJob({
+    lane: lane.id,
+    kind,
+    model: modelId,
+    prompt,
+    options,
+    references,
+    sessionId,
+    sourceType,
+  });
   const base = { lane: lane.id, model: modelId, laneSource, options, referenceCount: references.length, prompt };
   if (args.wait === false) {
     return {
@@ -371,7 +380,10 @@ async function cancel(args, { deps }) {
   return { ok: true, ...jobView(jobs.getMediaJob(id)), canceled: canceled === true };
 }
 
-export async function executeMediaTool(args = {}, { cwd = process.cwd(), signal = null, deps = null } = {}) {
+export async function executeMediaTool(
+  args = {},
+  { cwd = process.cwd(), signal = null, deps = null, sessionId = '', sourceType = '' } = {}
+) {
   const action = clean(args.action).toLowerCase();
   try {
     if (!MEDIA_ACTIONS.includes(action))
@@ -388,7 +400,7 @@ export async function executeMediaTool(args = {}, { cwd = process.cwd(), signal
         ),
       });
     }
-    if (action === 'generate') return mediaToolResult(await generate(args, { cwd, signal, deps }));
+    if (action === 'generate') return mediaToolResult(await generate(args, { cwd, signal, deps, sessionId, sourceType }));
     if (action === 'status') return mediaToolResult(await status(args, { cwd, deps }));
     return mediaToolResult(await cancel(args, { deps }));
   } catch (error) {

package/src/runtime/shared/llm/cost.mjs

@@ -39,6 +39,35 @@ export function billableInputTokensForProvider(provider, inputTokens, cacheReadT
   return Math.max(input - (Number(cacheReadTokens) || 0) - (Number(cacheWriteTokens) || 0), 0);
 }
 
+/**
+ * Media billed by something other than the text token slots: image/video output
+ * tokens, whole images, or video seconds (per resolution when the catalog lists
+ * one). A used unit without a catalog rate is reported missing, never free.
+ */
+function mediaCharges(meta, media, imageOut, videoOut) {
+  const n = (value) => (Number.isFinite(Number(value)) && Number(value) > 0 ? Number(value) : 0);
+  const out = { usd: 0, charged: false, missing: [], rates: {} };
+  const bill = (amount, key, rate, scale = 1) => {
+    if (amount <= 0) return;
+    out.charged = true;
+    if (rate == null) out.missing.push(key);
+    else {
+      out.usd += (amount * rate) / scale;
+      out.rates[key] = rate;
+    }
+  };
+  bill(imageOut, 'outputImageCostPerM', meta.outputImageCostPerM, 1_000_000);
+  bill(videoOut, 'outputVideoCostPerM', meta.outputVideoCostPerM, 1_000_000);
+  bill(n(media.images), 'outputCostPerImage', meta.outputCostPerImage);
+  const resolution = String(media.resolution || '').toLowerCase();
+  bill(
+    n(media.seconds),
+    'outputCostPerSecond',
+    meta.outputCostPerSecondByResolution?.[resolution] ?? meta.outputCostPerSecond
+  );
+  return out;
+}
+
 /**
  * Price normalized token slots once. Null means unknown, not a free request.
  * Rates are returned so a durable record keeps the price applied at ingestion.
@@ -68,6 +97,15 @@ export function priceUsage(args) {
     ...(args.serviceTier ? { serviceTier: args.serviceTier } : {}),
     ...(written1h ? { cacheWrite1hTokens: written1h } : {}),
   };
+  // A provider-billed figure for a media request (e.g. xAI cost_in_usd_ticks)
+  // is the price, with or without a catalog row.
+  const media = args.media || null;
+  if (typeof media?.reportedCostUsd === 'number' && Number.isFinite(media.reportedCostUsd) && media.reportedCostUsd >= 0)
+    return {
+      input,
+      costUsd: Number(media.reportedCostUsd.toFixed(6)),
+      rates: { ...provenance, pricingSource: 'provider' },
+    };
   if (args.inputTokensKnown === false || !meta)
     return {
       input,
@@ -107,7 +145,11 @@ export function priceUsage(args) {
   // Fast mode bills 2x standard rates on every fast-capable Opus.
   if (anthropicFast) multiplier *= 2;
   const keys = PRICING_RATE_KEYS;
-  const tokens = [input, n(args.outputTokens), cached, written - written1h];
+  // Image/video output tokens bill above the text output rate; the row still
+  // carries the full output count.
+  const imageOut = media ? Math.min(n(media.outputImageTokens), n(args.outputTokens)) : 0;
+  const videoOut = media ? Math.min(n(media.outputVideoTokens), n(args.outputTokens) - imageOut) : 0;
+  const tokens = [input, n(args.outputTokens) - imageOut - videoOut, cached, written - written1h];
   const tierRates = ratesForPrompt(rateMeta, promptTokens);
   const rates = {
     ...provenance,
@@ -116,6 +158,10 @@ export function priceUsage(args) {
   if (written1h) rates.cacheWrite1hCostPerM = rates.inputCostPerM === null ? null : rates.inputCostPerM * 2;
   const missingRates = keys.filter((key, i) => tokens[i] > 0 && rates[key] === null);
   if (written1h && rates.cacheWrite1hCostPerM === null) missingRates.push('cacheWrite1hCostPerM');
+  const charge = media ? mediaCharges(meta, media, imageOut, videoOut) : { usd: 0, charged: false, missing: [] };
+  missingRates.push(...charge.missing);
+  if (media && !charge.charged && tokens.every((amount) => amount === 0) && !written1h)
+    return { input, costUsd: null, rates: { ...rates, unpricedReason: 'usage-not-reported' } };
   if (missingRates.length) {
     rates.unpricedReason = 'missing-rate';
     rates.missingRates = missingRates;
@@ -124,8 +170,9 @@ export function priceUsage(args) {
   const costUsd =
     (tokens.reduce((sum, amount, i) => sum + amount * (rates[keys[i]] ?? 0), 0) +
       written1h * (rates.cacheWrite1hCostPerM ?? 0)) /
-    1_000_000;
-  return { input, costUsd: Number(costUsd.toFixed(6)), rates };
+      1_000_000 +
+    charge.usd;
+  return { input, costUsd: Number(costUsd.toFixed(6)), rates: { ...rates, ...charge.rates } };
 }
 
 /**

package/src/runtime/shared/llm/model-catalog-projection.mjs

@@ -124,6 +124,10 @@ const LITELLM_NUMBER_FIELDS = [
   'output_cost_per_token',
   'cache_read_input_token_cost',
   'cache_creation_input_token_cost',
+  'output_cost_per_image',
+  'output_cost_per_image_token',
+  'output_cost_per_video_token',
+  'output_cost_per_second',
 ];
 // _normalize tests each of these with `=== true`, so only a true value carries
 // information; anything else is indistinguishable from absent.
@@ -148,9 +152,10 @@ function projectLitellmRow(row) {
   // litellmPricing), not just the base price.
   for (const [field, value] of Object.entries(row)) {
     if (
-      /^(?:input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)(?:_above_\d+k_tokens)?(?:_priority)?$/.test(
+      (/^(?:input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)(?:_above_\d+k_tokens)?(?:_priority)?$/.test(
         field
-      ) &&
+      ) ||
+        /^output_cost_per_second_\w+$/.test(field)) &&
       typeof value === 'number' &&
       Number.isFinite(value)
     )

package/src/runtime/shared/llm/model-catalog.mjs

@@ -26,7 +26,7 @@ import {
   cachedProviderModelListsSync,
   providerCachedModelsSync,
 } from './provider-catalog-cache.mjs';
-import { litellmPricing, modelsDevPricing, PRICING_RATE_KEYS } from './model-pricing-rates.mjs';
+import { litellmMediaPricing, litellmPricing, modelsDevPricing, PRICING_RATE_KEYS } from './model-pricing-rates.mjs';
 // Both overlays are narrowed to their read surface before becoming resident;
 // the disk caches below still receive the full payload.
 import { projectLitellmCatalog, projectModelsDevCatalog } from './model-catalog-projection.mjs';
@@ -597,6 +597,7 @@ function _normalize(entry) {
     contextWindow: entry.max_input_tokens || entry.max_tokens || null,
     outputTokens: entry.max_output_tokens || null,
     ...litellmPricing(entry),
+    ...litellmMediaPricing(entry),
     ...(PRICING_RATE_KEYS.some((key) => fastPricing[key] != null) ? { fastPricing } : {}),
     ...(entry.off_peak_multiplier ? { offPeakMultiplier: entry.off_peak_multiplier } : {}),
     supportsVision: entry.supports_vision === true,

package/src/runtime/shared/llm/model-pricing-rates.mjs

@@ -51,6 +51,27 @@ export function litellmPricing(entry, suffix = '') {
   };
 }
 
+/**
+ * Non-token media rates published by LiteLLM: USD per generated image, USD per
+ * generated video second (optionally per resolution, `output_cost_per_second_<res>`),
+ * and USD/M for image / video output tokens, which bill above the text output rate.
+ */
+export function litellmMediaPricing(entry) {
+  const perM = (value) => (validRate(value) ? value * 1_000_000 : null);
+  const byResolution = {};
+  for (const [key, value] of Object.entries(entry || {})) {
+    const match = key.match(/^output_cost_per_second_(.+)$/);
+    if (match && validRate(value)) byResolution[match[1].toLowerCase()] = value;
+  }
+  return {
+    outputImageCostPerM: perM(entry?.output_cost_per_image_token),
+    outputVideoCostPerM: perM(entry?.output_cost_per_video_token),
+    outputCostPerImage: validRate(entry?.output_cost_per_image) ? entry.output_cost_per_image : null,
+    outputCostPerSecond: validRate(entry?.output_cost_per_second) ? entry.output_cost_per_second : null,
+    outputCostPerSecondByResolution: byResolution,
+  };
+}
+
 export function modelsDevPricing(cost) {
   // Structured tiers supersede the older context_over_200k compatibility
   // field; it can coexist with a tier whose actual boundary is not 200k.

package/src/runtime/shared/llm/usage-accounting.mjs

@@ -4,6 +4,13 @@ import { withUsageContext } from './usage-context.mjs';
 import { ACCOUNT_PROVIDERS } from '../provider-accounts.mjs';
 import { currentProviderAccountId } from '../provider-auth-binding.mjs';
 
+// Results and errors already written. A provider-local re-send (model
+// fallback, catalog retry) runs its own accounting and its result or error
+// then returns through the enclosing send, which must not write it again.
+const recorded = new WeakSet();
+const hasTokens = (usage) =>
+  ['inputTokens', 'outputTokens', 'cachedTokens', 'cacheWriteTokens'].some((key) => Number(usage?.[key]) > 0);
+
 /**
  * Runs at the common provider boundary, not inside optional diagnostic IO.
  * Provider-local retries remain owned by the provider. Accounting failure must
@@ -12,7 +19,9 @@ import { currentProviderAccountId } from '../provider-auth-binding.mjs';
 export async function accountProviderSend(provider, instance, send, model, opts = {}) {
   const requestId = randomUUID();
   const startedAt = Date.now();
-  const sessionId = opts.sessionId || opts.session?.id;
+  // usageSessionId: a request isolated under its own provider session id
+  // (compaction's `:compact`) whose spend belongs to the source session.
+  const sessionId = opts.usageSessionId || opts.sessionId || opts.session?.id;
   const sourceType = opts.session?.sourceType || opts.sourceType || opts.requestKind || '';
   const inputTokensInclusive = instance.constructor?.inputExcludesCache !== true;
   let ledger;
@@ -30,16 +39,18 @@ export async function accountProviderSend(provider, instance, send, model, opts
     sourceType,
     inputTokensInclusive,
   };
-  const record = async (result) => {
+  const record = async (result, id, owner) => {
     if (!result?.usage) return;
     // A nested send (e.g. a fallback model re-send) already stamped its own
     // final attempt's tier; the outer context only saw the abandoned attempt.
     result.requestServiceTier ??= identity.requestServiceTier || '';
+    if (recorded.has(owner)) return;
     if (openingError) throw openingError;
     if (!ledger) return;
+    recorded.add(owner);
     const usage = result.usage;
     const row = makeUsageRecord({
-      id: result.responseId ? undefined : requestId,
+      id: result.responseId ? undefined : id,
       ts: Date.now(),
       provider,
       model: result.model || model,
@@ -68,23 +79,32 @@ export async function accountProviderSend(provider, instance, send, model, opts
     // SQLite write no longer runs on the event loop.
     await ledger.recordQueued(row);
   };
-  const save = async (result) => {
+  const save = async (result, id = requestId, owner = result) => {
     try {
-      await record(result);
+      await record(result, id, owner);
     } catch (error) {
       result.usageAccountingError = String(error?.message || error);
       process.stderr.write(`[usage-ledger] RECORD NOT SAVED: ${result.usageAccountingError}\n`);
     }
   };
+  const saveAbandoned = async () => {
+    for (const [index, attempt] of (identity.abandonedUsage || []).entries()) {
+      if (hasTokens(attempt.usage)) await save(attempt, `${requestId}:abandoned:${index}`);
+    }
+  };
   let result;
   try {
     result = await withUsageContext(identity, send);
   } catch (error) {
+    await saveAbandoned();
     // Only provider-reported partial usage is recordable; never invent
     // tokens for a failed request or reinterpret an error as a success.
     if (error?.usage) await save(error);
+    else if (hasTokens(error?.partialUsage))
+      await save({ usage: error.partialUsage, model: error.partialModel }, requestId, error);
     throw error;
   }
+  await saveAbandoned();
   await save(result);
   return result;
 }

package/src/runtime/shared/llm/usage-context.mjs

@@ -11,3 +11,9 @@ export const noteRequestServiceTier = (tier) => {
   const identity = context.getStore();
   if (identity) identity.requestServiceTier = tier || '';
 };
+// A provider-local retry abandons an attempt the provider still billed; the
+// enclosing send records it alongside its own final usage.
+export const noteAbandonedUsage = (usage, model) => {
+  const identity = context.getStore();
+  if (identity && usage) (identity.abandonedUsage ||= []).push({ usage, model });
+};

package/src/runtime/shared/llm/usage-ledger-import.mjs

@@ -43,6 +43,7 @@ export function importTraceRow(row) {
     uncachedInputTokens: raw ? (row.uncached_input_tokens ?? payload.uncached_input_tokens) : undefined,
     cacheReadTokens: raw ? row.cached_tokens : row.cacheReadTokens,
     cacheWriteTokens: raw ? row.cache_write_tokens : row.cacheWriteTokens,
+    cacheWrite1hTokens: raw ? payload.raw_usage?.cache_creation?.ephemeral_1h_input_tokens : undefined,
     costUsd: raw ? undefined : row.costUsd,
     sessionId: row.session_id || row.sessionId,
     sourceType: row.sourceType || row.source_type || payload.sourceType || payload.source_type,