swayrouter 1.0.0

package/src/translator/request/claude-to-kiro.js

@@ -0,0 +1,288 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { applyKiroSessionReplay } from "../../utils/kiroSessionReplay.js";
+import { resolveContinuationId, resolveSessionIdentity } from "../../utils/sessionManager.js";
+import {
+  resolveKiroModelIntent,
+  applyKiroThinkingOverride,
+  resolveDefaultProfileArn,
+  buildKiroAdditionalModelRequestFieldsForModel,
+} from "../../config/kiroConstants.js";
+import { DEFAULT_IMAGE_MIME } from "../schema/index.js";
+import { ROLE, CLAUDE_BLOCK } from "../schema/index.js";
+import {
+  canonicalizeKiroConversation,
+  normalizeKiroToolSpecs,
+} from "../concerns/kiroConversation.js";
+
+function convertClaudeMessagesToKiro(messages, model) {
+  const history = [];
+  let currentMessage = null;
+
+  let pendingUserContent = [];
+  let pendingAssistantContent = [];
+  let pendingToolResults = [];
+  let pendingImages = [];
+  let currentRole = null;
+
+  const flushPending = () => {
+    if (currentRole === ROLE.USER) {
+      const content = pendingUserContent.join("\n\n");
+      const userMsg = { userInputMessage: { content, modelId: model } };
+
+      if (pendingImages.length > 0) {
+        userMsg.userInputMessage.images = pendingImages;
+      }
+      if (pendingToolResults.length > 0) {
+        userMsg.userInputMessage.userInputMessageContext = {
+          toolResults: pendingToolResults,
+        };
+      }
+      history.push(userMsg);
+      currentMessage = userMsg;
+      pendingUserContent = [];
+      pendingToolResults = [];
+      pendingImages = [];
+    } else if (currentRole === ROLE.ASSISTANT) {
+      const content = pendingAssistantContent.join("\n\n");
+      history.push({ assistantResponseMessage: { content } });
+      pendingAssistantContent = [];
+    }
+  };
+
+  for (const msg of messages) {
+    const role = msg.role;
+    if (role !== currentRole && currentRole !== null) flushPending();
+    currentRole = role;
+
+    if (role === ROLE.USER) {
+      if (typeof msg.content === "string") {
+        pendingUserContent.push(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === CLAUDE_BLOCK.TEXT) {
+            pendingUserContent.push(block.text);
+          } else if (block.type === CLAUDE_BLOCK.IMAGE && block.source?.type === "base64") {
+            const mediaType = block.source.media_type || DEFAULT_IMAGE_MIME;
+            const format = mediaType.split("/")[1] || mediaType;
+            pendingImages.push({ format, source: { bytes: block.source.data } });
+          } else if (block.type === CLAUDE_BLOCK.TOOL_RESULT) {
+            let resultContent = "";
+            if (typeof block.content === "string") {
+              resultContent = block.content;
+            } else if (Array.isArray(block.content)) {
+              resultContent =
+                block.content
+                  .filter((c) => c.type === CLAUDE_BLOCK.TEXT)
+                  .map((c) => c.text)
+                  .join("\n") || JSON.stringify(block.content);
+            } else if (block.content) {
+              resultContent = JSON.stringify(block.content);
+            }
+            pendingToolResults.push({
+              toolUseId: block.tool_use_id,
+              status: block.is_error ? "error" : "success",
+              content: [{ text: resultContent }],
+            });
+          }
+        }
+      }
+    } else if (role === ROLE.ASSISTANT) {
+      let textContent = "";
+      const toolUses = [];
+      if (typeof msg.content === "string") {
+        textContent = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === CLAUDE_BLOCK.TEXT) {
+            textContent += block.text;
+          } else if (block.type === CLAUDE_BLOCK.TOOL_USE) {
+            toolUses.push({
+              toolUseId: block.id,
+              name: block.name,
+              input: block.input || {},
+            });
+          }
+        }
+      }
+      if (textContent) pendingAssistantContent.push(textContent);
+
+      if (toolUses.length > 0) {
+        flushPending();
+        const lastMsg = history[history.length - 1];
+        if (lastMsg?.assistantResponseMessage) {
+          lastMsg.assistantResponseMessage.toolUses = toolUses;
+        }
+        currentRole = null;
+      }
+    }
+  }
+
+  if (currentRole !== null) flushPending();
+
+  for (let i = history.length - 1; i >= 0; i--) {
+    if (history[i].userInputMessage) {
+      currentMessage = history.splice(i, 1)[0];
+      break;
+    }
+  }
+
+  history.forEach((item) => {
+    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;
+    }
+  });
+
+  const mergedHistory = [];
+  for (const current of history) {
+    const prev = mergedHistory[mergedHistory.length - 1];
+    if (current.userInputMessage && prev?.userInputMessage) {
+      prev.userInputMessage.content += "\n\n" + current.userInputMessage.content;
+      const prevCtx = prev.userInputMessage.userInputMessageContext;
+      const curCtx = current.userInputMessage.userInputMessageContext;
+      if (curCtx) {
+        if (!prevCtx) {
+          prev.userInputMessage.userInputMessageContext = curCtx;
+        } else {
+          if (curCtx.toolResults?.length > 0) {
+            prevCtx.toolResults = [
+              ...(prevCtx.toolResults || []),
+              ...curCtx.toolResults,
+            ];
+          }
+          if (curCtx.tools?.length > 0) {
+            prevCtx.tools = [...(prevCtx.tools || []), ...curCtx.tools];
+          }
+        }
+      }
+    } else {
+      mergedHistory.push(current);
+    }
+  }
+
+  if (!currentMessage) {
+    currentMessage = { userInputMessage: { content: "", modelId: model } };
+  }
+
+  return { history: mergedHistory, currentMessage };
+}
+
+function extractClaudeSystemText(system) {
+  if (!system) return "";
+  if (typeof system === "string") return system;
+  if (Array.isArray(system)) {
+    return system.map((s) => {
+      if (typeof s === "string") return s;
+      return s?.text || "";
+    }).filter(Boolean).join("\n\n");
+  }
+  return "";
+}
+
+export function claudeToKiroRequest(model, body, stream, credentials) {
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  const tools = Array.isArray(body.tools) ? body.tools : [];
+  const maxTokens = body.max_tokens || 32000;
+  const temperature = body.temperature;
+  const topP = body.top_p;
+
+  const modelIntent = resolveKiroModelIntent(model);
+  const { upstream: upstreamModel } = modelIntent;
+  const thinkingBody = applyKiroThinkingOverride(body, modelIntent.thinkingOverride);
+  const additionalModelRequestFields = buildKiroAdditionalModelRequestFieldsForModel(thinkingBody, upstreamModel);
+
+  const { specs: toolSpecs, nameMap } = normalizeKiroToolSpecs(tools);
+  const { history, currentMessage } = convertClaudeMessagesToKiro(messages, upstreamModel);
+
+  const authMethod = credentials?.providerSpecificData?.authMethod;
+  const accountBoundAuth =
+    authMethod === "api_key" || authMethod === "idc" || authMethod === "external_idp";
+  const profileArn = accountBoundAuth
+    ? (credentials?.providerSpecificData?.profileArn || "")
+    : (credentials?.providerSpecificData?.profileArn || resolveDefaultProfileArn(authMethod));
+
+  const systemPrompt = extractClaudeSystemText(body.system);
+
+  const sessionIdentity = resolveSessionIdentity({
+    headers: credentials?.rawHeaders,
+    body,
+    connectionId: credentials?.connectionId,
+    scope: "kiro",
+  });
+  const conversationId = sessionIdentity.sessionId;
+  const continuationId = resolveContinuationId({
+    sessionId: conversationId,
+    connectionId: credentials?.connectionId,
+    scope: "kiro",
+    ephemeral: sessionIdentity.ephemeral,
+  });
+  const replay = applyKiroSessionReplay({
+    conversationId,
+    connectionId: credentials?.connectionId,
+    modelId: upstreamModel,
+    systemPrompt,
+    history,
+    currentMessage,
+  });
+  const canonical = canonicalizeKiroConversation({
+    history: replay.history,
+    currentMessage: replay.currentMessage,
+    modelId: upstreamModel,
+    toolSpecs,
+    nameMap,
+  });
+  const replayCurrent = canonical.currentMessage.userInputMessage;
+  const userInputMessage = {
+    content: replayCurrent.content || "",
+    modelId: upstreamModel,
+    origin: "AI_EDITOR",
+    ...(replayCurrent.userInputMessageContext && {
+      userInputMessageContext: replayCurrent.userInputMessageContext,
+    }),
+    ...(replayCurrent.images && {
+      images: replayCurrent.images,
+    }),
+  };
+
+  const payload = {
+    conversationState: {
+      chatTriggerType: "MANUAL",
+      conversationId,
+      agentContinuationId: continuationId,
+      agentTaskType: "vibe",
+      currentMessage: {
+        userInputMessage,
+      },
+      history: canonical.history,
+    },
+    agentMode: "vibe",
+  };
+
+  if (profileArn) payload.profileArn = profileArn;
+  if (systemPrompt) payload.systemPrompt = systemPrompt;
+  if (additionalModelRequestFields) {
+    payload.additionalModelRequestFields = additionalModelRequestFields;
+  }
+
+  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;
+  }
+
+  Object.defineProperty(payload, "_kiroUpstreamModel", {
+    value: upstreamModel,
+    enumerable: false,
+  });
+
+  return payload;
+}
+
+register(FORMATS.CLAUDE, FORMATS.KIRO, claudeToKiroRequest, null);

