n9router 0.4.43 → 0.4.45

package/app/open-sse/translator/response/claude-to-openai.js

@@ -1,19 +1,18 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK, OPENAI_FINISH } from "../schema/index.js";
+import { buildChunk } from "../concerns/chunk.js";
+import { toOpenAIUsage } from "../concerns/usage.js";
+import { reasoningDelta } from "../concerns/reasoning.js";
+import { toOpenAIFinish } from "../concerns/finishReason.js";
 
 // Create OpenAI chunk helper
 function createChunk(state, delta, finishReason = null) {
-  return {
-    id: `chatcmpl-${state.messageId}`,
-    object: "chat.completion.chunk",
-    created: Math.floor(Date.now() / 1000),
-    model: state.model,
-    choices: [{
-      index: 0,
-      delta,
-      finish_reason: finishReason
-    }]
-  };
+  return buildChunk(
+    { id: `chatcmpl-${state.messageId}`, created: Math.floor(Date.now() / 1000), model: state.model },
+    delta,
+    finishReason
+  );
 }
 
 // Convert Claude stream chunk to OpenAI format
@@ -28,16 +27,26 @@ export function claudeToOpenAIResponse(chunk, state) {
       state.messageId = chunk.message?.id || `msg_${Date.now()}`;
       state.model = chunk.message?.model;
       state.toolCallIndex = 0;
-      // Capture input-side tokens from message_start.
-      // Claude SSE reports input_tokens and cache tokens ONLY here; message_delta only has output_tokens.
-      if (chunk.message?.usage) {
-        state.inputUsage = {
-          input_tokens: chunk.message.usage.input_tokens || 0,
-          cache_read_input_tokens: chunk.message.usage.cache_read_input_tokens || 0,
-          cache_creation_input_tokens: chunk.message.usage.cache_creation_input_tokens || 0
+      // Claude sends input_tokens + cache_read + cache_creation here; message_delta
+      // later carries only the final output_tokens. Capture cache now so the
+      // delta (output-only) doesn't reset it to zero.
+      const startUsage = chunk.message?.usage;
+      if (startUsage && typeof startUsage === "object") {
+        const inputTokens = typeof startUsage.input_tokens === "number" ? startUsage.input_tokens : 0;
+        const cacheReadTokens = typeof startUsage.cache_read_input_tokens === "number" ? startUsage.cache_read_input_tokens : 0;
+        const cacheCreationTokens = typeof startUsage.cache_creation_input_tokens === "number" ? startUsage.cache_creation_input_tokens : 0;
+        const promptTokens = inputTokens + cacheReadTokens + cacheCreationTokens;
+        state.usage = {
+          prompt_tokens: promptTokens,
+          completion_tokens: 0,
+          total_tokens: promptTokens,
+          input_tokens: inputTokens,
+          output_tokens: 0
         };
+        if (cacheReadTokens > 0) state.usage.cache_read_input_tokens = cacheReadTokens;
+        if (cacheCreationTokens > 0) state.usage.cache_creation_input_tokens = cacheCreationTokens;
       }
-      results.push(createChunk(state, { role: "assistant" }));
+      results.push(createChunk(state, { role: ROLE.ASSISTANT }));
       break;
     }
 
@@ -48,20 +57,20 @@ export function claudeToOpenAIResponse(chunk, state) {
         state.serverToolBlockIndex = chunk.index;
         break;
       }
-      if (block?.type === "text") {
+      if (block?.type === CLAUDE_BLOCK.TEXT) {
         state.textBlockStarted = true;
-      } else if (block?.type === "thinking") {
+      } else if (block?.type === CLAUDE_BLOCK.THINKING) {
         state.inThinkingBlock = true;
         state.currentBlockIndex = chunk.index;
         results.push(createChunk(state, { content: "<think>" }));
-      } else if (block?.type === "tool_use") {
+      } else if (block?.type === CLAUDE_BLOCK.TOOL_USE) {
         const toolCallIndex = state.toolCallIndex++;
         // Restore original tool name from mapping (Claude OAuth)
         const toolName = state.toolNameMap?.get(block.name) || block.name;
         const toolCall = {
           index: toolCallIndex,
           id: block.id,
-          type: "function",
+          type: OPENAI_BLOCK.FUNCTION,
           function: {
             name: toolName,
             arguments: ""
@@ -80,7 +89,7 @@ export function claudeToOpenAIResponse(chunk, state) {
       if (delta?.type === "text_delta" && delta.text) {
         results.push(createChunk(state, { content: delta.text }));
       } else if (delta?.type === "thinking_delta" && delta.thinking) {
-        results.push(createChunk(state, { reasoning_content: delta.thinking }));
+        results.push(createChunk(state, reasoningDelta(delta.thinking)));
       } else if (delta?.type === "input_json_delta" && delta.partial_json) {
         const toolCall = state.toolCalls.get(chunk.index);
         if (toolCall) {
@@ -114,21 +123,14 @@ export function claudeToOpenAIResponse(chunk, state) {
 
     case "message_delta": {
       // Extract usage from message_delta event (Claude native format).
-      // IMPORTANT: Claude SSE only reports output_tokens in message_delta.
-      // input_tokens and cache tokens were reported in message_start and are stored in state.inputUsage.
+      // Anthropic sends input/cache in message_start and only output here, so
+      // fall back to cache captured in message_start when the delta omits it.
       if (chunk.usage && typeof chunk.usage === "object") {
-        const startUsage = state.inputUsage || {};
-        // Use message_delta values when present; fall back to message_start captured values.
-        const inputTokens = typeof chunk.usage.input_tokens === "number"
-          ? chunk.usage.input_tokens
-          : (startUsage.input_tokens || 0);
+        const prev = state.usage || {};
+        const inputTokens = typeof chunk.usage.input_tokens === "number" ? chunk.usage.input_tokens : (prev.input_tokens || 0);
         const outputTokens = typeof chunk.usage.output_tokens === "number" ? chunk.usage.output_tokens : 0;
-        const cacheReadTokens = typeof chunk.usage.cache_read_input_tokens === "number"
-          ? chunk.usage.cache_read_input_tokens
-          : (startUsage.cache_read_input_tokens || 0);
-        const cacheCreationTokens = typeof chunk.usage.cache_creation_input_tokens === "number"
-          ? chunk.usage.cache_creation_input_tokens
-          : (startUsage.cache_creation_input_tokens || 0);
+        const cacheReadTokens = typeof chunk.usage.cache_read_input_tokens === "number" ? chunk.usage.cache_read_input_tokens : (prev.cache_read_input_tokens || 0);
+        const cacheCreationTokens = typeof chunk.usage.cache_creation_input_tokens === "number" ? chunk.usage.cache_creation_input_tokens : (prev.cache_creation_input_tokens || 0);
 
         // prompt_tokens = input_tokens + cache_read + cache_creation (all prompt-side tokens)
         const promptTokens = inputTokens + cacheReadTokens + cacheCreationTokens;
@@ -147,28 +149,17 @@ export function claudeToOpenAIResponse(chunk, state) {
 
       if (chunk.delta?.stop_reason) {
         state.finishReason = convertStopReason(chunk.delta.stop_reason);
-        const finalChunk = {
-          id: `chatcmpl-${state.messageId}`,
-          object: "chat.completion.chunk",
-          created: Math.floor(Date.now() / 1000),
-          model: state.model,
-          choices: [{ index: 0, delta: {}, finish_reason: state.finishReason }]
-        };
+        const finalChunk = createChunk(state, {}, state.finishReason);
 
         if (state.usage) {
-          finalChunk.usage = {
-            prompt_tokens: state.usage.prompt_tokens,
-            completion_tokens: state.usage.completion_tokens,
-            total_tokens: state.usage.total_tokens
-          };
-
-          const cacheRead = state.usage.cache_read_input_tokens;
-          const cacheCreate = state.usage.cache_creation_input_tokens;
-          if (cacheRead > 0 || cacheCreate > 0) {
-            finalChunk.usage.prompt_tokens_details = {};
-            if (cacheRead > 0) finalChunk.usage.prompt_tokens_details.cached_tokens = cacheRead;
-            if (cacheCreate > 0) finalChunk.usage.prompt_tokens_details.cache_creation_tokens = cacheCreate;
-          }
+          // Build OpenAI usage from the merged state (cache from message_start +
+          // output from message_delta), not the delta chunk alone.
+          finalChunk.usage = toOpenAIUsage({
+            input_tokens: state.usage.input_tokens || 0,
+            output_tokens: state.usage.output_tokens || 0,
+            cache_read_input_tokens: state.usage.cache_read_input_tokens,
+            cache_creation_input_tokens: state.usage.cache_creation_input_tokens
+          }, "claude");
         }
 
         results.push(finalChunk);
@@ -179,7 +170,7 @@ export function claudeToOpenAIResponse(chunk, state) {
 
     case "message_stop": {
       if (!state.finishReasonSent) {
-        const finishReason = state.finishReason || (state.toolCalls?.size > 0 ? "tool_calls" : "stop");
+        const finishReason = state.finishReason || (state.toolCalls?.size > 0 ? OPENAI_FINISH.TOOL_CALLS : OPENAI_FINISH.STOP);
         const usageObj = (state.usage && typeof state.usage === 'object') ? {
           usage: {
             prompt_tokens: state.usage.input_tokens || 0,
@@ -187,18 +178,7 @@ export function claudeToOpenAIResponse(chunk, state) {
             total_tokens: (state.usage.input_tokens || 0) + (state.usage.output_tokens || 0)
           }
         } : {};
-        results.push({
-          id: `chatcmpl-${state.messageId}`,
-          object: "chat.completion.chunk",
-          created: Math.floor(Date.now() / 1000),
-          model: state.model,
-          choices: [{
-            index: 0,
-            delta: {},
-            finish_reason: finishReason
-          }],
-          ...usageObj
-        });
+        results.push({ ...createChunk(state, {}, finishReason), ...usageObj });
         state.finishReasonSent = true;
       }
       break;
@@ -208,16 +188,7 @@ export function claudeToOpenAIResponse(chunk, state) {
   return results.length > 0 ? results : null;
 }
 
-// Convert Claude stop_reason to OpenAI finish_reason
-function convertStopReason(reason) {
-  switch (reason) {
-    case "end_turn": return "stop";
-    case "max_tokens": return "length";
-    case "tool_use": return "tool_calls";
-    case "stop_sequence": return "stop";
-    default: return "stop";
-  }
-}
+const convertStopReason = (reason) => toOpenAIFinish(reason, "claude");
 
 // Register
 register(FORMATS.CLAUDE, FORMATS.OPENAI, null, claudeToOpenAIResponse);

package/app/open-sse/translator/response/commandcode-to-openai.js

@@ -17,6 +17,12 @@
  */
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
+import { ROLE, OPENAI_BLOCK, OPENAI_FINISH } from "../schema/index.js";
+import { buildChunk } from "../concerns/chunk.js";
+import { toOpenAIUsage } from "../concerns/usage.js";
+import { reasoningDelta } from "../concerns/reasoning.js";
+import { fallbackToolCallId } from "../concerns/toolCall.js";
+import { toOpenAIFinish } from "../concerns/finishReason.js";
 
 function ensureState(state, model) {
   if (!state.responseId) {
@@ -34,28 +40,16 @@ function ensureState(state, model) {
 }
 
 function makeChunk(state, delta, finishReason = null) {
-  return {
-    id: state.responseId,
-    object: "chat.completion.chunk",
-    created: state.created,
-    model: state.model,
-    choices: [{ index: 0, delta, finish_reason: finishReason }],
-  };
+  return buildChunk(
+    { id: state.responseId, created: state.created, model: state.model },
+    delta,
+    finishReason
+  );
 }
 
-function mapFinishReason(reason) {
-  switch (reason) {
-    case "stop": return "stop";
-    case "length": return "length";
-    case "tool-calls":
-    case "tool_use": return "tool_calls";
-    case "content-filter": return "content_filter";
-    case "error": return "stop";
-    default: return reason || "stop";
-  }
-}
+const mapFinishReason = (reason) => toOpenAIFinish(reason, "commandcode");
 
-export function convertCommandCodeToOpenAI(chunk, state) {
+export function commandCodeToOpenAIResponse(chunk, state) {
   if (!chunk) return null;
 
   // Already-OpenAI chunk: pass through
@@ -87,7 +81,7 @@ export function convertCommandCodeToOpenAI(chunk, state) {
     case "text-delta": {
       const text = event.text || event.delta || "";
       if (!text) break;
-      const delta = state.chunkIndex === 0 ? { role: "assistant", content: text } : { content: text };
+      const delta = state.chunkIndex === 0 ? { role: ROLE.ASSISTANT, content: text } : { content: text };
       state.chunkIndex++;
       state.openText = true;
       out.push(makeChunk(state, delta));
@@ -97,15 +91,13 @@ export function convertCommandCodeToOpenAI(chunk, state) {
       const text = event.text || "";
       if (!text) break;
       // Map reasoning to OpenAI "reasoning_content" field (used by deepseek-reasoner-style clients).
-      const delta = state.chunkIndex === 0
-        ? { role: "assistant", reasoning_content: text }
-        : { reasoning_content: text };
+      const delta = reasoningDelta(text, state.chunkIndex === 0);
       state.chunkIndex++;
       out.push(makeChunk(state, delta));
       break;
     }
     case "tool-input-start": {
-      const id = event.id || event.toolCallId || `call_${Date.now()}_${state.toolIndex}`;
+      const id = event.id || event.toolCallId || fallbackToolCallId(state.toolIndex);
       let idx = state.toolIndexById.get(id);
       if (idx == null) {
         idx = state.toolIndex++;
@@ -113,11 +105,11 @@ export function convertCommandCodeToOpenAI(chunk, state) {
       }
       state.openTools.add(id);
       const delta = {
-        ...(state.chunkIndex === 0 ? { role: "assistant" } : {}),
+        ...(state.chunkIndex === 0 ? { role: ROLE.ASSISTANT } : {}),
         tool_calls: [{
           index: idx,
           id,
-          type: "function",
+          type: OPENAI_BLOCK.FUNCTION,
           function: { name: event.toolName || "", arguments: "" },
         }],
       };
@@ -146,11 +138,11 @@ export function convertCommandCodeToOpenAI(chunk, state) {
       state.toolIndexById.set(id, idx);
       const argsStr = typeof event.input === "string" ? event.input : JSON.stringify(event.input ?? {});
       const delta = {
-        ...(state.chunkIndex === 0 ? { role: "assistant" } : {}),
+        ...(state.chunkIndex === 0 ? { role: ROLE.ASSISTANT } : {}),
         tool_calls: [{
           index: idx,
           id,
-          type: "function",
+          type: OPENAI_BLOCK.FUNCTION,
           function: { name: event.toolName || "", arguments: argsStr },
         }],
       };
@@ -167,22 +159,17 @@ export function convertCommandCodeToOpenAI(chunk, state) {
       const finishReason = state.finishReason || mapFinishReason(event.finishReason || "stop");
       const finalChunk = makeChunk(state, {}, finishReason);
       const totalUsage = event.totalUsage || state.usage;
-      if (totalUsage) {
-        finalChunk.usage = {
-          prompt_tokens: totalUsage.inputTokens ?? 0,
-          completion_tokens: totalUsage.outputTokens ?? 0,
-          total_tokens: totalUsage.totalTokens ?? ((totalUsage.inputTokens ?? 0) + (totalUsage.outputTokens ?? 0)),
-        };
-      }
+      const usage = toOpenAIUsage(totalUsage, "commandcode");
+      if (usage) finalChunk.usage = usage;
       out.push(finalChunk);
       break;
     }
     case "error": {
-      state.finishReason = "stop";
+      state.finishReason = OPENAI_FINISH.STOP;
       const errVal = event.error ?? event.message ?? "unknown";
       const errStr = typeof errVal === "string" ? errVal : JSON.stringify(errVal);
       out.push(makeChunk(state, { content: `\n\n[CommandCode error: ${errStr}]` }));
-      out.push(makeChunk(state, {}, "stop"));
+      out.push(makeChunk(state, {}, OPENAI_FINISH.STOP));
       break;
     }
     // Silently ignore: start, start-step, reasoning-start, reasoning-end, text-start, text-end,
@@ -194,4 +181,4 @@ export function convertCommandCodeToOpenAI(chunk, state) {
   return out.length ? out : null;
 }
 
-register(FORMATS.COMMANDCODE, FORMATS.OPENAI, null, convertCommandCodeToOpenAI);
+register(FORMATS.COMMANDCODE, FORMATS.OPENAI, null, commandCodeToOpenAIResponse);

package/app/open-sse/translator/response/cursor-to-openai.js

@@ -10,7 +10,7 @@ import { FORMATS } from "../formats.js";
  * Since CursorExecutor.transformProtobufToSSE/JSON already emits OpenAI chunks,
  * this is a passthrough translator (similar to Kiro pattern)
  */
-export function convertCursorToOpenAI(chunk, state) {
+export function cursorToOpenAIResponse(chunk, state) {
   if (!chunk) return null;
 
   // If chunk is already in OpenAI format (from executor transform), return as-is
@@ -27,4 +27,4 @@ export function convertCursorToOpenAI(chunk, state) {
   return chunk;
 }
 
-register(FORMATS.CURSOR, FORMATS.OPENAI, null, convertCursorToOpenAI);
+register(FORMATS.CURSOR, FORMATS.OPENAI, null, cursorToOpenAIResponse);

package/app/open-sse/translator/response/gemini-to-openai.js

@@ -1,5 +1,36 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
+import { ROLE, OPENAI_BLOCK, OPENAI_FINISH, DEFAULT_IMAGE_MIME } from "../schema/index.js";
+import { buildChunk } from "../concerns/chunk.js";
+import { toOpenAIUsage } from "../concerns/usage.js";
+import { reasoningDelta } from "../concerns/reasoning.js";
+import { encodeDataUri } from "../concerns/image.js";
+import { toOpenAIFinish } from "../concerns/finishReason.js";
+
+// Build chunk meta for current gemini state
+function chunkMeta(state) {
+  return { id: `chatcmpl-${state.messageId}`, created: Math.floor(Date.now() / 1000), model: state.model };
+}
+
+// Build a tool_call chunk from a gemini functionCall part (shared by sig/non-sig branches)
+function emitFunctionCall(functionCall, state) {
+  const rawName = functionCall.name;
+  // Restore original tool name from mapping (AG cloaking)
+  const fcName = state.toolNameMap?.get(rawName) || rawName;
+  const fcArgs = functionCall.args || {};
+  const toolCallIndex = state.functionIndex++;
+  const toolCall = {
+    id: `${fcName}-${Date.now()}-${toolCallIndex}`,
+    index: toolCallIndex,
+    type: OPENAI_BLOCK.FUNCTION,
+    function: { name: fcName, arguments: JSON.stringify(fcArgs) },
+  };
+  // Keep Gemini bookkeeping separate from the shared translator state.toolCalls map.
+  // The downstream OpenAI→Claude translator uses state.toolCalls for Claude block
+  // metadata; pre-populating it here makes Anthropic tool deltas lose index.
+  state.geminiToolCallCount = (state.geminiToolCallCount || 0) + 1;
+  return buildChunk(chunkMeta(state), { tool_calls: [toolCall] }, null);
+}
 
 // Convert Gemini response chunk to OpenAI format
 export function geminiToOpenAIResponse(chunk, state) {
@@ -18,17 +49,8 @@ export function geminiToOpenAIResponse(chunk, state) {
     state.messageId = response.responseId || `msg_${Date.now()}`;
     state.model = response.modelVersion || "gemini";
     state.functionIndex = 0;
-    results.push({
-      id: `chatcmpl-${state.messageId}`,
-      object: "chat.completion.chunk",
-      created: Math.floor(Date.now() / 1000),
-      model: state.model,
-      choices: [{
-        index: 0,
-        delta: { role: "assistant" },
-        finish_reason: null
-      }]
-    });
+    state.geminiToolCallCount = 0;
+    results.push(buildChunk(chunkMeta(state), { role: ROLE.ASSISTANT }, null));
   }
 
   // Process parts
@@ -43,187 +65,67 @@ export function geminiToOpenAIResponse(chunk, state) {
         const hasFunctionCall = !!part.functionCall;
         
         if (hasTextContent) {
-          results.push({
-            id: `chatcmpl-${state.messageId}`,
-            object: "chat.completion.chunk",
-            created: Math.floor(Date.now() / 1000),
-            model: state.model,
-            choices: [{
-              index: 0,
-              delta: isThought 
-                ? { reasoning_content: part.text }
-                : { content: part.text },
-              finish_reason: null
-            }]
-          });
+          results.push(buildChunk(
+            chunkMeta(state),
+            isThought ? reasoningDelta(part.text) : { content: part.text },
+            null
+          ));
         }
         
         if (hasFunctionCall) {
-          const rawName = part.functionCall.name;
-          // Restore original tool name from mapping (AG cloaking)
-          const fcName = state.toolNameMap?.get(rawName) || rawName;
-          const fcArgs = part.functionCall.args || {};
-          const toolCallIndex = state.functionIndex++;
-          
-          const toolCall = {
-            id: `${fcName}-${Date.now()}-${toolCallIndex}`,
-            index: toolCallIndex,
-            type: "function",
-            function: {
-              name: fcName,
-              arguments: JSON.stringify(fcArgs)
-            }
-          };
-          
-          state.toolCalls.set(toolCallIndex, toolCall);
-          
-          results.push({
-            id: `chatcmpl-${state.messageId}`,
-            object: "chat.completion.chunk",
-            created: Math.floor(Date.now() / 1000),
-            model: state.model,
-            choices: [{
-              index: 0,
-              delta: { tool_calls: [toolCall] },
-              finish_reason: null
-            }]
-          });
+          results.push(emitFunctionCall(part.functionCall, state));
         }
         continue;
       }
 
-      // Text content (non-thinking)
+      // Text content. Gemini marks model-internal thinking with `thought: true`.
+      // Some responses include a thoughtSignature, but Google AI Studio/Gemini API
+      // can also stream thought parts without a signature; those must not be
+      // surfaced as normal assistant content in OpenAI-compatible clients.
       if (part.text !== undefined && part.text !== "") {
-        results.push({
-          id: `chatcmpl-${state.messageId}`,
-          object: "chat.completion.chunk",
-          created: Math.floor(Date.now() / 1000),
-          model: state.model,
-          choices: [{
-            index: 0,
-            delta: { content: part.text },
-            finish_reason: null
-          }]
-        });
+        results.push(buildChunk(
+          chunkMeta(state),
+          isThought ? reasoningDelta(part.text) : { content: part.text },
+          null
+        ));
       }
 
       // Function call
       if (part.functionCall) {
-        const rawName = part.functionCall.name;
-        // Restore original tool name from mapping (AG cloaking)
-        const fcName = state.toolNameMap?.get(rawName) || rawName;
-        const fcArgs = part.functionCall.args || {};
-        const toolCallIndex = state.functionIndex++;
-        
-        const toolCall = {
-          id: `${fcName}-${Date.now()}-${toolCallIndex}`,
-          index: toolCallIndex,
-          type: "function",
-          function: {
-            name: fcName,
-            arguments: JSON.stringify(fcArgs)
-          }
-        };
-        
-        state.toolCalls.set(toolCallIndex, toolCall);
-        
-        results.push({
-          id: `chatcmpl-${state.messageId}`,
-          object: "chat.completion.chunk",
-          created: Math.floor(Date.now() / 1000),
-          model: state.model,
-          choices: [{
-            index: 0,
-            delta: { tool_calls: [toolCall] },
-            finish_reason: null
-          }]
-        });
+        results.push(emitFunctionCall(part.functionCall, state));
       }
 
       // Inline data (images)
       const inlineData = part.inlineData || part.inline_data;
       if (inlineData?.data) {
-        const mimeType = inlineData.mimeType || inlineData.mime_type || "image/png";
-        results.push({
-          id: `chatcmpl-${state.messageId}`,
-          object: "chat.completion.chunk",
-          created: Math.floor(Date.now() / 1000),
-          model: state.model,
-          choices: [{
-            index: 0,
-            delta: {
-              images: [{
-                type: "image_url",
-                image_url: { url: `data:${mimeType};base64,${inlineData.data}` }
-              }]
-            },
-            finish_reason: null
-          }]
-        });
+        const mimeType = inlineData.mimeType || inlineData.mime_type || DEFAULT_IMAGE_MIME;
+        results.push(buildChunk(
+          chunkMeta(state),
+          {
+            images: [{
+              type: OPENAI_BLOCK.IMAGE_URL,
+              image_url: { url: encodeDataUri(mimeType, inlineData.data) }
+            }]
+          },
+          null
+        ));
       }
     }
   }
 
   // Usage metadata - extract before finish reason so we can include it
   const usageMeta = response.usageMetadata || chunk.usageMetadata;
-  if (usageMeta && typeof usageMeta === "object") {
-    const cachedTokens = typeof usageMeta.cachedContentTokenCount === "number" ? usageMeta.cachedContentTokenCount : 0;
-    const promptTokenCountRaw = typeof usageMeta.promptTokenCount === "number" ? usageMeta.promptTokenCount : 0;
-    const thoughtsTokens = typeof usageMeta.thoughtsTokenCount === "number" ? usageMeta.thoughtsTokenCount : 0;
-    let candidatesTokens = typeof usageMeta.candidatesTokenCount === "number" ? usageMeta.candidatesTokenCount : 0;
-    const totalTokens = typeof usageMeta.totalTokenCount === "number" ? usageMeta.totalTokenCount : 0;
-    
-    // prompt_tokens = promptTokenCount (includes cached tokens, matching claude-to-openai.js behavior)
-    const promptTokens = promptTokenCountRaw;
-    
-    // Fallback calculation if candidatesTokenCount is 0 but totalTokenCount exists
-    if (candidatesTokens === 0 && totalTokens > 0) {
-      candidatesTokens = totalTokens - promptTokenCountRaw - thoughtsTokens;
-      if (candidatesTokens < 0) candidatesTokens = 0;
-    }
-    
-    // completion_tokens = candidatesTokenCount + thoughtsTokenCount (match Go code)
-    const completionTokens = candidatesTokens + thoughtsTokens;
-    
-    state.usage = {
-      prompt_tokens: promptTokens,
-      completion_tokens: completionTokens,
-      total_tokens: totalTokens
-    };
-    
-    // Add prompt_tokens_details if cached tokens exist
-    if (cachedTokens > 0) {
-      state.usage.prompt_tokens_details = {
-        cached_tokens: cachedTokens
-      };
-    }
-    
-    // Add completion_tokens_details if reasoning tokens exist
-    if (thoughtsTokens > 0) {
-      state.usage.completion_tokens_details = {
-        reasoning_tokens: thoughtsTokens
-      };
-    }
-  }
+  const geminiUsage = toOpenAIUsage(usageMeta, "gemini");
+  if (geminiUsage) state.usage = geminiUsage;
 
   // Finish reason - include usage in final chunk
   if (candidate.finishReason) {
-    let finishReason = candidate.finishReason.toLowerCase();
-    if (finishReason === "stop" && state.toolCalls.size > 0) {
-      finishReason = "tool_calls";
+    let finishReason = toOpenAIFinish(candidate.finishReason, "gemini");
+    if (finishReason === OPENAI_FINISH.STOP && state.geminiToolCallCount > 0) {
+      finishReason = OPENAI_FINISH.TOOL_CALLS;
     }
     
-    const finalChunk = {
-      id: `chatcmpl-${state.messageId}`,
-      object: "chat.completion.chunk",
-      created: Math.floor(Date.now() / 1000),
-      model: state.model,
-      choices: [{
-        index: 0,
-        delta: {},
-        finish_reason: finishReason
-      }]
-    };
+    const finalChunk = buildChunk(chunkMeta(state), {}, finishReason);
     
     // Include usage in final chunk for downstream translators
     if (state.usage) {