fix(openai): split reasoning from output and fix cacheWrite in totalTokens fallback

- Stop double-counting reasoning by setting usage.output to completion_tokens
  (which already includes reasoning per OpenAI's wire contract)
- Expose reasoning as a separate read-only count on usage.reasoning
- Include cacheWrite in the totalTokens fallback when total_tokens is absent

Author: yyyyaaa

packages/openai/__tests__/openai.test.ts

@@ -74,6 +74,64 @@ describe('OpenAIAdapter', () => {
     });
   });
 
+  it('surfaces reasoning tokens without double-counting output', async () => {
+    (fetch as jest.Mock).mockResolvedValueOnce(
+      createStreamingResponse([
+        'data: {"choices":[{"delta":{"content":"Hi"},"finish_reason":"stop"}],"usage":{"prompt_tokens":20,"completion_tokens":15,"total_tokens":35,"completion_tokens_details":{"reasoning_tokens":8}}}',
+        'data: [DONE]',
+      ])
+    );
+
+    const adapter = new OpenAIAdapter({ apiKey: 'test-key' });
+    const model = adapter.createModel('gpt-5.4-mini');
+    const stream = adapter.stream(model, {
+      messages: [{ role: 'user', content: 'hi', timestamp: Date.now() }],
+    });
+
+    for await (const _ of stream) { /* drain */ }
+    const message = await stream.result();
+
+    // output must equal completion_tokens (15), NOT completion_tokens + reasoning_tokens (23)
+    expect(message.usage.output).toBe(15);
+    // reasoning is exposed as its own field
+    expect(message.usage.reasoning).toBe(8);
+    // total from wire — no double-count
+    expect(message.usage.totalTokens).toBe(35);
+  });
+
+  it('totalTokens fallback includes cacheWrite when total_tokens is absent', async () => {
+    // Simulate a chunk with no total_tokens but with cached input tokens and reasoning.
+    // cacheWrite stays 0 (adapter default) but the fallback formula must still be correct.
+    (fetch as jest.Mock).mockResolvedValueOnce(
+      createStreamingResponse([
+        'data: {"choices":[{"delta":{"content":"Hi"},"finish_reason":"stop"}],"usage":{"prompt_tokens":30,"completion_tokens":10,"completion_tokens_details":{"reasoning_tokens":4},"prompt_tokens_details":{"cached_tokens":6}}}',
+        'data: [DONE]',
+      ])
+    );
+
+    const adapter = new OpenAIAdapter({ apiKey: 'test-key' });
+    const model = adapter.createModel('gpt-5.4-mini');
+    const stream = adapter.stream(model, {
+      messages: [{ role: 'user', content: 'hi', timestamp: Date.now() }],
+    });
+
+    for await (const _ of stream) { /* drain */ }
+    const message = await stream.result();
+
+    // input = prompt_tokens(30) - cached(6) = 24
+    expect(message.usage.input).toBe(24);
+    // output = completion_tokens (no double-count)
+    expect(message.usage.output).toBe(10);
+    // reasoning subset
+    expect(message.usage.reasoning).toBe(4);
+    // cacheRead = cached_tokens
+    expect(message.usage.cacheRead).toBe(6);
+    // cacheWrite = 0 (stock OpenAI doesn't emit it)
+    expect(message.usage.cacheWrite).toBe(0);
+    // fallback: input + output + cacheRead + cacheWrite = 24 + 10 + 6 + 0 = 40
+    expect(message.usage.totalTokens).toBe(40);
+  });
+
   it('falls back to built-in models when no API key is configured', async () => {
     const adapter = new OpenAIAdapter();
     const models = await adapter.listModels();

packages/openai/src/index.ts

@@ -128,6 +128,7 @@ interface StreamOptions {
 interface Usage {
   input: number;
   output: number;
+  reasoning: number;
   cacheRead: number;
   cacheWrite: number;
   totalTokens: number;
@@ -797,6 +798,7 @@ function createAssistantMessage(model: ModelDescriptor): AssistantMessage {
     usage: {
       input: 0,
       output: 0,
+      reasoning: 0,
       cacheRead: 0,
       cacheWrite: 0,
       totalTokens: 0,
@@ -825,10 +827,11 @@ function applyUsage(
   const reasoningTokens = payload.completion_tokens_details?.reasoning_tokens ?? 0;
 
   usage.input = (payload.prompt_tokens ?? 0) - cachedTokens;
-  usage.output = (payload.completion_tokens ?? 0) + reasoningTokens;
+  usage.output = payload.completion_tokens ?? 0;
+  usage.reasoning = reasoningTokens;
   usage.cacheRead = cachedTokens;
   usage.cacheWrite = 0;
-  usage.totalTokens = payload.total_tokens ?? usage.input + usage.output + usage.cacheRead;
+  usage.totalTokens = payload.total_tokens ?? usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
   calculateUsageCost(model, usage);
 }