n9router 0.4.44 → 0.4.45

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

@@ -4,12 +4,23 @@
  */
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
+import { ROLE, OPENAI_BLOCK } from "../schema/index.js";
+import { buildChunk } from "../concerns/chunk.js";
+import { toOpenAIUsage } from "../concerns/usage.js";
+import { fallbackToolCallId } from "../concerns/toolCall.js";
+import { reasoningDelta } from "../concerns/reasoning.js";
+import { toOpenAIFinish } from "../concerns/finishReason.js";
+
+// Build chunk meta for current kiro state
+function chunkMeta(state) {
+  return { id: state.responseId, created: state.created, model: state.model || "kiro" };
+}
 
 /**
  * Parse Kiro SSE event and convert to OpenAI format
  * Kiro events: assistantResponseEvent, codeEvent, supplementaryWebLinksEvent, etc.
  */
-export function convertKiroToOpenAI(chunk, state) {
+export function kiroToOpenAIResponse(chunk, state) {
   
   if (!chunk) return null;
 
@@ -66,20 +77,10 @@ export function convertKiroToOpenAI(chunk, state) {
     const content = data.assistantResponseEvent?.content || data.content || "";
     if (!content) return null;
 
-    const openaiChunk = {
-      id: state.responseId,
-      object: "chat.completion.chunk",
-      created: state.created,
-      model: state.model || "kiro",
-      choices: [{
-        index: 0,
-        delta: {
-          ...(state.chunkIndex === 0 ? { role: "assistant" } : {}),
-          content: content
-        },
-        finish_reason: null
-      }]
-    };
+    const openaiChunk = buildChunk(chunkMeta(state), {
+      ...(state.chunkIndex === 0 ? { role: ROLE.ASSISTANT } : {}),
+      content: content
+    }, null);
 
     state.chunkIndex++;
     return openaiChunk;
@@ -97,20 +98,7 @@ export function convertKiroToOpenAI(chunk, state) {
       : (reasoning.text || reasoning.content || data.content || "");
     if (!content) return null;
 
-    const openaiChunk = {
-      id: state.responseId,
-      object: "chat.completion.chunk",
-      created: state.created,
-      model: state.model || "kiro",
-      choices: [{
-        index: 0,
-        delta: {
-          ...(state.chunkIndex === 0 ? { role: "assistant" } : {}),
-          reasoning_content: content
-        },
-        finish_reason: null
-      }]
-    };
+    const openaiChunk = buildChunk(chunkMeta(state), reasoningDelta(content, state.chunkIndex === 0), null);
 
     state.chunkIndex++;
     return openaiChunk;
@@ -118,33 +106,24 @@ export function convertKiroToOpenAI(chunk, state) {
 
   // Handle tool use events
   if (eventType === "toolUseEvent" || data.toolUseEvent) {
+    state.hadToolUse = true;
     const toolUse = data.toolUseEvent || data;
-    const toolCallId = toolUse.toolUseId || `call_${Date.now()}`;
+    const toolCallId = toolUse.toolUseId || fallbackToolCallId();
     const toolName = toolUse.name || "";
     const toolInput = toolUse.input || {};
 
-    const openaiChunk = {
-      id: state.responseId,
-      object: "chat.completion.chunk",
-      created: state.created,
-      model: state.model || "kiro",
-      choices: [{
+    const openaiChunk = buildChunk(chunkMeta(state), {
+      ...(state.chunkIndex === 0 ? { role: ROLE.ASSISTANT } : {}),
+      tool_calls: [{
         index: 0,
-        delta: {
-          ...(state.chunkIndex === 0 ? { role: "assistant" } : {}),
-          tool_calls: [{
-            index: 0,
-            id: toolCallId,
-            type: "function",
-            function: {
-              name: toolName,
-              arguments: JSON.stringify(toolInput)
-            }
-          }]
-        },
-        finish_reason: null
+        id: toolCallId,
+        type: OPENAI_BLOCK.FUNCTION,
+        function: {
+          name: toolName,
+          arguments: JSON.stringify(toolInput)
+        }
       }]
-    };
+    }, null);
 
     state.chunkIndex++;
     return openaiChunk;
@@ -152,19 +131,11 @@ export function convertKiroToOpenAI(chunk, state) {
 
   // Handle completion/done events
   if (eventType === "messageStopEvent" || eventType === "done" || data.messageStopEvent) {
-    state.finishReason = "stop"; // Mark for usage injection in stream.js
-    
-    const openaiChunk = {
-      id: state.responseId,
-      object: "chat.completion.chunk",
-      created: state.created,
-      model: state.model || "kiro",
-      choices: [{
-        index: 0,
-        delta: {},
-        finish_reason: "stop"
-      }]
-    };
+    // tool_calls when a tool was used this turn, else stop (kiro upstream has no explicit reason)
+    const finishReason = toOpenAIFinish(state.hadToolUse ? "tool_use" : "stop", "kiro");
+    state.finishReason = finishReason; // Mark for usage injection in stream.js
+
+    const openaiChunk = buildChunk(chunkMeta(state), {}, finishReason);
 
     // Include usage in final chunk if available
     if (state.usage && typeof state.usage === "object") {
@@ -176,14 +147,8 @@ export function convertKiroToOpenAI(chunk, state) {
 
 // Handle usage events
   if (eventType === "usageEvent" || data.usageEvent) {
-    const usage = data.usageEvent || data;
-    if (usage && typeof usage === 'object') {
-      state.usage = {
-        prompt_tokens: usage.inputTokens || 0,
-        completion_tokens: usage.outputTokens || 0,
-        total_tokens: (usage.inputTokens || 0) + (usage.outputTokens || 0)
-      };
-    }
+    const usage = toOpenAIUsage(data.usageEvent || data, "kiro");
+    if (usage) state.usage = usage;
     return null;
   }
 
@@ -192,4 +157,4 @@ export function convertKiroToOpenAI(chunk, state) {
 }
 
 // Register translator
-register(FORMATS.KIRO, FORMATS.OPENAI, null, convertKiroToOpenAI);
+register(FORMATS.KIRO, FORMATS.OPENAI, null, kiroToOpenAIResponse);

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

@@ -1,5 +1,10 @@
 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 { fallbackToolCallId } from "../concerns/toolCall.js";
+import { toOpenAIFinish } from "../concerns/finishReason.js";
 
 /**
  * Convert Ollama NDJSON response to OpenAI SSE format
@@ -12,7 +17,7 @@ import { FORMATS } from "../formats.js";
  * {"id": "...", "object": "chat.completion.chunk", "created": 123, "model": "...",
  *  "choices": [{"index": 0, "delta": {"content": "..."}, "finish_reason": null}]}
  */
-export function ollamaToOpenAI(chunk, state) {
+export function ollamaToOpenAIResponse(chunk, state) {
   if (!chunk || typeof chunk !== "object") return null;
 
   // Initialize state on first chunk
@@ -30,24 +35,15 @@ export function ollamaToOpenAI(chunk, state) {
   if (chunk.done) {
     const usage = extractUsage(chunk);
     
-    // Determine finish_reason based on done_reason and previous tool_calls
-    let finishReason = "stop";
-    if (chunk.done_reason === "tool_calls" || state.hadToolCalls) {
-      finishReason = "tool_calls";
+    // Determine finish_reason: map upstream done_reason, override to tool_calls if tools used
+    let finishReason = toOpenAIFinish(chunk.done_reason, "ollama");
+    if (chunk.done_reason === OPENAI_FINISH.TOOL_CALLS || state.hadToolCalls) {
+      finishReason = OPENAI_FINISH.TOOL_CALLS;
     }
 
-    return {
-      id: id,
-      object: "chat.completion.chunk",
-      created: created,
-      model: model,
-      choices: [{
-        index: 0,
-        delta: {},
-        finish_reason: finishReason
-      }],
-      usage: usage
-    };
+    const doneChunk = buildChunk({ id, created, model }, {}, finishReason);
+    doneChunk.usage = usage;
+    return doneChunk;
   }
 
   // Content chunk
@@ -79,28 +75,14 @@ export function ollamaToOpenAI(chunk, state) {
     delta.tool_calls = convertToolCalls(toolCalls);
   }
 
-  return {
-    id: id,
-    object: "chat.completion.chunk",
-    created: created,
-    model: model,
-    choices: [{
-      index: 0,
-      delta: delta,
-      finish_reason: null
-    }]
-  };
+  return buildChunk({ id, created, model }, delta, null);
 }
 
 /**
  * Extract usage stats from Ollama response
  */
 function extractUsage(ollamaChunk) {
-  return {
-    prompt_tokens: ollamaChunk.prompt_eval_count || 0,
-    completion_tokens: ollamaChunk.eval_count || 0,
-    total_tokens: (ollamaChunk.prompt_eval_count || 0) + (ollamaChunk.eval_count || 0)
-  };
+  return toOpenAIUsage(ollamaChunk, "ollama");
 }
 
 /**
@@ -109,8 +91,8 @@ function extractUsage(ollamaChunk) {
 function convertToolCalls(toolCalls) {
   return toolCalls.map((tc, i) => ({
     index: tc.function?.index ?? i,
-    id: tc.id || `call_${i}_${Date.now()}`,
-    type: "function",
+    id: tc.id || fallbackToolCallId(i),
+    type: OPENAI_BLOCK.FUNCTION,
     function: {
       name: tc.function?.name || "",
       arguments: typeof tc.function?.arguments === "string"
@@ -129,14 +111,14 @@ export function ollamaBodyToOpenAI(body) {
   const thinking = msg.thinking || "";
   const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
 
-  const message = { role: "assistant" };
+  const message = { role: ROLE.ASSISTANT };
   if (content) message.content = content;
   if (thinking) message.reasoning_content = thinking;
   if (toolCalls.length > 0) message.tool_calls = convertToolCalls(toolCalls);
   if (!message.content && !message.tool_calls) message.content = "";
 
-  let finishReason = body.done_reason || "stop";
-  if (toolCalls.length > 0) finishReason = "tool_calls";
+  let finishReason = toOpenAIFinish(body.done_reason, "ollama");
+  if (toolCalls.length > 0) finishReason = OPENAI_FINISH.TOOL_CALLS;
 
   return {
     id: `chatcmpl-${Date.now()}`,
@@ -149,4 +131,4 @@ export function ollamaBodyToOpenAI(body) {
 }
 
 // Register translator
-register(FORMATS.OLLAMA, FORMATS.OPENAI, null, ollamaToOpenAI);
+register(FORMATS.OLLAMA, FORMATS.OPENAI, null, ollamaToOpenAIResponse);

package/app/open-sse/translator/response/openai-responses.js

@@ -4,6 +4,11 @@
  */
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
+import { buildChunk } from "../concerns/chunk.js";
+import { buildUsage } from "../concerns/usage.js";
+import { fallbackToolCallId } from "../concerns/toolCall.js";
+import { reasoningDelta, extractReasoningText } from "../concerns/reasoning.js";
+import { ROLE, OPENAI_BLOCK, RESPONSES_ITEM, OPENAI_FINISH, MODEL_FALLBACK } from "../schema/index.js";
 
 /**
  * Translate OpenAI chunk to Responses API events
@@ -57,10 +62,11 @@ export function openaiToOpenAIResponsesResponse(chunk, state) {
     });
   }
 
-  // Handle reasoning_content
-  if (delta.reasoning_content) {
+  // Handle reasoning across vendor shapes (reasoning_content / reasoning / reasoning_details)
+  const reasoningText = extractReasoningText(delta);
+  if (reasoningText) {
     startReasoning(state, emit, idx);
-    emitReasoningDelta(state, emit, delta.reasoning_content);
+    emitReasoningDelta(state, emit, reasoningText);
   }
 
   // Handle text content
@@ -121,7 +127,7 @@ function startReasoning(state, emit, idx) {
     emit("response.output_item.added", {
       type: "response.output_item.added",
       output_index: idx,
-      item: { id: state.reasoningId, type: "reasoning", summary: [] }
+      item: { id: state.reasoningId, type: RESPONSES_ITEM.REASONING, summary: [] }
     });
 
     emit("response.reasoning_summary_part.added", {
@@ -129,7 +135,7 @@ function startReasoning(state, emit, idx) {
       item_id: state.reasoningId,
       output_index: idx,
       summary_index: 0,
-      part: { type: "summary_text", text: "" }
+      part: { type: RESPONSES_ITEM.SUMMARY_TEXT, text: "" }
     });
     state.reasoningPartAdded = true;
   }
@@ -164,7 +170,7 @@ function closeReasoning(state, emit) {
       item_id: state.reasoningId,
       output_index: state.reasoningIndex,
       summary_index: 0,
-      part: { type: "summary_text", text: state.reasoningBuf }
+      part: { type: RESPONSES_ITEM.SUMMARY_TEXT, text: state.reasoningBuf }
     });
 
     emit("response.output_item.done", {
@@ -172,8 +178,8 @@ function closeReasoning(state, emit) {
       output_index: state.reasoningIndex,
       item: {
         id: state.reasoningId,
-        type: "reasoning",
-        summary: [{ type: "summary_text", text: state.reasoningBuf }]
+        type: RESPONSES_ITEM.REASONING,
+        summary: [{ type: RESPONSES_ITEM.SUMMARY_TEXT, text: state.reasoningBuf }]
       }
     });
   }
@@ -187,7 +193,7 @@ function emitTextContent(state, emit, idx, content) {
     emit("response.output_item.added", {
       type: "response.output_item.added",
       output_index: idx,
-      item: { id: msgId, type: "message", content: [], role: "assistant" }
+      item: { id: msgId, type: RESPONSES_ITEM.MESSAGE, content: [], role: ROLE.ASSISTANT }
     });
   }
 
@@ -199,7 +205,7 @@ function emitTextContent(state, emit, idx, content) {
       item_id: `msg_${state.responseId}_${idx}`,
       output_index: idx,
       content_index: 0,
-      part: { type: "output_text", annotations: [], logprobs: [], text: "" }
+      part: { type: RESPONSES_ITEM.OUTPUT_TEXT, annotations: [], logprobs: [], text: "" }
     });
   }
 
@@ -236,7 +242,7 @@ function closeMessage(state, emit, idx) {
       item_id: msgId,
       output_index: parseInt(idx),
       content_index: 0,
-      part: { type: "output_text", annotations: [], logprobs: [], text: fullText }
+      part: { type: RESPONSES_ITEM.OUTPUT_TEXT, annotations: [], logprobs: [], text: fullText }
     });
 
     emit("response.output_item.done", {
@@ -244,9 +250,9 @@ function closeMessage(state, emit, idx) {
       output_index: parseInt(idx),
       item: {
         id: msgId,
-        type: "message",
-        content: [{ type: "output_text", annotations: [], logprobs: [], text: fullText }],
-        role: "assistant"
+        type: RESPONSES_ITEM.MESSAGE,
+        content: [{ type: RESPONSES_ITEM.OUTPUT_TEXT, annotations: [], logprobs: [], text: fullText }],
+        role: ROLE.ASSISTANT
       }
     });
   }
@@ -267,7 +273,7 @@ function emitToolCall(state, emit, tc) {
       output_index: tcIdx,
       item: {
         id: `fc_${newCallId}`,
-        type: "function_call",
+        type: RESPONSES_ITEM.FUNCTION_CALL,
         arguments: "",
         call_id: newCallId,
         name: state.funcNames[tcIdx] || ""
@@ -308,7 +314,7 @@ function closeToolCall(state, emit, idx) {
       output_index: parseInt(idx),
       item: {
         id: `fc_${callId}`,
-        type: "function_call",
+        type: RESPONSES_ITEM.FUNCTION_CALL,
         arguments: args,
         call_id: callId,
         name: state.funcNames[idx] || ""
@@ -359,8 +365,8 @@ function flushEvents(state) {
   // can still finalize as tool_calls even if the tool call was emitted before stream end.
 function computeFinishReason(state) {
    return state.toolCallIndex > 0 || state.currentToolCallId
-    ? "tool_calls"
-    : "stop";
+    ? OPENAI_FINISH.TOOL_CALLS
+    : OPENAI_FINISH.STOP;
 }
 
 /**
@@ -377,17 +383,11 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
     state.finishReasonSent = true;
     state.finishReason = finishReason;
 
-    const finalChunk = {
-      id: state.chatId || `chatcmpl-${Date.now()}`,
-      object: "chat.completion.chunk",
-      created: state.created || Math.floor(Date.now() / 1000),
-      model: state.model || "unknown",
-      choices: [{
-        index: 0,
-        delta: {},
-        finish_reason: finishReason
-      }]
-    };
+    const finalChunk = buildChunk(
+      { id: state.chatId || `chatcmpl-${Date.now()}`, created: state.created || Math.floor(Date.now() / 1000), model: state.model || MODEL_FALLBACK },
+      {},
+      finishReason
+    );
 
     if (state.usage && typeof state.usage === "object") {
       finalChunk.usage = state.usage;
@@ -414,17 +414,10 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
     const delta = data.delta || "";
     if (!delta) return null;
 
-    return {
-      id: state.chatId,
-      object: "chat.completion.chunk",
-      created: state.created,
-      model: state.model || "unknown",
-      choices: [{
-        index: 0,
-        delta: { content: delta },
-        finish_reason: null
-      }]
-    };
+    return buildChunk(
+      { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+      { content: delta }
+    );
   }
 
   // Text content done (ignore, we handle via delta)
@@ -433,31 +426,21 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
   }
 
   // Function call started (standard function_call or custom_tool_call)
-  if (eventType === "response.output_item.added" && (data.item?.type === "function_call" || data.item?.type === "custom_tool_call")) {
+  if (eventType === "response.output_item.added" && (data.item?.type === RESPONSES_ITEM.FUNCTION_CALL || data.item?.type === "custom_tool_call")) {
     const item = data.item;
-    state.currentToolCallId = item.call_id || `call_${Date.now()}`;
-
-    return {
-      id: state.chatId,
-      object: "chat.completion.chunk",
-      created: state.created,
-      model: state.model || "unknown",
-      choices: [{
-        index: 0,
-        delta: {
-          tool_calls: [{
-            index: state.toolCallIndex,
-            id: state.currentToolCallId,
-            type: "function",
-            function: {
-              name: item.name || "",
-              arguments: ""
-            }
-          }]
-        },
-        finish_reason: null
-      }]
-    };
+    state.currentToolCallId = item.call_id || fallbackToolCallId();
+
+    return buildChunk(
+      { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+      {
+        tool_calls: [{
+          index: state.toolCallIndex,
+          id: state.currentToolCallId,
+          type: OPENAI_BLOCK.FUNCTION,
+          function: { name: item.name || "", arguments: "" }
+        }]
+      }
+    );
   }
 
   // Function call arguments delta (standard or custom_tool_call variant)
@@ -465,26 +448,14 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
     const argsDelta = data.delta || "";
     if (!argsDelta) return null;
 
-    return {
-      id: state.chatId,
-      object: "chat.completion.chunk",
-      created: state.created,
-      model: state.model || "unknown",
-      choices: [{
-        index: 0,
-        delta: {
-          tool_calls: [{
-            index: state.toolCallIndex,
-            function: { arguments: argsDelta }
-          }]
-        },
-        finish_reason: null
-      }]
-    };
+    return buildChunk(
+      { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+      { tool_calls: [{ index: state.toolCallIndex, function: { arguments: argsDelta } }] }
+    );
   }
 
   // Function call done (standard or custom_tool_call variant)
-  if (eventType === "response.output_item.done" && (data.item?.type === "function_call" || data.item?.type === "custom_tool_call")) {
+  if (eventType === "response.output_item.done" && (data.item?.type === RESPONSES_ITEM.FUNCTION_CALL || data.item?.type === "custom_tool_call")) {
     state.toolCallIndex++;
     return null;
   }
@@ -500,18 +471,7 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
       // Cache info is in input_tokens_details.cached_tokens
       const cacheReadTokens = responseUsage.input_tokens_details?.cached_tokens || responseUsage.cache_read_input_tokens || 0;
       
-      state.usage = {
-        prompt_tokens: inputTokens,
-        completion_tokens: outputTokens,
-        total_tokens: inputTokens + outputTokens
-      };
-      
-      // Add prompt_tokens_details if cache tokens exist
-      if (cacheReadTokens > 0) {
-        state.usage.prompt_tokens_details = {
-          cached_tokens: cacheReadTokens
-        };
-      }
+      state.usage = buildUsage({ promptTokens: inputTokens, completionTokens: outputTokens, totalTokens: inputTokens + outputTokens, cachedTokens: cacheReadTokens });
     }
     
     if (!state.finishReasonSent) {
@@ -520,18 +480,12 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
       state.finishReasonSent = true;
       state.finishReason = finishReason; // Mark for usage injection in stream.js
       
-      const finalChunk = {
-        id: state.chatId,
-        object: "chat.completion.chunk",
-        created: state.created,
-        model: state.model || "unknown",
-        choices: [{
-          index: 0,
-          delta: {},
-          finish_reason: finishReason
-        }]
-      };
-      
+      const finalChunk = buildChunk(
+        { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+        {},
+        finishReason
+      );
+
       // Include usage in final chunk if available
       if (state.usage && typeof state.usage === "object") {
         finalChunk.usage = state.usage;
@@ -553,17 +507,11 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
       state.finishReasonSent = true;
 
       // Surface the error as an OpenAI-compatible error chunk
-      return {
-        id: state.chatId || `chatcmpl-${Date.now()}`,
-        object: "chat.completion.chunk",
-        created: state.created || Math.floor(Date.now() / 1000),
-        model: state.model || "unknown",
-        choices: [{
-          index: 0,
-          delta: { content: `[Error] ${error.message || JSON.stringify(error)}` },
-          finish_reason: "stop"
-        }]
-      };
+      return buildChunk(
+        { id: state.chatId || `chatcmpl-${Date.now()}`, created: state.created || Math.floor(Date.now() / 1000), model: state.model || MODEL_FALLBACK },
+        { content: `[Error] ${error.message || JSON.stringify(error)}` },
+        OPENAI_FINISH.STOP
+      );
     }
     return null;
   }
@@ -572,13 +520,10 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
   if (eventType === "response.reasoning_summary_text.delta") {
     const delta = data.delta || "";
     if (!delta) return null;
-    return {
-      id: state.chatId,
-      object: "chat.completion.chunk",
-      created: state.created,
-      model: state.model || "unknown",
-      choices: [{ index: 0, delta: { reasoning_content: delta }, finish_reason: null }]
-    };
+    return buildChunk(
+      { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+      reasoningDelta(delta)
+    );
   }
 
   // Ignore other events

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

@@ -1,5 +1,6 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
+import { GEMINI_ROLE, OPENAI_FINISH, GEMINI_FINISH } from "../schema/index.js";
 
 // Convert OpenAI SSE chunk to Antigravity SSE format
 // Real Antigravity format:
@@ -79,17 +80,17 @@ export function openaiToAntigravityResponse(chunk, state) {
   }
 
   // Build candidate
-  const candidate = { content: { role: "model", parts } };
+  const candidate = { content: { role: GEMINI_ROLE.MODEL, parts } };
 
   // Finish reason mapping
   if (finishReason) {
     const reasonMap = {
-      "stop": "STOP",
-      "length": "MAX_TOKENS",
-      "tool_calls": "STOP",
-      "content_filter": "SAFETY"
+      [OPENAI_FINISH.STOP]: GEMINI_FINISH.STOP,
+      [OPENAI_FINISH.LENGTH]: GEMINI_FINISH.MAX_TOKENS,
+      [OPENAI_FINISH.TOOL_CALLS]: GEMINI_FINISH.STOP,
+      [OPENAI_FINISH.CONTENT_FILTER]: GEMINI_FINISH.SAFETY
     };
-    candidate.finishReason = reasonMap[finishReason] || "STOP";
+    candidate.finishReason = reasonMap[finishReason] || GEMINI_FINISH.STOP;
   }
 
   // Build response