@fudrouter/fsrouter 0.6.64 → 0.6.66

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

@@ -0,0 +1,278 @@
+/**
+ * OpenAI to Kiro Request Translator
+ * Converts OpenAI Chat Completions format to Kiro/AWS CodeWhisperer format
+ */
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { v4 as uuidv4 } from "uuid";
+
+/**
+ * Convert OpenAI messages to Kiro format
+ */
+function convertMessages(messages, tools, model) {
+  let history = [];
+  let currentMessage = null;
+  let systemPrompt = "";
+
+  const toolResultsMap = new Map();
+  
+  for (const msg of messages) {
+    if (msg.role === "tool" && msg.tool_call_id) {
+      const content = typeof msg.content === "string" ? msg.content : 
+        (Array.isArray(msg.content) ? msg.content.map(c => c.text || "").join("\n") : "");
+      toolResultsMap.set(msg.tool_call_id, content);
+    }
+    
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_result" && block.tool_use_id) {
+          const content = Array.isArray(block.content) 
+            ? block.content.map(c => c.text || "").join("\n")
+            : (typeof block.content === "string" ? block.content : "");
+          toolResultsMap.set(block.tool_use_id, content);
+        }
+      }
+    }
+  }
+
+  for (const msg of messages) {
+    const role = msg.role;
+    
+    if (role === "tool") continue;
+    
+    const content = typeof msg.content === "string" ? msg.content : 
+      (Array.isArray(msg.content) ? msg.content.map(c => c.text || "").join("\n") : "");
+
+    if (role === "system") {
+      systemPrompt += (systemPrompt ? "\n" : "") + content;
+      continue;
+    }
+
+    if (role === "user") {
+      let finalContent = content;
+      let toolResults = [];
+      
+      // Check if this user message contains tool_result blocks
+      if (Array.isArray(msg.content)) {
+        const toolResultBlocks = msg.content.filter(c => c.type === "tool_result");
+        if (toolResultBlocks.length > 0) {
+          toolResults = toolResultBlocks.map(block => {
+            const text = Array.isArray(block.content) 
+              ? block.content.map(c => c.text || "").join("\n")
+              : (typeof block.content === "string" ? block.content : "");
+            
+            return {
+              toolUseId: block.tool_use_id,
+              status: "success",
+              content: [{ text: text }]
+            };
+          });
+          
+          // Set simple content when tool results exist
+          finalContent = content || "Continue";
+        }
+      }
+      
+      const userMsg = {
+        userInputMessage: {
+          content: finalContent,
+          modelId: "",
+        }
+      };
+
+      // Add tool results to userInputMessageContext
+      if (toolResults.length > 0) {
+        if (!userMsg.userInputMessage.userInputMessageContext) {
+          userMsg.userInputMessage.userInputMessageContext = {};
+        }
+        userMsg.userInputMessage.userInputMessageContext.toolResults = toolResults;
+      }
+
+      // Add tools to first user message
+      if (tools && tools.length > 0 && history.length === 0) {
+        if (!userMsg.userInputMessage.userInputMessageContext) {
+          userMsg.userInputMessage.userInputMessageContext = {};
+        }
+        userMsg.userInputMessage.userInputMessageContext.tools = tools.map(t => {
+          const name = t.function?.name || t.name;
+          let description = t.function?.description || t.description || "";
+          
+          if (!description.trim()) {
+            description = `Tool: ${name}`;
+          }
+          
+          return {
+            toolSpecification: {
+              name,
+              description,
+              inputSchema: {
+                json: t.function?.parameters || t.parameters || t.input_schema || {}
+              }
+            }
+          };
+        });
+      }
+
+      currentMessage = userMsg;
+      history.push(userMsg);
+    }
+
+    if (role === "assistant") {
+      // Extract text content and tool uses separately from content array
+      let textContent = "";
+      let toolUses = [];
+      
+      if (Array.isArray(msg.content)) {
+        const textBlocks = msg.content.filter(c => c.type === "text");
+        textContent = textBlocks.map(b => b.text).join("\n").trim();
+        
+        const toolUseBlocks = msg.content.filter(c => c.type === "tool_use");
+        toolUses = toolUseBlocks;
+      } else if (typeof msg.content === "string") {
+        textContent = msg.content.trim();
+      }
+      
+      // Fallback for OpenAI tool_calls format
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        toolUses = msg.tool_calls;
+      }
+      
+      const assistantMsg = {
+        assistantResponseMessage: {
+          content: textContent || "Call tools"
+        }
+      };
+      
+      if (toolUses.length > 0) {
+        assistantMsg.assistantResponseMessage.toolUses = toolUses.map(tc => {
+          if (tc.function) {
+            // OpenAI format
+            return {
+              toolUseId: tc.id || uuidv4(),
+              name: tc.function.name,
+              input: typeof tc.function.arguments === "string" 
+                ? JSON.parse(tc.function.arguments) 
+                : (tc.function.arguments || {})
+            };
+          } else {
+            // Anthropic format
+            return {
+              toolUseId: tc.id || uuidv4(),
+              name: tc.name,
+              input: tc.input || {}
+            };
+          }
+        });
+      }
+
+      history.push(assistantMsg);
+    }
+  }
+  
+  // If last message in history is userInputMessage, use it as currentMessage
+  if (history.length > 0 && history[history.length - 1].userInputMessage) {
+    currentMessage = history.pop();
+  }
+
+  const firstHistoryItem = history[0];
+  if (firstHistoryItem?.userInputMessage?.userInputMessageContext?.tools && 
+      !currentMessage?.userInputMessage?.userInputMessageContext?.tools) {
+    if (!currentMessage.userInputMessage.userInputMessageContext) {
+      currentMessage.userInputMessage.userInputMessageContext = {};
+    }
+    currentMessage.userInputMessage.userInputMessageContext.tools = 
+      firstHistoryItem.userInputMessage.userInputMessageContext.tools;
+  }
+    
+  // Clean up history for Kiro API compatibility
+  history.forEach(item => {
+    if (item.userInputMessage?.userInputMessageContext?.tools) {
+      delete item.userInputMessage.userInputMessageContext.tools;
+    }
+    
+    if (item.userInputMessage?.userInputMessageContext && 
+        Object.keys(item.userInputMessage.userInputMessageContext).length === 0) {
+      delete item.userInputMessage.userInputMessageContext;
+    }
+    
+    if (item.userInputMessage && !item.userInputMessage.modelId) {
+      item.userInputMessage.modelId = model;
+    }
+  });
+  
+  // Merge consecutive user messages (Kiro requires alternating user/assistant)
+  const mergedHistory = [];
+  for (let i = 0; i < history.length; i++) {
+    const current = history[i];
+    
+    if (current.userInputMessage && 
+        mergedHistory.length > 0 && 
+        mergedHistory[mergedHistory.length - 1].userInputMessage) {
+      const prev = mergedHistory[mergedHistory.length - 1];
+      prev.userInputMessage.content += "\n\n" + current.userInputMessage.content;
+    } else {
+      mergedHistory.push(current);
+    }
+  }
+  history = mergedHistory;
+
+  return { history, currentMessage, systemPrompt };
+}
+
+/**
+ * Build Kiro payload from OpenAI format
+ */
+function buildKiroPayload(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 { history, currentMessage, systemPrompt } = convertMessages(messages, tools, model);
+
+  const profileArn = credentials?.providerSpecificData?.profileArn || "";
+
+  let finalContent = currentMessage?.userInputMessage?.content || "";
+  if (systemPrompt) {
+    finalContent = `[System: ${systemPrompt}]\n\n${finalContent}`;
+  }
+
+  const timestamp = new Date().toISOString();
+  finalContent = `[Context: Current time is ${timestamp}]\n\n${finalContent}`;
+  
+  const payload = {
+    conversationState: {
+      chatTriggerType: "MANUAL",
+      conversationId: uuidv4(),
+      currentMessage: {
+        userInputMessage: {
+          content: finalContent,
+          modelId: model,
+          origin: "AI_EDITOR",
+          ...(currentMessage?.userInputMessage?.userInputMessageContext && {
+            userInputMessageContext: currentMessage.userInputMessage.userInputMessageContext
+          })
+        }
+      },
+      history: history
+    }
+  };
+
+  if (profileArn) {
+    payload.profileArn = profileArn;
+  }
+
+  if (maxTokens || temperature !== undefined || topP !== undefined) {
+    payload.inferenceConfig = {};
+    if (maxTokens) payload.inferenceConfig.maxTokens = maxTokens;
+    if (temperature !== undefined) payload.inferenceConfig.temperature = temperature;
+    if (topP !== undefined) payload.inferenceConfig.topP = topP;
+  }
+
+  return payload;
+}
+
+register(FORMATS.OPENAI, FORMATS.KIRO, buildKiroPayload, null);
+
+export { buildKiroPayload };

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

