n9router 0.4.43 → 0.4.45

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

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