Fix token + cost accounting in OpenAI usage

- prompt_tokens is now inclusive of cache read/write (OpenAI contract);
  OpenCode derives the non-cached count by subtracting the details
- surface cost_usd from the gateway finish event, with an estimated
  fallback from advertised $/1M rates when the gateway omits it
- parse advertised $/1M rates from models.md and set provider model.cost
  (was zeroCost), so OpenCode computes real message costs
- forward usage before parking tool-call turns instead of emitting
  prompt_tokens:0 that overwrote OpenCode's session meter
- drop empty usage chunks (zero prompt+completion) instead of emitting them

Author: makeittech

src/gateway-types.ts

@@ -54,6 +54,9 @@ export type WireUsage = {
   outputTokens: number;
   cacheReadTokens: number;
   cacheWriteTokens: number;
+  reasoningTokens?: number;
+  /** Estimated USD from the gateway finish event, when provided. */
+  costUsd?: number;
 };
 
 export type GenerateBody = {
@@ -124,11 +127,23 @@ export type StreamEvent =
       totalUsage?: {
         inputTokens?: number;
         outputTokens?: number;
+        reasoningTokens?: number;
+        cachedInputTokens?: number;
+        costUSD?: number;
+        costUsd?: number;
+        cost_usd?: number;
+        total_cost_usd?: number;
+        totalCostUSD?: number;
+        cost?: number;
         inputTokenDetails?: {
           cacheReadTokens?: number;
           cacheWriteTokens?: number;
         };
       };
+      costUSD?: number;
+      costUsd?: number;
+      cost_usd?: number;
+      total_cost_usd?: number;
       systemPromptTokens?: number;
     }
   | { type: "error"; error?: unknown }
@@ -144,11 +159,69 @@ export function emptyUsage(): WireUsage {
   };
 }
 