@@ -0,0 +1,195 @@
+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
+ *
+ * Ollama expects:
+ * - model: string
+ * - messages: Array<{role: string, content: string, images?: string[] }>
+ * - stream: boolean
+ * - options?: {temperature?: number, num_predict?: number}
+ *
+ * Key differences from OpenAI:
+ * - Content must be string, not array
+ * - Multimodal images should be mapped to `message.images[]` (raw base64, no data: prefix)
+ * - tool role maps to tool (Ollama supports tool messages)
+ */
+export function openaiToOllamaRequest(model, body, stream) {
+  const result = {
+    model: model,
+    messages: normalizeMessages(body.messages),
+    stream: stream
+  };
+
+  // Temperature
+  if (body.temperature !== undefined) {
+    result.options = result.options || {};
+    result.options.temperature = body.temperature;
+  }
+
+  // Max tokens (Ollama uses num_predict)
+  if (body.max_tokens !== undefined) {
+    result.options = result.options || {};
+    result.options.num_predict = body.max_tokens;
+  }
+
+  // Top_p
+  if (body.top_p !== undefined) {
+    result.options = result.options || {};
+    result.options.top_p = body.top_p;
+  }
+
+  // Tools (Ollama supports tools in OpenAI format)
+  if (body.tools && Array.isArray(body.tools)) {
+    result.tools = body.tools;
+  }
+
+  // Tool choice
+  if (body.tool_choice) {
+    result.tool_choice = body.tool_choice;
+  }
+
+  return result;
+}
+
+/**
+ * Normalize messages to Ollama format
+ * - Content must be string
+ * - tool messages: convert tool_call_id to tool_name
+ * - assistant messages: keep tool_calls as-is
+ */
+function normalizeMessages(messages) {
+  if (!Array.isArray(messages)) return messages;
+
+  const result = [];
+  const toolCallMap = new Map(); // Map tool_call_id -> tool_name
+
+  // First pass: build tool_call_id -> tool_name map from assistant messages
+  for (const msg of messages) {
+    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);
+        }
+      }
+    }
+  }
+
+  // Second pass: convert messages
+  for (const msg of messages) {
+    // Handle tool result messages (OpenAI format -> Ollama format)
+    if (msg.role === ROLE.TOOL) {
+      const toolResult = normalizeContent(msg.content);
+      if (!toolResult) continue;
+
+      // Get tool_name from map or use msg.name as fallback
+      const toolName = toolCallMap.get(msg.tool_call_id) || msg.name || "unknown_tool";
+
+      result.push({
+        role: ROLE.TOOL,
+        tool_name: toolName,
+        content: toolResult
+      });
+      continue;
+    }
+
+    // Handle assistant messages with 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: OPENAI_BLOCK.FUNCTION,
+        function: {
+          index: tc.index || 0,
+          name: tc.function?.name || "",
+          arguments: typeof tc.function?.arguments === "string" 
+            ? safeParseJSON(tc.function.arguments || "{}", {})
+            : tc.function?.arguments || {}
+        }
+      }));
+
+      result.push({
+        role: ROLE.ASSISTANT,
+        content: content,
+        tool_calls: ollamaToolCalls
+      });
+      continue;
+    }
+
+    // Normal messages
+    const role = msg.role;
+    const content = normalizeContent(msg.content);
+    const images = extractImagesFromContent(msg.content);
+
+    // Skip empty messages (except assistant)
+    if (!content && role !== ROLE.ASSISTANT) continue;
+
+    const out = {
+      role: role,
+      content: content
+    };
+
+    if (images.length > 0) {
+      out.images = images;
+    }
+
+    result.push(out);
+  }
+
+  return result;
+}
+
+/**
+ * Normalize content to string
+ * Ollama only accepts string content
+ */
+function normalizeContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+
+  if (Array.isArray(content)) {
+    // Extract text from content array
+    const textParts = content
+      .filter(block => block && block.type === OPENAI_BLOCK.TEXT && block.text)
+      .map(block => block.text);
+
+    return textParts.join("\n") || "";
+  }
+
+  return "";
+}
+
+/**
+ * Extract base64 images from OpenAI multimodal content blocks.
+ * OpenAI image block format:
+ *   { type: "image_url", image_url: { url: "data:image/png;base64,..." } }
+ * Ollama expects raw base64 strings in message.images[].
+ */
+function extractImagesFromContent(content) {
+  if (!Array.isArray(content)) return [];
+
+  const images = [];
+
+  for (const block of content) {
+    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 parsed = parseDataUri(url);
+    if (!parsed) continue;
+
+    images.push(parsed.base64);
+  }
+
+  return images;
+}
+
+// Register translator
+register(FORMATS.OPENAI, FORMATS.OLLAMA, openaiToOllamaRequest, null);

