n9router 0.4.44 → 0.4.45

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

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

@@ -0,0 +1,261 @@
+/**
+ * Kiro → Claude Response Translator (DIRECT route, no OpenAI pivot)
+ *
+ * IMPORTANT: This translator does NOT receive raw Kiro AWS-EventStream frames.
+ * KiroExecutor.transformEventStreamToSSE() (open-sse/executors/kiro.js) already
+ * parses the binary EventStream and emits OpenAI-shaped
+ * `chat.completion.chunk` objects. So the chunks arriving here are OpenAI
+ * streaming chunks, and our job is OpenAI-chunk → Claude SSE events — the same
+ * transformation openai-to-claude.js performs. We re-implement it here so the
+ * direct `kiro:claude` route is self-contained and lossless (reasoning_content
+ * → thinking blocks, tool_calls → tool_use blocks, usage → message_delta).
+ *
+ * Registered on the direct route by ../index.js; reached only when source
+ * format is Claude and target is Kiro.
+ */
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+
+function stopThinkingBlock(state, results) {
+  if (!state.thinkingBlockStarted) return;
+  results.push({ type: "content_block_stop", index: state.thinkingBlockIndex });
+  state.thinkingBlockStarted = false;
+}
+
+function stopTextBlock(state, results) {
+  if (!state.textBlockStarted || state.textBlockClosed) return;
+  state.textBlockClosed = true;
+  results.push({ type: "content_block_stop", index: state.textBlockIndex });
+  state.textBlockStarted = false;
+}
+
+function convertFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "length":
+      return "max_tokens";
+    case "tool_calls":
+      return "tool_use";
+    default:
+      return "end_turn";
+  }
+}
+
+/**
+ * Convert one OpenAI-format chunk (from KiroExecutor) into Claude SSE events.
+ * Returns an array of Claude events, or null when the chunk yields nothing.
+ */
+export function kiroToClaudeResponse(chunk, state) {
+  // KiroExecutor emits chat.completion.chunk objects; tolerate string chunks
+  // by attempting a parse (defensive — the direct path is always objects).
+  let data = chunk;
+  if (typeof chunk === "string") {
+    const trimmed = chunk.trim();
+    if (!trimmed || trimmed === "[DONE]") return null;
+    try {
+      data = JSON.parse(trimmed.startsWith("data:") ? trimmed.slice(5).trim() : trimmed);
+    } catch {
+      return null;
+    }
+  }
+
+  if (!data || !data.choices?.[0]) return null;
+
+  const results = [];
+  const choice = data.choices[0];
+  const delta = choice.delta || {};
+
+  // Track usage if present on the chunk.
+  if (data.usage && typeof data.usage === "object") {
+    const promptTokens =
+      typeof data.usage.prompt_tokens === "number" ? data.usage.prompt_tokens : 0;
+    const outputTokens =
+      typeof data.usage.completion_tokens === "number"
+        ? data.usage.completion_tokens
+        : 0;
+    state.usage = { input_tokens: promptTokens, output_tokens: outputTokens };
+  }
+
+  // First chunk → emit message_start.
+  if (!state.messageStartSent) {
+    state.messageStartSent = true;
+    state.messageId =
+      (typeof data.id === "string" && data.id.replace("chatcmpl-", "")) ||
+      `msg_${Date.now()}`;
+    state.model = data.model || "kiro";
+    state.nextBlockIndex = 0;
+    results.push({
+      type: "message_start",
+      message: {
+        id: state.messageId,
+        type: "message",
+        role: "assistant",
+        model: state.model,
+        content: [],
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+      },
+    });
+  }
+
+  // Reasoning / thinking content (Kiro reasoningContentEvent → reasoning_content).
+  const reasoningContent = delta.reasoning_content || delta.reasoning;
+  if (reasoningContent) {
+    stopTextBlock(state, results);
+    if (!state.thinkingBlockStarted) {
+      state.thinkingBlockIndex = state.nextBlockIndex++;
+      state.thinkingBlockStarted = true;
+      results.push({
+        type: "content_block_start",
+        index: state.thinkingBlockIndex,
+        content_block: { type: "thinking", thinking: "" },
+      });
+    }
+    results.push({
+      type: "content_block_delta",
+      index: state.thinkingBlockIndex,
+      delta: { type: "thinking_delta", thinking: reasoningContent },
+    });
+  }
+
+  // Regular text content.
+  if (delta.content) {
+    stopThinkingBlock(state, results);
+    if (!state.textBlockStarted) {
+      state.textBlockIndex = state.nextBlockIndex++;
+      state.textBlockStarted = true;
+      state.textBlockClosed = false;
+      results.push({
+        type: "content_block_start",
+        index: state.textBlockIndex,
+        content_block: { type: "text", text: "" },
+      });
+    }
+    results.push({
+      type: "content_block_delta",
+      index: state.textBlockIndex,
+      delta: { type: "text_delta", text: delta.content },
+    });
+  }
+
+  // Tool calls.
+  if (delta.tool_calls) {
+    if (!state.toolCalls) state.toolCalls = new Map();
+    if (!state.toolArgBuffers) state.toolArgBuffers = new Map();
+    for (const tc of delta.tool_calls) {
+      const idx = tc.index ?? 0;
+      if (tc.id) {
+        stopThinkingBlock(state, results);
+        stopTextBlock(state, results);
+        const toolBlockIndex = state.nextBlockIndex++;
+        state.toolCalls.set(idx, {
+          id: tc.id,
+          name: tc.function?.name || "",
+          blockIndex: toolBlockIndex,
+        });
+        results.push({
+          type: "content_block_start",
+          index: toolBlockIndex,
+          content_block: {
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function?.name || "",
+            input: {},
+          },
+        });
+      }
+      if (tc.function?.arguments) {
+        const toolInfo = state.toolCalls.get(idx);
+        if (toolInfo) {
+          state.toolArgBuffers.set(
+            idx,
+            (state.toolArgBuffers.get(idx) || "") + tc.function.arguments
+          );
+        }
+      }
+    }
+  }
+
+  // Finish.
+  if (choice.finish_reason) {
+    stopThinkingBlock(state, results);
+    stopTextBlock(state, results);
+
+    if (state.toolCalls) {
+      for (const [idx, toolInfo] of state.toolCalls) {
+        const buffered = state.toolArgBuffers?.get(idx);
+        if (buffered) {
+          results.push({
+            type: "content_block_delta",
+            index: toolInfo.blockIndex,
+            delta: { type: "input_json_delta", partial_json: buffered },
+          });
+        }
+        results.push({ type: "content_block_stop", index: toolInfo.blockIndex });
+      }
+    }
+
+    state.finishReason = choice.finish_reason;
+    const finalUsage = state.usage || { input_tokens: 0, output_tokens: 0 };
+    results.push({
+      type: "message_delta",
+      delta: { stop_reason: convertFinishReason(choice.finish_reason) },
+      usage: finalUsage,
+    });
+    results.push({ type: "message_stop" });
+  }
+
+  return results.length > 0 ? results : null;
+}
+
+/**
+ * Non-streaming Kiro → Claude. KiroExecutor only produces a stream, so this is
+ * a defensive helper for any non-streaming caller that hands us an aggregated
+ * OpenAI-shaped completion.
+ */
+export function kiroToClaudeNonStreaming(data) {
+  const content = [];
+  const choice = data?.choices?.[0];
+  const message = choice?.message || {};
+
+  if (message.content) {
+    content.push({ type: "text", text: message.content });
+  }
+  if (Array.isArray(message.tool_calls)) {
+    for (const tc of message.tool_calls) {
+      let input = {};
+      try {
+        input =
+          typeof tc.function?.arguments === "string"
+            ? JSON.parse(tc.function.arguments)
+            : tc.function?.arguments || {};
+      } catch {
+        input = {};
+      }
+      content.push({
+        type: "tool_use",
+        id: tc.id || `toolu_${Date.now()}`,
+        name: tc.function?.name || "",
+        input,
+      });
+    }
+  }
+
+  const usage = data?.usage || {};
+  return {
+    id: `msg_${Date.now()}`,
+    type: "message",
+    role: "assistant",
+    content,
+    model: data?.model || "kiro",
+    stop_reason: convertFinishReason(choice?.finish_reason || "stop"),
+    usage: {
+      input_tokens: usage.prompt_tokens || 0,
+      output_tokens: usage.completion_tokens || 0,
+    },
+  };
+}
+
+register(FORMATS.KIRO, FORMATS.CLAUDE, null, kiroToClaudeResponse);