@fudrouter/fsrouter 0.6.63 → 0.6.64

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

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

@@ -1,195 +0,0 @@
-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

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