+function asFiniteNumber(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function costFromUnknown(...candidates: unknown[]): number {
+  for (const candidate of candidates) {
+    if (!candidate || typeof candidate !== "object") continue;
+    const o = candidate as Record<string, unknown>;
+    const cost =
+      asFiniteNumber(o.costUSD) ||
+      asFiniteNumber(o.costUsd) ||
+      asFiniteNumber(o.cost_usd) ||
+      asFiniteNumber(o.total_cost_usd) ||
+      asFiniteNumber(o.totalCostUSD) ||
+      asFiniteNumber(o.cost);
+    if (cost > 0) return cost;
+  }
+  return 0;
+}
+
+/** Map a gateway `finish` event's usage/cost fields onto WireUsage. */
+export function usageFromFinishEvent(event: {
+  totalUsage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    reasoningTokens?: number;
+    cachedInputTokens?: number;
+    inputTokenDetails?: {
+      cacheReadTokens?: number;
+      cacheWriteTokens?: number;
+    };
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}): WireUsage {
+  const usage = emptyUsage();
+  const total = event.totalUsage;
+  if (total) {
+    usage.inputTokens = asFiniteNumber(total.inputTokens);
+    usage.outputTokens = asFiniteNumber(total.outputTokens);
+    usage.cacheReadTokens =
+      asFiniteNumber(total.inputTokenDetails?.cacheReadTokens) ||
+      asFiniteNumber(total.cachedInputTokens);
+    usage.cacheWriteTokens = asFiniteNumber(
+      total.inputTokenDetails?.cacheWriteTokens,
+    );
+    const reasoning = asFiniteNumber(total.reasoningTokens);
+    if (reasoning > 0) usage.reasoningTokens = reasoning;
+  }
+  const cost = costFromUnknown(total, event);
+  if (cost > 0) usage.costUsd = cost;
+  return usage;
+}
+
 export function addUsage(a: WireUsage, b: WireUsage): WireUsage {
+  const reasoningTokens = (a.reasoningTokens ?? 0) + (b.reasoningTokens ?? 0);
+  const costUsd = (a.costUsd ?? 0) + (b.costUsd ?? 0);
   return {
     inputTokens: a.inputTokens + b.inputTokens,
     outputTokens: a.outputTokens + b.outputTokens,
     cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
     cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens,
+    ...(reasoningTokens > 0 ? { reasoningTokens } : {}),
+    ...(costUsd > 0 ? { costUsd } : {}),
   };
 }

src/gateway.ts

@@ -7,7 +7,7 @@ import { basename } from "node:path";
 import { spawnSync } from "node:child_process";
 import {
   GENERATE_ROUTE,
-  emptyUsage,
+  usageFromFinishEvent,
   getApiBaseUrl,
   type GenerateBody,
   type StreamEvent,
@@ -340,25 +340,7 @@ export function mapStreamEvent(event: StreamEvent): GatewayMappedEvent {
       };
     }
     case "finish": {
-      const usage = emptyUsage();
-      const total = event.totalUsage as
-        | {
-            inputTokens?: number;
-            outputTokens?: number;
-            inputTokenDetails?: {
-              cacheReadTokens?: number;
-              cacheWriteTokens?: number;
-            };
-          }
-        | undefined;
-      if (total) {
-        usage.inputTokens = total.inputTokens ?? 0;
-        usage.outputTokens = total.outputTokens ?? 0;
-        usage.cacheReadTokens =
-          total.inputTokenDetails?.cacheReadTokens ?? 0;
-        usage.cacheWriteTokens =
-          total.inputTokenDetails?.cacheWriteTokens ?? 0;
-      }
+      const usage = usageFromFinishEvent(event);
       const finishReason =
         event.finishReason === "tool-calls"
           ? "tool_calls"

src/index.ts

@@ -120,7 +120,7 @@ function buildProviderModel(
       input: model.vision ? ["text", "image"] : ["text"],
       output: ["text"],
     },
-    cost: zeroCost(),
+    cost: model.cost ?? zeroCost(),
     limit: {
       context: model.contextWindow,
       output: model.maxTokens,
@@ -158,6 +158,7 @@ function buildConfigModelEntry(model: CommandModel): Record<string, unknown> {
       includeUsage: true,
     },
     variants,
+    cost: model.cost ?? zeroCost(),
   };
 }
 

src/model-discover.ts

@@ -11,6 +11,12 @@ import { isCommandEffort, LAGUNA_MODEL_ID } from "./constants.js";
 import { resolveCommandCodeExecutable } from "./executable-path.js";
 import { log } from "./log.js";
 
+export type ModelCostRates = {
+  input: number;
+  output: number;
+  cache: { read: number; write: number };
+};
+
 export type DiscoveredModelMeta = {
   id: string;
   name: string;
@@ -21,8 +27,33 @@ export type DiscoveredModelMeta = {
   free: boolean;
   efforts: CommandEffort[];
   reasoning: boolean;
+  /** Advertised $/1M rates from Command Code models.md, when present. */
+  cost?: ModelCostRates;
 };
 
+/**
+ * Parse advertised `$in/$out · cache $read (write $write)` rates from a
+ * models.md table row. Write is optional and defaults to 0.
+ */
+export function parseAdvertisedCost(line: string): ModelCostRates | undefined {
+  const m = line.match(
+    /\$([0-9]*\.?[0-9]+)\/\$([0-9]*\.?[0-9]+)\s*[·*]\s*cache\s*\$([0-9]*\.?[0-9]+)(?:\s*\(write\s*\$([0-9]*\.?[0-9]+)\))?/i,
+  );
+  if (!m) return undefined;
+  const input = Number(m[1]);
+  const output = Number(m[2]);
+  const read = Number(m[3]);
+  const write = m[4] != null ? Number(m[4]) : 0;
+  if (![input, output, read, write].every((n) => Number.isFinite(n))) {
+    return undefined;
+  }
+  return {
+    input,
+    output,
+    cache: { read, write },
+  };
+}
+
 /**
  * Command Code deliberately models vision support as an exclusion list. Read
  * that list from the installed CLI bundle so our capabilities stay in lockstep
@@ -152,6 +183,7 @@ export function parseModelsMarkdown(md: string): Map<string, DiscoveredModelMeta
     const vision =
       /vision|multimodal|image/i.test(line) ||
       /kimi|minimax|gemini|inkling|step-/i.test(id);
+    const cost = parseAdvertisedCost(line);
     map.set(id, {
       id,
       name,
@@ -161,6 +193,7 @@ export function parseModelsMarkdown(md: string): Map<string, DiscoveredModelMeta
       free,
       efforts,
       reasoning: efforts.length > 0,
+      ...(cost ? { cost } : {}),
     });
     // Case-insensitive alias for CLI lowercase ids
     map.set(id.toLowerCase(), map.get(id)!);
@@ -290,6 +323,7 @@ export function discoverCommandModels(): DiscoveredModelMeta[] {
       free,
       efforts: enrich?.efforts ?? [],
       reasoning: enrich ? enrich.reasoning : true,
+      ...(enrich?.cost ? { cost: enrich.cost } : {}),
     });
   }
 
@@ -315,6 +349,7 @@ export function discoverCommandModels(): DiscoveredModelMeta[] {
       free: true,
       efforts: [],
       reasoning: true,
+      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
     });
   }
 

src/models.ts

@@ -12,9 +12,12 @@ import {
 import {
   discoverCommandModels,
   type DiscoveredModelMeta,
+  type ModelCostRates,
 } from "./model-discover.js";
 import { log } from "./log.js";
 
+export type { ModelCostRates };
+
 export type CommandModel = {
   id: string;
   name: string;
@@ -28,6 +31,8 @@ export type CommandModel = {
   free?: boolean;
   /** Supported effort levels from Command Code (empty → model decides). */
   efforts?: CommandEffort[];
+  /** Advertised $/1M token rates (OpenCode `model.cost`). */
+  cost?: ModelCostRates;
 };
 
 const CATALOG_TTL_MS = 30 * 60 * 1000;
@@ -69,6 +74,7 @@ function metaToModel(meta: DiscoveredModelMeta): CommandModel {
     vision: meta.vision,
     free: meta.free || undefined,
     efforts: meta.efforts.length ? meta.efforts : undefined,
+    cost: meta.cost,
   };
 }
 

