@fudrouter/fsrouter 0.6.63 → 0.6.64

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

@@ -1,261 +0,0 @@
-/**
- * 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

@@ -1,160 +0,0 @@
-/**
- * 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

@@ -1,134 +0,0 @@
-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);