package/open-sse/translator/request/openai-to-vertex.js

@@ -0,0 +1,42 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { openaiToGeminiRequest } from "./openai-to-gemini.js";
+import { DEFAULT_THINKING_VERTEX_SIGNATURE } from "../../config/defaultThinkingSignature.js";
+
+/**
+ * Post-process a Gemini-format body for Vertex AI compatibility:
+ *
+ * 1. Replace all synthetic thoughtSignatures with Vertex-native signature.
+ * 2. Strip `id` from functionCall and functionResponse (Vertex rejects these).
+ */
+function postProcessForVertex(body) {
+  if (!body?.contents) return body;
+
+  for (const turn of body.contents) {
+    if (!Array.isArray(turn.parts)) continue;
+
+    for (const part of turn.parts) {
+      // Replace any synthetic signature with Vertex-native one
+      if (part.thoughtSignature !== undefined) {
+        part.thoughtSignature = DEFAULT_THINKING_VERTEX_SIGNATURE;
+      }
+      // Strip id from functionCall
+      if (part.functionCall && "id" in part.functionCall) {
+        delete part.functionCall.id;
+      }
+      // Strip id from functionResponse
+      if (part.functionResponse && "id" in part.functionResponse) {
+        delete part.functionResponse.id;
+      }
+    }
+  }
+
+  return body;
+}
+
+export function openaiToVertexRequest(model, body, stream, credentials) {
+  const gemini = openaiToGeminiRequest(model, body, stream, credentials);
+  return postProcessForVertex(gemini);
+}
+
+register(FORMATS.OPENAI, FORMATS.VERTEX, openaiToVertexRequest, null);