package/src/translator/request/claude-to-openai.js

@@ -0,0 +1,199 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { adjustMaxTokens } from "../formats/maxTokens.js";
+import { encodeDataUri } from "../concerns/image.js";
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK } from "../schema/index.js";
+import { collapseTextParts } from "../concerns/message.js";
+
+export function claudeToOpenAIRequest(model, body, stream) {
+  const result = {
+    model: model,
+    messages: [],
+    stream: stream
+  };
+
+  if (body.max_tokens) {
+    result.max_tokens = adjustMaxTokens(body);
+  }
+
+  if (body.temperature !== undefined) {
+    result.temperature = body.temperature;
+  }
+
+  if (body.system) {
+    const systemContent = Array.isArray(body.system)
+      ? body.system.map(s => typeof s === "string" ? s : s?.text || "").filter(Boolean).join("\n\n")
+      : body.system;
+
+    if (systemContent) {
+      result.messages.push({
+        role: ROLE.SYSTEM,
+        content: systemContent
+      });
+    }
+  }
+
+  if (body.messages && Array.isArray(body.messages)) {
+    for (let i = 0; i < body.messages.length; i++) {
+      const msg = body.messages[i];
+      const converted = convertClaudeMessage(msg);
+      if (converted) {
+
+        if (Array.isArray(converted)) {
+          result.messages.push(...converted);
+        } else {
+          result.messages.push(converted);
+        }
+      }
+    }
+  }
+
+  if (body.tools && Array.isArray(body.tools)) {
+    result.tools = body.tools.map(tool => ({
+      type: OPENAI_BLOCK.FUNCTION,
+      function: {
+        name: tool.name,
+        description: String(tool.description || ""),
+        parameters: tool.input_schema || { type: "object", properties: {} }
+      }
+    }));
+  }
+
+  if (body.tool_choice) {
+    result.tool_choice = convertToolChoice(body.tool_choice);
+  }
+
+  if (body.reasoning_effort !== undefined) {
+    result.reasoning_effort = body.reasoning_effort;
+  } else if (body.reasoning?.effort !== undefined) {
+    result.reasoning_effort = body.reasoning.effort;
+  }
+
+  if (body.reasoning !== undefined) {
+    result.reasoning = body.reasoning;
+  }
+
+  return result;
+}
+
+function systemMessageText(content) {
+  const parts = Array.isArray(content)
+    ? content.filter(c => c?.type === CLAUDE_BLOCK.TEXT).map(c => c.text || "")
+    : [typeof content === "string" ? content : ""];
+  const text = parts.filter(Boolean).join("\n");
+  if (!text.trim()) return "";
+  return text;
+}
+
+function convertClaudeMessage(msg) {
+
+  if (msg.role === ROLE.SYSTEM || msg.role === ROLE.DEVELOPER) {
+    const text = systemMessageText(msg.content);
+    return text ? { role: ROLE.SYSTEM, content: text } : null;
+  }
+
+  const role = msg.role === ROLE.USER || msg.role === ROLE.TOOL ? ROLE.USER : ROLE.ASSISTANT;
+
+  if (typeof msg.content === "string") {
+    return { role, content: msg.content };
+  }
+
+  if (Array.isArray(msg.content)) {
+    const parts = [];
+    const toolCalls = [];
+    const toolResults = [];
+
+    for (const block of msg.content) {
+      switch (block.type) {
+        case CLAUDE_BLOCK.TEXT:
+          parts.push({ type: OPENAI_BLOCK.TEXT, text: block.text });
+          break;
+
+        case CLAUDE_BLOCK.IMAGE:
+          if (block.source?.type === "base64") {
+            parts.push({
+              type: OPENAI_BLOCK.IMAGE_URL,
+              image_url: {
+                url: encodeDataUri(block.source.media_type, block.source.data)
+              }
+            });
+          }
+          break;
+
+        case CLAUDE_BLOCK.TOOL_USE:
+          toolCalls.push({
+            id: block.id,
+            type: OPENAI_BLOCK.FUNCTION,
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(block.input || {})
+            }
+          });
+          break;
+
+        case CLAUDE_BLOCK.TOOL_RESULT:
+          let resultContent = "";
+          if (typeof block.content === "string") {
+            resultContent = block.content;
+          } else if (Array.isArray(block.content)) {
+            resultContent = block.content
+              .filter(c => c.type === CLAUDE_BLOCK.TEXT)
+              .map(c => c.text)
+              .join("\n") || JSON.stringify(block.content);
+          } else if (block.content) {
+            resultContent = JSON.stringify(block.content);
+          }
+
+          toolResults.push({
+            role: ROLE.TOOL,
+            tool_call_id: block.tool_use_id,
+            content: resultContent
+          });
+          break;
+      }
+    }
+
+    if (toolResults.length > 0) {
+      if (parts.length > 0) {
+        return [...toolResults, { role: ROLE.USER, content: collapseTextParts(parts) }];
+      }
+      return toolResults;
+    }
+
+    if (toolCalls.length > 0) {
+      const result = { role: ROLE.ASSISTANT };
+      if (parts.length > 0) {
+        result.content = collapseTextParts(parts);
+      }
+      result.tool_calls = toolCalls;
+      return result;
+    }
+
+    if (parts.length > 0) {
+      return {
+        role,
+        content: collapseTextParts(parts)
+      };
+    }
+
+    if (msg.content.length === 0) {
+      return { role, content: "" };
+    }
+  }
+
+  return null;
+}
+
+function convertToolChoice(choice) {
+  if (!choice) return "auto";
+  if (typeof choice === "string") return choice;
+
+  switch (choice.type) {
+    case "auto": return "auto";
+    case "any": return "required";
+    case "tool": return { type: OPENAI_BLOCK.FUNCTION, function: { name: choice.name } };
+    default: return "auto";
+  }
+}
+
+register(FORMATS.CLAUDE, FORMATS.OPENAI, claudeToOpenAIRequest, null);

