@fudrouter/fsrouter 0.6.64 → 0.6.65

package/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/open-sse/translator/response/kiro-to-openai.js

@@ -0,0 +1,160 @@
+/**
+ * Kiro to OpenAI Response Translator
+ * Converts Kiro/AWS CodeWhisperer streaming events to OpenAI SSE format
+ */
+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 kiroToOpenAIResponse(chunk, state) {
+  
+  if (!chunk) return null;
+
+  // If chunk is already in OpenAI format (from executor transform), return as-is
+  if (chunk.object === "chat.completion.chunk" && chunk.choices) {
+    return chunk;
+  }
+  
+  // Handle string chunk (raw SSE data)
+  let data = chunk;
+  if (typeof chunk === "string") {
+    // Parse SSE format: event:xxx\ndata:xxx
+    const lines = chunk.split("\n");
+    let eventType = "";
+    let eventData = "";
+
+    for (const line of lines) {
+      if (line.startsWith("event:")) {
+        eventType = line.slice(6).trim();
+      } else if (line.startsWith(":event-type:")) {
+        eventType = line.slice(12).trim();
+      } else if (line.startsWith("data:")) {
+        eventData = line.slice(5).trim();
+      } else if (line.startsWith(":content-type:")) {
+        // Skip content-type header
+      } else if (line.trim() && !line.startsWith(":")) {
+        // Raw JSON data
+        eventData = line.trim();
+      }
+    }
+
+    if (!eventData) return null;
+
+    try {
+      data = JSON.parse(eventData);
+      data._eventType = eventType;
+    } catch {
+      // Not JSON, might be raw text
+      data = { text: eventData, _eventType: eventType };
+    }
+  }
+
+  // Initialize state if needed
+  if (!state.responseId) {
+    state.responseId = `chatcmpl-${Date.now()}`;
+    state.created = Math.floor(Date.now() / 1000);
+    state.chunkIndex = 0;
+  }
+
+  const eventType = data._eventType || data.event || "";
+
+  // Handle different Kiro event types
+  if (eventType === "assistantResponseEvent" || data.assistantResponseEvent) {
+    const content = data.assistantResponseEvent?.content || data.content || "";
+    if (!content) return null;
+
+    const openaiChunk = buildChunk(chunkMeta(state), {
+      ...(state.chunkIndex === 0 ? { role: ROLE.ASSISTANT } : {}),
+      content: content
+    }, null);
+
+    state.chunkIndex++;
+    return openaiChunk;
+  }
+
+  // Handle reasoning/thinking events.
+  // Kiro emits reasoningContentEvent when the request enabled thinking via
+  // the <thinking_mode>enabled</thinking_mode> system-prompt tag. We surface
+  // this as OpenAI delta.reasoning_content so downstream translators can map
+  // it to Claude thinking blocks / Anthropic reasoning / etc.
+  if (eventType === "reasoningContentEvent" || data.reasoningContentEvent) {
+    const reasoning = data.reasoningContentEvent || data;
+    const content = (typeof reasoning === "string")
+      ? reasoning
+      : (reasoning.text || reasoning.content || data.content || "");
+    if (!content) return null;
+
+    const openaiChunk = buildChunk(chunkMeta(state), reasoningDelta(content, state.chunkIndex === 0), null);
+
+    state.chunkIndex++;
+    return openaiChunk;
+  }
+
+  // Handle tool use events
+  if (eventType === "toolUseEvent" || data.toolUseEvent) {
+    state.hadToolUse = true;
+    const toolUse = data.toolUseEvent || data;
+    const toolCallId = toolUse.toolUseId || fallbackToolCallId();
+    const toolName = toolUse.name || "";
+    const toolInput = toolUse.input || {};
+
+    const openaiChunk = buildChunk(chunkMeta(state), {
+      ...(state.chunkIndex === 0 ? { role: ROLE.ASSISTANT } : {}),
+      tool_calls: [{
+        index: 0,
+        id: toolCallId,
+        type: OPENAI_BLOCK.FUNCTION,
+        function: {
+          name: toolName,
+          arguments: JSON.stringify(toolInput)
+        }
+      }]
+    }, null);
+
+    state.chunkIndex++;
+    return openaiChunk;
+  }
+
+  // Handle completion/done events
+  if (eventType === "messageStopEvent" || eventType === "done" || data.messageStopEvent) {
+    // 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") {
+      openaiChunk.usage = state.usage;
+    }
+
+    return openaiChunk;
+  }
+
+// Handle usage events
+  if (eventType === "usageEvent" || data.usageEvent) {
+    const usage = toOpenAIUsage(data.usageEvent || data, "kiro");
+    if (usage) state.usage = usage;
+    return null;
+  }
+
+  // Unknown event type - skip
+  return null;
+}
+
+// Register translator
+register(FORMATS.KIRO, FORMATS.OPENAI, null, kiroToOpenAIResponse);

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

