fix: exclude cached tokens from chat usage

src/plugin.ts

@@ -913,10 +913,148 @@ function createFetchInterceptor(
       debug('Processing /v1/models response');
     }
 
-    return response;
+    return normalizeChatUsageResponse(url, response);
   };
 }
 
+async function normalizeChatUsageResponse(url: string, response: Response): Promise<Response> {
+  if (!response.ok || !url.includes('/chat/completions')) {
+    return response;
+  }
+
+  const contentType = response.headers.get('content-type')?.toLowerCase() ?? '';
+  if (contentType.includes('application/json')) {
+    return normalizeJsonChatUsageResponse(response);
+  }
+
+  if (contentType.includes('text/event-stream')) {
+    return normalizeSseChatUsageResponse(response);
+  }
+
+  return response;
+}
+
+async function normalizeJsonChatUsageResponse(response: Response): Promise<Response> {
+  let payload: unknown;
+  try {
+    payload = await response.clone().json();
+  } catch {
+    return response;
+  }
+
+  if (!isRecord(payload) || !normalizeCachedChatUsage(payload)) {
+    return response;
+  }
+
+  const headers = cloneMutableResponseHeaders(response.headers);
+  headers.set('Content-Type', 'application/json');
+  return new Response(JSON.stringify(payload), {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
+function normalizeSseChatUsageResponse(response: Response): Response {
+  if (!response.body) {
+    return response;
+  }
+
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let pending = '';
+
+  const stream = response.body.pipeThrough(new TransformStream<Uint8Array, Uint8Array>({
+    transform(chunk, controller) {
+      pending += decoder.decode(chunk, { stream: true });
+      const lines = pending.split('\n');
+      pending = lines.pop() ?? '';
+
+      for (const line of lines) {
+        controller.enqueue(encoder.encode(`${normalizeSseChatUsageLine(line)}\n`));
+      }
+    },
+    flush(controller) {
+      const tail = pending + decoder.decode();
+      if (tail) {
+        controller.enqueue(encoder.encode(`${normalizeSseChatUsageLine(tail)}\n`));
+      }
+    },
+  }));
+
+  return new Response(stream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: cloneMutableResponseHeaders(response.headers),
+  });
+}
+
+function normalizeSseChatUsageLine(line: string): string {
+  if (!line.startsWith('data:')) {
+    return line;
+  }
+
+  const rawData = line.slice(5).trim();
+  if (!rawData || rawData === '[DONE]') {
+    return line;
+  }
+
+  let payload: unknown;
+  try {
+    payload = JSON.parse(rawData);
+  } catch {
+    return line;
+  }
+
+  if (!isRecord(payload) || !normalizeCachedChatUsage(payload)) {
+    return line;
+  }
+
+  return `data: ${JSON.stringify(payload)}`;
+}
+
+function normalizeCachedChatUsage(payload: Record<string, unknown>): boolean {
+  const usage = payload.usage;
+  if (!isRecord(usage)) {
+    return false;
+  }
+
+  const promptTokens = getNumber(usage.prompt_tokens);
+  const promptDetails = getRecord(usage.prompt_tokens_details);
+  const cachedTokens = getNumber(promptDetails?.cached_tokens);
+  if (
+    promptTokens === undefined ||
+    cachedTokens === undefined ||
+    cachedTokens <= 0 ||
+    cachedTokens > promptTokens
+  ) {
+    return false;
+  }
+
+  // OpenCode tracks cached input separately, so prompt_tokens must be non-cached.
+  usage.prompt_tokens = promptTokens - cachedTokens;
+  const totalTokens = getNumber(usage.total_tokens);
+  if (totalTokens !== undefined) {
+    usage.total_tokens = totalTokens - cachedTokens;
+  }
+  return true;
+}
+
+function getNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function getRecord(value: unknown): Record<string, unknown> | undefined {
+  return isRecord(value) ? value : undefined;
+}
+
+function cloneMutableResponseHeaders(headers: Headers): Headers {
+  const next = new Headers(headers);
+  next.delete('Content-Length');
+  next.delete('Content-Encoding');
+  return next;
+}
+
 const GEMINI_SCHEMA_KEYS_TO_REMOVE = new Set(['$schema', '$ref', 'ref', 'additionalProperties']);
 
 async function sanitizeGeminiToolSchemas(

test/plugin.test.mjs

@@ -130,6 +130,97 @@ test('loader injects auth headers only for OmniRoute URLs', async () => {
   assert.equal(externalHeaders.get('Authorization'), null);
 });
 
+test('chat completion excludes cached tokens from JSON prompt tokens', async () => {
+  const plugin = await OmniRouteAuthPlugin({});
+
+  global.fetch = async (input) => {
+    const url = input instanceof Request ? input.url : String(input);
+    if (url.endsWith('/v1/models')) {
+      return new Response(JSON.stringify(createModelsResponse()), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
+    return new Response(
+      JSON.stringify({
+        id: 'chatcmpl-test',
+        object: 'chat.completion',
+        choices: [],
+        usage: {
+          prompt_tokens: 39493,
+          completion_tokens: 185,
+          total_tokens: 39678,
+          prompt_tokens_details: { cached_tokens: 36864 },
+        },
+      }),
+      { status: 200, headers: { 'Content-Type': 'application/json' } },
+    );
+  };
+
+  const provider = {
+    options: { baseURL: getDummyBaseUrl(), apiMode: 'chat' },
+    models: {},
+  };
+
+  const options = await plugin.auth.loader(async () => ({ type: 'api', key: 'secret-key' }), provider);
+  const response = await options.fetch(`${getDummyBaseUrl()}/chat/completions`, {
+    method: 'POST',
+    body: JSON.stringify({ model: 'gpt-4.1-mini', messages: [] }),
+  });
+  const body = await response.json();
+
+  assert.equal(body.usage.prompt_tokens, 2629);
+  assert.equal(body.usage.completion_tokens, 185);
+  assert.equal(body.usage.total_tokens, 2814);
+  assert.equal(body.usage.prompt_tokens_details.cached_tokens, 36864);
+});
+
+test('chat completion excludes cached tokens from streaming prompt tokens', async () => {
+  const plugin = await OmniRouteAuthPlugin({});
+  const contentChunk = 'data: {"choices":[{"delta":{"content":"hi"},"index":0}]}';
+  const usageChunk = 'data: {"choices":[],"usage":{"prompt_tokens":39493,"completion_tokens":185,"total_tokens":39678,"prompt_tokens_details":{"cached_tokens":36864}}}';
+
+  global.fetch = async (input) => {
+    const url = input instanceof Request ? input.url : String(input);
+    if (url.endsWith('/v1/models')) {
+      return new Response(JSON.stringify(createModelsResponse()), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
+    return new Response(`${contentChunk}\n\n${usageChunk}\n\ndata: [DONE]`, {
+      status: 200,
+      headers: { 'Content-Type': 'text/event-stream' },
+    });
+  };
+
+  const provider = {
+    options: { baseURL: getDummyBaseUrl(), apiMode: 'chat' },
+    models: {},
+  };
+
+  const options = await plugin.auth.loader(async () => ({ type: 'api', key: 'secret-key' }), provider);
+  const response = await options.fetch(`${getDummyBaseUrl()}/chat/completions`, {
+    method: 'POST',
+    body: JSON.stringify({ model: 'gpt-4.1-mini', messages: [], stream: true }),
+  });
+  const text = await response.text();
+  const normalizedLine = text
+    .split('\n')
+    .find((line) => line.includes('"prompt_tokens"'));
+
+  assert.ok(text.includes(contentChunk));
+  assert.ok(text.endsWith('\n'));
+  assert.ok(normalizedLine);
+  const normalized = JSON.parse(normalizedLine.slice('data: '.length));
+  assert.equal(normalized.usage.prompt_tokens, 2629);
+  assert.equal(normalized.usage.completion_tokens, 185);
+  assert.equal(normalized.usage.total_tokens, 2814);
+  assert.equal(normalized.usage.prompt_tokens_details.cached_tokens, 36864);
+});
+
 test('auth loader applies user modelMetadata override to provider models', async () => {
   const plugin = await OmniRouteAuthPlugin({});