src/proxy.ts

@@ -46,7 +46,9 @@ import {
   recordToolCall,
   recordTurnUsage,
   totalUsageAcrossSessions,
+  usageChunkFields,
   usageToOpenAI,
+  withEstimatedCost,
 } from "./usage.js";
 
 const DEFAULT_PROXY_PORT = 8797;
@@ -471,7 +473,7 @@ async function handleChatCompletions(
         continue;
       }
       if (event.kind === "finish") {
-        turnUsage = event.usage;
+        turnUsage = withEstimatedCost(event.usage, modelMeta.cost);
         systemPromptTokens = event.systemPromptTokens;
         finishReason = event.finishReason;
         recordTurnUsage(
@@ -519,6 +521,14 @@ async function handleChatCompletions(
             pendingTools.clear();
             yield* runTurn(resumed, tools, null);
           };
+          // Forward this turn's usage before parking. Omitting it emits
+          // prompt_tokens:0 and OpenCode overwrites the session meter.
+          yield {
+            kind: "finish",
+            finishReason,
+            usage: turnUsage,
+            systemPromptTokens,
+          } satisfies GatewayMappedEvent;
           yield { type: "__park__", tools: assistantToolCalls };
           return;
         }
@@ -534,6 +544,7 @@ async function handleChatCompletions(
     }
 
     // Stream ended without explicit finish.
+    turnUsage = withEstimatedCost(turnUsage, modelMeta.cost);
     recordTurnUsage(
       conversationKey,
       model,
@@ -624,7 +635,7 @@ function streamOpenAIResponse(
                 finish_reason: toolCalls.length ? "tool_calls" : "stop",
               },
             ],
-            ...(includeUsage ? { usage: usageToOpenAI(usage) } : {}),
+            ...(includeUsage ? usageChunkFields(usage) : {}),
           };
           controller.enqueue(
             new TextEncoder().encode(JSON.stringify(payload)),
@@ -778,7 +789,7 @@ function streamOpenAIResponse(
         created,
         model,
         choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
-        ...(includeUsage ? { usage: usageToOpenAI(usage) } : {}),
+        ...(includeUsage ? usageChunkFields(usage) : {}),
       });
       controller.enqueue(encoder.encode("data: [DONE]\n\n"));
       controller.close();