@@ -0,0 +1,134 @@
+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
+ *
+ * Ollama response format:
+ * {"model": "...", "message": {"role": "assistant", "content": "..."}, "done": false}
+ * {"model": "...", "done": true, "prompt_eval_count": 123, "eval_count": 456}
+ *
+ * OpenAI format:
+ * {"id": "...", "object": "chat.completion.chunk", "created": 123, "model": "...",
+ *  "choices": [{"index": 0, "delta": {"content": "..."}, "finish_reason": null}]}
+ */
+export function ollamaToOpenAIResponse(chunk, state) {
+  if (!chunk || typeof chunk !== "object") return null;
+
+  // Initialize state on first chunk
+  if (!state.ollama) {
+    state.ollama = {
+      id: `chatcmpl-${Date.now()}`,
+      created: Math.floor(Date.now() / 1000),
+      model: chunk.model || state.model
+    };
+  }
+
+  const { id, created, model } = state.ollama;
+
+  // Final chunk with done=true
+  if (chunk.done) {
+    const usage = extractUsage(chunk);
+    
+    // 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;
+    }
+
+    const doneChunk = buildChunk({ id, created, model }, {}, finishReason);
+    doneChunk.usage = usage;
+    return doneChunk;
+  }
+
+  // Content chunk
+  const message = chunk.message;
+  if (!message) return null;
+
+  const content = typeof message.content === "string" ? message.content : "";
+  const thinking = typeof message.thinking === "string" ? message.thinking : "";
+  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : null;
+
+  // Skip empty chunks
+  if (!content && !thinking && !toolCalls) return null;
+
+  // Accumulate content in state
+  if (content) {
+    state.accumulatedContent = (state.accumulatedContent || "") + content;
+  }
+  if (thinking) {
+    state.accumulatedThinking = (state.accumulatedThinking || "") + thinking;
+  }
+
+  const delta = {};
+  if (content) delta.content = content;
+  if (thinking) delta.reasoning_content = thinking;
+  
+  // Convert Ollama tool_calls to OpenAI format
+  if (toolCalls) {
+    state.hadToolCalls = true;
+    delta.tool_calls = convertToolCalls(toolCalls);
+  }
+
+  return buildChunk({ id, created, model }, delta, null);
+}
+
+/**
+ * Extract usage stats from Ollama response
+ */
+function extractUsage(ollamaChunk) {
+  return toOpenAIUsage(ollamaChunk, "ollama");
+}
+
+/**
+ * Convert tool_calls from Ollama format to OpenAI format
+ */
+function convertToolCalls(toolCalls) {
+  return toolCalls.map((tc, i) => ({
+    index: tc.function?.index ?? i,
+    id: tc.id || fallbackToolCallId(i),
+    type: OPENAI_BLOCK.FUNCTION,
+    function: {
+      name: tc.function?.name || "",
+      arguments: typeof tc.function?.arguments === "string"
+        ? tc.function.arguments
+        : JSON.stringify(tc.function?.arguments || {})
+    }
+  }));
+}
+
+/**
+ * Convert Ollama non-streaming response body to OpenAI chat.completion format
+ */
+export function ollamaBodyToOpenAI(body) {
+  const msg = body.message || {};
+  const content = msg.content || "";
+  const thinking = msg.thinking || "";
+  const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+
+  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 = toOpenAIFinish(body.done_reason, "ollama");
+  if (toolCalls.length > 0) finishReason = OPENAI_FINISH.TOOL_CALLS;
+
+  return {
+    id: `chatcmpl-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model: body.model || "ollama",
+    choices: [{ index: 0, message, finish_reason: finishReason }],
+    usage: extractUsage(body)
+  };
+}
+
+// Register translator
+register(FORMATS.OLLAMA, FORMATS.OPENAI, null, ollamaToOpenAIResponse);