n9router 0.4.44 → 0.4.45

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

@@ -5,12 +5,17 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
 import { v4 as uuidv4 } from "uuid";
+import { resolveSessionId } from "../../utils/sessionManager.js";
 import {
   resolveKiroModel,
-  isThinkingEnabled,
+  resolveKiroThinkingBudget,
   buildThinkingSystemPrefix,
-  KIRO_AGENTIC_SYSTEM_PROMPT
+  KIRO_AGENTIC_SYSTEM_PROMPT,
+  resolveDefaultProfileArn
 } from "../../config/kiroConstants.js";
+import { parseDataUri } from "../concerns/image.js";
+import { DEFAULT_IMAGE_MIME } from "../schema/index.js";
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK } from "../schema/index.js";
 
 /** Render a single tool call as a readable text line. */
 function toolCallToText(name, input) {
@@ -54,18 +59,18 @@ function flattenToolInteractions(messages) {
 
   for (const msg of messages) {
     // OpenAI tool-result message → user text line
-    if (msg.role === "tool") {
-      out.push({ role: "user", content: toolResultToText(msg.content) });
+    if (msg.role === ROLE.TOOL) {
+      out.push({ role: ROLE.USER, content: toolResultToText(msg.content) });
       continue;
     }
 
-    if (msg.role === "assistant") {
+    if (msg.role === ROLE.ASSISTANT) {
       const parts = [];
       if (Array.isArray(msg.content)) {
         for (const c of msg.content) {
-          if (c.type === "tool_use") {
+          if (c.type === CLAUDE_BLOCK.TOOL_USE) {
             parts.push(toolCallToText(c.name, c.input));
-          } else if (c.type === "text" || c.text) {
+          } else if (c.type === OPENAI_BLOCK.TEXT || c.text) {
             parts.push(c.text || "");
           }
         }
@@ -75,15 +80,15 @@ function flattenToolInteractions(messages) {
       for (const tc of msg.tool_calls || []) {
         parts.push(toolCallToText(tc.function?.name, tc.function?.arguments));
       }
-      out.push({ role: "assistant", content: parts.filter(Boolean).join("\n") });
+      out.push({ role: ROLE.ASSISTANT, content: parts.filter(Boolean).join("\n") });
       continue;
     }
 
     // User messages: replace tool_result blocks with text, keep text + images.
-    if (msg.role === "user" && Array.isArray(msg.content)) {
+    if (msg.role === ROLE.USER && Array.isArray(msg.content)) {
       const newContent = msg.content.map(c =>
-        c.type === "tool_result"
-          ? { type: "text", text: toolResultToText(c.content) }
+        c.type === CLAUDE_BLOCK.TOOL_RESULT
+          ? { type: OPENAI_BLOCK.TEXT, text: toolResultToText(c.content) }
           : c
       );
       out.push({ ...msg, content: newContent });
@@ -265,8 +270,8 @@ function convertMessages(messages, tools, model) {
     let role = msg.role;
 
     // Normalize: system/tool -> user
-    if (role === "system" || role === "tool") {
-      role = "user";
+    if (role === ROLE.SYSTEM || role === ROLE.TOOL) {
+      role = ROLE.USER;
     }
 
     // If role changes, flush pending
@@ -275,7 +280,7 @@ function convertMessages(messages, tools, model) {
     }
     currentRole = role;
 
-    if (role === "user") {
+    if (role === ROLE.USER) {
       // Extract content
       let content = "";
       if (typeof msg.content === "string") {
@@ -283,24 +288,23 @@ function convertMessages(messages, tools, model) {
       } else if (Array.isArray(msg.content)) {
         const textParts = [];
         for (const c of msg.content) {
-          if (c.type === "text" || c.text) {
+          if (c.type === OPENAI_BLOCK.TEXT || c.text) {
             textParts.push(c.text || "");
-          } else if (c.type === "image_url") {
+          } else if (c.type === OPENAI_BLOCK.IMAGE_URL) {
             // OpenAI format: image_url.url with data URI
             const url = c.image_url?.url || "";
-            const base64Match = url.match(/^data:([^;]+);base64,(.+)$/);
-            if (base64Match) {
-              const mediaType = base64Match[1];
-              const format = mediaType.split("/")[1] || mediaType;
-              pendingImages.push({ format, source: { bytes: base64Match[2] } });
+            const parsed = parseDataUri(url);
+            if (parsed) {
+              const format = parsed.mimeType.split("/")[1] || parsed.mimeType;
+              pendingImages.push({ format, source: { bytes: parsed.base64 } });
             } else if (url.startsWith("http://") || url.startsWith("https://")) {
               // Kiro only supports base64 — fallback to URL text
               textParts.push(`[Image: ${url}]`);
             }
-          } else if (c.type === "image") {
+          } else if (c.type === CLAUDE_BLOCK.IMAGE) {
             // Claude format: source.type = "base64", source.media_type, source.data
             if (c.source?.type === "base64" && c.source?.data) {
-              const mediaType = c.source.media_type || "image/png";
+              const mediaType = c.source.media_type || DEFAULT_IMAGE_MIME;
               const format = mediaType.split("/")[1] || mediaType;
               pendingImages.push({ format, source: { bytes: c.source.data } });
             }
@@ -309,7 +313,7 @@ function convertMessages(messages, tools, model) {
         content = textParts.join("\n");
 
         // Check for tool_result blocks
-        const toolResultBlocks = msg.content.filter(c => c.type === "tool_result");
+        const toolResultBlocks = msg.content.filter(c => c.type === CLAUDE_BLOCK.TOOL_RESULT);
         if (toolResultBlocks.length > 0) {
           toolResultBlocks.forEach(block => {
             const text = Array.isArray(block.content)
@@ -326,7 +330,7 @@ function convertMessages(messages, tools, model) {
       }
 
       // Handle tool role (from normalized)
-      if (msg.role === "tool") {
+      if (msg.role === ROLE.TOOL) {
         const toolContent = typeof msg.content === "string" ? msg.content : "";
         pendingToolResults.push({
           toolUseId: msg.tool_call_id,
@@ -336,16 +340,16 @@ function convertMessages(messages, tools, model) {
       } else if (content) {
         pendingUserContent.push(content);
       }
-    } else if (role === "assistant") {
+    } else if (role === ROLE.ASSISTANT) {
       // Extract text content and tool uses
       let textContent = "";
       let toolUses = [];
 
       if (Array.isArray(msg.content)) {
-        const textBlocks = msg.content.filter(c => c.type === "text");
+        const textBlocks = msg.content.filter(c => c.type === OPENAI_BLOCK.TEXT);
         textContent = textBlocks.map(b => b.text).join("\n").trim();
 
-        const toolUseBlocks = msg.content.filter(c => c.type === "tool_use");
+        const toolUseBlocks = msg.content.filter(c => c.type === CLAUDE_BLOCK.TOOL_USE);
         toolUses = toolUseBlocks;
       } else if (typeof msg.content === "string") {
         textContent = msg.content.trim();
@@ -508,19 +512,35 @@ function convertMessages(messages, tools, model) {
  *    `thinking`, OpenAI `reasoning_effort`, AMP/Cursor magic tags, and model
  *    name hints.
  */
-export function buildKiroPayload(model, body, stream, credentials) {
+export function openaiToKiroRequest(model, body, stream, credentials) {
   const messages = body.messages || [];
   const tools = body.tools || [];
   const maxTokens = 32000;
   const temperature = body.temperature;
   const topP = body.top_p;
 
-  const { upstream: upstreamModel, agentic, thinking: modelImpliesThinking } = resolveKiroModel(model);
-  const thinkingEnabled = modelImpliesThinking || isThinkingEnabled(body, null, model);
+  const { upstream: upstreamModel, agentic } = resolveKiroModel(model);
+  const thinkingBudget = resolveKiroThinkingBudget(body, credentials?.rawHeaders, model);
 
   const { history, currentMessage } = convertMessages(messages, tools, upstreamModel);
 
-  const profileArn = credentials?.providerSpecificData?.profileArn || "";
+  // API-key (headless) auth uses a raw CodeWhisperer credential whose profile is
+  // account-specific. Injecting the shared builder-id/social *default* placeholder
+  // ARN makes CodeWhisperer reject the request with 403 "bearer token invalid"
+  // (the ARN doesn't belong to the key's account). So for api_key, only send a
+  // profileArn that was actually resolved for this connection — never the default.
+  // OAuth/social keep the default fallback (their tokens accept it).
+  // api_key / idc / external_idp carry an account-specific (or token-bound)
+  // profile. The shared builder-id/social default ARN belongs to a different
+  // account and triggers 403 "bearer token invalid", so never fall back to it —
+  // send the resolved ARN, or an empty string so CodeWhisperer uses the token's
+  // own default profile. Only OAuth/social keep the shared placeholder.
+  const authMethod = credentials?.providerSpecificData?.authMethod;
+  const accountBoundAuth =
+    authMethod === "api_key" || authMethod === "idc" || authMethod === "external_idp";
+  const profileArn = accountBoundAuth
+    ? (credentials?.providerSpecificData?.profileArn || "")
+    : (credentials?.providerSpecificData?.profileArn || resolveDefaultProfileArn(authMethod));
 
   let finalContent = currentMessage?.userInputMessage?.content || "";
 
@@ -530,8 +550,8 @@ export function buildKiroPayload(model, body, stream, credentials) {
   // Order: thinking_mode tag first (so Kiro sees it before any user text),
   // then context/timestamp marker, then optional agentic chunked-write prompt.
   const prefixParts = [];
-  if (thinkingEnabled) {
-    prefixParts.push(buildThinkingSystemPrefix());
+  if (thinkingBudget !== null) {
+    prefixParts.push(buildThinkingSystemPrefix(thinkingBudget));
   }
   prefixParts.push(`[Context: Current time is ${timestamp}]`);
   if (agentic) {
@@ -542,7 +562,7 @@ export function buildKiroPayload(model, body, stream, credentials) {
   const payload = {
     conversationState: {
       chatTriggerType: "MANUAL",
-      conversationId: uuidv4(),
+      conversationId: resolveSessionId({ headers: credentials?.rawHeaders, body, connectionId: credentials?.connectionId, scope: "kiro" }),
       currentMessage: {
         userInputMessage: {
           content: finalContent,
@@ -580,4 +600,4 @@ export function buildKiroPayload(model, body, stream, credentials) {
   return payload;
 }
 
-register(FORMATS.OPENAI, FORMATS.KIRO, buildKiroPayload, null);
+register(FORMATS.OPENAI, FORMATS.KIRO, openaiToKiroRequest, null);

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

@@ -1,5 +1,8 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
+import { parseDataUri } from "../concerns/image.js";
+import { safeParseJSON } from "../concerns/json.js";
+import { ROLE, OPENAI_BLOCK } from "../schema/index.js";
 
 /**
  * Convert OpenAI request to Ollama format
@@ -67,7 +70,7 @@ function normalizeMessages(messages) {
 
   // First pass: build tool_call_id -> tool_name map from assistant messages
   for (const msg of messages) {
-    if (msg.role === "assistant" && msg.tool_calls) {
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) {
       for (const tc of msg.tool_calls) {
         if (tc.id && tc.function?.name) {
           toolCallMap.set(tc.id, tc.function.name);
@@ -79,7 +82,7 @@ function normalizeMessages(messages) {
   // Second pass: convert messages
   for (const msg of messages) {
     // Handle tool result messages (OpenAI format -> Ollama format)
-    if (msg.role === "tool") {
+    if (msg.role === ROLE.TOOL) {
       const toolResult = normalizeContent(msg.content);
       if (!toolResult) continue;
 
@@ -87,7 +90,7 @@ function normalizeMessages(messages) {
       const toolName = toolCallMap.get(msg.tool_call_id) || msg.name || "unknown_tool";
 
       result.push({
-        role: "tool",
+        role: ROLE.TOOL,
         tool_name: toolName,
         content: toolResult
       });
@@ -95,23 +98,23 @@ function normalizeMessages(messages) {
     }
 
     // Handle assistant messages with tool_calls
-    if (msg.role === "assistant" && msg.tool_calls) {
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) {
       const content = normalizeContent(msg.content) || "";
       
       // Convert OpenAI tool_calls format to Ollama format
       const ollamaToolCalls = msg.tool_calls.map(tc => ({
-        type: "function",
+        type: OPENAI_BLOCK.FUNCTION,
         function: {
           index: tc.index || 0,
           name: tc.function?.name || "",
           arguments: typeof tc.function?.arguments === "string" 
-            ? JSON.parse(tc.function.arguments || "{}")
+            ? safeParseJSON(tc.function.arguments || "{}", {})
             : tc.function?.arguments || {}
         }
       }));
 
       result.push({
-        role: "assistant",
+        role: ROLE.ASSISTANT,
         content: content,
         tool_calls: ollamaToolCalls
       });
@@ -124,7 +127,7 @@ function normalizeMessages(messages) {
     const images = extractImagesFromContent(msg.content);
 
     // Skip empty messages (except assistant)
-    if (!content && role !== "assistant") continue;
+    if (!content && role !== ROLE.ASSISTANT) continue;
 
     const out = {
       role: role,
@@ -153,7 +156,7 @@ function normalizeContent(content) {
   if (Array.isArray(content)) {
     // Extract text from content array
     const textParts = content
-      .filter(block => block && block.type === "text" && block.text)
+      .filter(block => block && block.type === OPENAI_BLOCK.TEXT && block.text)
       .map(block => block.text);
 
     return textParts.join("\n") || "";
@@ -174,15 +177,15 @@ function extractImagesFromContent(content) {
   const images = [];
 
   for (const block of content) {
-    if (!block || block.type !== "image_url") continue;
+    if (!block || block.type !== OPENAI_BLOCK.IMAGE_URL) continue;
 
     const url = typeof block.image_url === "string" ? block.image_url : block.image_url?.url;
     if (typeof url !== "string" || !url) continue;
 
-    const m = url.match(/^data:[^;]+;base64,([\s\S]+)$/);
-    if (!m) continue;
+    const parsed = parseDataUri(url);
+    if (!parsed) continue;
 
-    images.push(m[1]);
+    images.push(parsed.base64);
   }
 
   return images;

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);