package/src/translator/request/gemini-to-openai.js

@@ -0,0 +1,142 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { adjustMaxTokens } from "../formats/maxTokens.js";
+import { encodeDataUri } from "../concerns/image.js";
+import { collapseTextParts } from "../concerns/message.js";
+import { ROLE, GEMINI_ROLE, OPENAI_BLOCK } from "../schema/index.js";
+
+export function geminiToOpenAIRequest(model, body, stream) {
+  const result = {
+    model: model,
+    messages: [],
+    stream: stream
+  };
+
+  if (body.generationConfig) {
+    const config = body.generationConfig;
+    if (config.maxOutputTokens) {
+      const tempBody = { max_tokens: config.maxOutputTokens, tools: body.tools };
+      result.max_tokens = adjustMaxTokens(tempBody);
+    }
+    if (config.temperature !== undefined) {
+      result.temperature = config.temperature;
+    }
+    if (config.topP !== undefined) {
+      result.top_p = config.topP;
+    }
+  }
+
+  if (body.systemInstruction) {
+    const systemText = extractGeminiText(body.systemInstruction);
+    if (systemText) {
+      result.messages.push({
+        role: ROLE.SYSTEM,
+        content: systemText
+      });
+    }
+  }
+
+  if (body.contents && Array.isArray(body.contents)) {
+    for (const content of body.contents) {
+      const converted = convertGeminiContent(content);
+      if (converted) {
+        result.messages.push(converted);
+      }
+    }
+  }
+
+  if (body.tools && Array.isArray(body.tools)) {
+    result.tools = [];
+    for (const tool of body.tools) {
+      if (tool.functionDeclarations) {
+        for (const func of tool.functionDeclarations) {
+          result.tools.push({
+            type: OPENAI_BLOCK.FUNCTION,
+            function: {
+              name: func.name,
+              description: func.description || "",
+              parameters: func.parameters || { type: "object", properties: {} }
+            }
+          });
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+function convertGeminiContent(content) {
+  const role = content.role === GEMINI_ROLE.USER ? ROLE.USER : ROLE.ASSISTANT;
+
+  if (!content.parts || !Array.isArray(content.parts)) {
+    return null;
+  }
+
+  const parts = [];
+  const toolCalls = [];
+
+  for (const part of content.parts) {
+    if (part.text !== undefined) {
+      parts.push({ type: OPENAI_BLOCK.TEXT, text: part.text });
+    }
+
+    if (part.inlineData) {
+      parts.push({
+        type: OPENAI_BLOCK.IMAGE_URL,
+        image_url: {
+          url: encodeDataUri(part.inlineData.mimeType, part.inlineData.data)
+        }
+      });
+    }
+
+    if (part.functionCall) {
+
+      toolCalls.push({
+        id: part.functionCall.id || `call_${part.functionCall.name}`,
+        type: OPENAI_BLOCK.FUNCTION,
+        function: {
+          name: part.functionCall.name,
+          arguments: JSON.stringify(part.functionCall.args || {})
+        }
+      });
+    }
+
+    if (part.functionResponse) {
+      return {
+        role: ROLE.TOOL,
+        tool_call_id: part.functionResponse.id || `call_${part.functionResponse.name}`,
+        content: JSON.stringify(part.functionResponse.response?.result || part.functionResponse.response || {})
+      };
+    }
+  }
+
+  if (toolCalls.length > 0) {
+    const result = { role: ROLE.ASSISTANT };
+    if (parts.length > 0) {
+      result.content = parts.length === 1 ? parts[0].text : parts;
+    }
+    result.tool_calls = toolCalls;
+    return result;
+  }
+
+  if (parts.length > 0) {
+    return {
+      role,
+      content: collapseTextParts(parts)
+    };
+  }
+
+  return null;
+}
+
+function extractGeminiText(content) {
+  if (typeof content === "string") return content;
+  if (content.parts && Array.isArray(content.parts)) {
+    return content.parts.map(p => p.text || "").join("");
+  }
+  return "";
+}
+
+register(FORMATS.GEMINI, FORMATS.OPENAI, geminiToOpenAIRequest, null);
+register(FORMATS.GEMINI_CLI, FORMATS.OPENAI, geminiToOpenAIRequest, null);