swayrouter 1.0.0

package/src/translator/request/openai-responses.js

@@ -0,0 +1,373 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { normalizeResponsesInput } from "../formats/responsesApi.js";
+import { ROLE, OPENAI_BLOCK, RESPONSES_ITEM } from "../schema/index.js";
+
+const MAX_CALL_ID_LEN = 64;
+const clampCallId = (id) => (typeof id === "string" && id.length > MAX_CALL_ID_LEN ? id.substring(0, MAX_CALL_ID_LEN) : id);
+
+export function openaiResponsesToOpenAIRequest(model, body, stream, credentials) {
+  if (!body.input) return body;
+
+  const result = { ...body };
+  result.messages = [];
+
+  if (body.instructions) {
+    result.messages.push({ role: ROLE.SYSTEM, content: body.instructions });
+  }
+
+  let currentAssistantMsg = null;
+  let pendingToolResults = [];
+  let pendingReasoning = "";
+  let pendingReasoningEncrypted = "";
+  const additionalTools = [];
+  const customToolNames = new Set();
+
+  const inputItems = normalizeResponsesInput(body.input);
+  if (!inputItems) return body;
+
+  const extractReasoningText = (item) => {
+    if (Array.isArray(item.summary)) {
+      const txt = item.summary.map(s => s?.text || "").filter(Boolean).join("\n");
+      if (txt) return txt;
+    }
+    if (Array.isArray(item.content)) {
+      const txt = item.content.map(c => c?.text || "").filter(Boolean).join("\n");
+      if (txt) return txt;
+    }
+    return "";
+  };
+
+  const attachPendingReasoning = (msg) => {
+    if (pendingReasoning) msg.reasoning_content = pendingReasoning;
+    if (pendingReasoningEncrypted) msg.encrypted_content = pendingReasoningEncrypted;
+    pendingReasoning = "";
+    pendingReasoningEncrypted = "";
+  };
+
+  for (const item of inputItems) {
+
+    const itemType = item.type || (item.role ? RESPONSES_ITEM.MESSAGE : null);
+
+    if (itemType === RESPONSES_ITEM.MESSAGE) {
+
+      if (currentAssistantMsg) {
+        result.messages.push(currentAssistantMsg);
+        currentAssistantMsg = null;
+      }
+
+      if (pendingToolResults.length > 0) {
+        for (const tr of pendingToolResults) {
+          result.messages.push(tr);
+        }
+        pendingToolResults = [];
+      }
+
+      const content = Array.isArray(item.content)
+        ? item.content.map(c => {
+          if (c.type === RESPONSES_ITEM.INPUT_TEXT) return { type: OPENAI_BLOCK.TEXT, text: c.text };
+          if (c.type === RESPONSES_ITEM.OUTPUT_TEXT) return { type: OPENAI_BLOCK.TEXT, text: c.text };
+          if (c.type === RESPONSES_ITEM.INPUT_IMAGE) {
+            const url = c.image_url || c.file_id || "";
+            return { type: OPENAI_BLOCK.IMAGE_URL, image_url: { url, detail: c.detail || "auto" } };
+          }
+          return c;
+        })
+        : item.content;
+      const msg = { role: item.role, content };
+
+      if (item.role === ROLE.ASSISTANT) attachPendingReasoning(msg);
+      else {
+        pendingReasoning = "";
+        pendingReasoningEncrypted = "";
+      }
+      result.messages.push(msg);
+    }
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL || itemType === RESPONSES_ITEM.CUSTOM_TOOL_CALL) {
+
+      if (!currentAssistantMsg) {
+        currentAssistantMsg = {
+          role: ROLE.ASSISTANT,
+          content: null,
+          tool_calls: []
+        };
+        attachPendingReasoning(currentAssistantMsg);
+      }
+
+      if (!item.name || typeof item.name !== "string" || item.name.trim() === "") continue;
+      if (itemType === RESPONSES_ITEM.CUSTOM_TOOL_CALL) customToolNames.add(item.name);
+      const toolInput = itemType === RESPONSES_ITEM.CUSTOM_TOOL_CALL
+        ? { input: typeof item.input === "string" ? item.input : JSON.stringify(item.input ?? "") }
+        : item.arguments;
+      currentAssistantMsg.tool_calls.push({
+        id: item.call_id,
+        type: OPENAI_BLOCK.FUNCTION,
+        function: {
+          name: item.name,
+          arguments: typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput ?? {})
+        }
+      });
+    }
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL_OUTPUT || itemType === RESPONSES_ITEM.CUSTOM_TOOL_CALL_OUTPUT) {
+
+      if (currentAssistantMsg) {
+        result.messages.push(currentAssistantMsg);
+        currentAssistantMsg = null;
+      }
+
+      if (pendingToolResults.length > 0) {
+        for (const tr of pendingToolResults) {
+          result.messages.push(tr);
+        }
+        pendingToolResults = [];
+      }
+
+      result.messages.push({
+        role: ROLE.TOOL,
+        tool_call_id: item.call_id,
+        content: typeof item.output === "string" ? item.output : JSON.stringify(item.output)
+      });
+    }
+    else if (itemType === RESPONSES_ITEM.ADDITIONAL_TOOLS) {
+      if (Array.isArray(item.tools)) additionalTools.push(...item.tools);
+    }
+    else if (itemType === RESPONSES_ITEM.REASONING) {
+
+      const txt = extractReasoningText(item);
+      if (txt) pendingReasoning = pendingReasoning ? `${pendingReasoning}\n${txt}` : txt;
+      if (typeof item.encrypted_content === "string" && item.encrypted_content) {
+
+        pendingReasoningEncrypted = item.encrypted_content;
+      }
+      continue;
+    }
+  }
+
+  if (currentAssistantMsg) {
+    result.messages.push(currentAssistantMsg);
+  }
+  if (pendingToolResults.length > 0) {
+    for (const tr of pendingToolResults) {
+      result.messages.push(tr);
+    }
+  }
+
+  const responseTools = [
+    ...(Array.isArray(body.tools) ? body.tools : []),
+    ...additionalTools,
+  ];
+  if (responseTools.length > 0) {
+    result.tools = responseTools
+      .map(tool => {
+
+        if (tool.function) return tool;
+
+        const name = tool.name;
+        if (!name || typeof name !== "string" || name.trim() === "") return null;
+        if (tool.type === "custom") {
+          customToolNames.add(name);
+          const formatHint = [tool.format?.syntax, tool.format?.definition].filter(Boolean).join("\n");
+          return {
+            type: OPENAI_BLOCK.FUNCTION,
+            function: {
+              name,
+              description: [String(tool.description || ""), formatHint].filter(Boolean).join("\n\n"),
+              parameters: {
+                type: "object",
+                properties: {
+                  input: {
+                    type: "string",
+                    description: "Raw freeform input for this custom tool"
+                  }
+                },
+                required: ["input"],
+                additionalProperties: false
+              }
+            }
+          };
+        }
+
+        return {
+          type: OPENAI_BLOCK.FUNCTION,
+          function: {
+            name,
+            description: String(tool.description || ""),
+            parameters: normalizeToolParameters(tool.parameters),
+            strict: tool.strict
+          }
+        };
+      })
+      .filter(Boolean);
+  }
+  if (customToolNames.size > 0) result._customToolNames = [...customToolNames];
+
+  if (result.max_output_tokens !== undefined) {
+    if (result.max_tokens === undefined) result.max_tokens = result.max_output_tokens;
+    delete result.max_output_tokens;
+  }
+
+  delete result.input;
+  delete result.instructions;
+  delete result.include;
+  delete result.prompt_cache_key;
+  delete result.store;
+  if (typeof result.reasoning?.effort === "string") {
+    result.reasoning_effort = result.reasoning.effort;
+  }
+  delete result.reasoning;
+  delete result.client_metadata;
+
+  return result;
+}
+
+function normalizeToolParameters(params) {
+  if (!params) return { type: "object", properties: {} };
+  if (params.type === "object" && !params.properties) return { ...params, properties: {} };
+  return params;
+}
+
+function buildReasoningInputItem(msg) {
+  if (!msg || typeof msg !== "object") return null;
+
+  const encrypted =
+    (typeof msg.encrypted_content === "string" && msg.encrypted_content) ||
+    (typeof msg.reasoning_encrypted_content === "string" && msg.reasoning_encrypted_content) ||
+    (typeof msg.reasoning?.encrypted_content === "string" && msg.reasoning.encrypted_content) ||
+    "";
+
+  let summaryText = "";
+  if (typeof msg.reasoning_content === "string" && msg.reasoning_content.trim()) {
+    summaryText = msg.reasoning_content;
+  } else if (typeof msg.reasoning === "string" && msg.reasoning.trim()) {
+    summaryText = msg.reasoning;
+  } else if (Array.isArray(msg.reasoning_details)) {
+    summaryText = msg.reasoning_details
+      .map((d) => (typeof d?.text === "string" ? d.text : typeof d?.content === "string" ? d.content : ""))
+      .filter(Boolean)
+      .join("\n");
+  }
+
+  if (!encrypted && !summaryText) return null;
+
+  const item = { type: RESPONSES_ITEM.REASONING };
+  if (summaryText) {
+    item.summary = [{ type: RESPONSES_ITEM.SUMMARY_TEXT, text: summaryText }];
+  }
+
+  if (encrypted) item.encrypted_content = encrypted;
+  return item;
+}
+
+export function openaiToOpenAIResponsesRequest(model, body, stream, credentials) {
+
+  if (body.input) return { ...body, model, stream: true };
+
+  const result = {
+    model,
+    input: [],
+    stream: true,
+    store: false
+  };
+
+  const systemParts = [];
+  const messages = body.messages || [];
+
+  for (const msg of messages) {
+    if (msg.role === ROLE.SYSTEM || msg.role === ROLE.DEVELOPER) {
+      const content = typeof msg.content === "string"
+        ? msg.content
+        : Array.isArray(msg.content)
+          ? msg.content.map((part) => part?.text || "").filter(Boolean).join("\n")
+          : "";
+      if (content) systemParts.push(content);
+      continue;
+    }
+
+    if (msg.role === ROLE.USER || msg.role === ROLE.ASSISTANT) {
+
+      if (msg.role === ROLE.ASSISTANT) {
+        const reasoningItem = buildReasoningInputItem(msg);
+        if (reasoningItem) result.input.push(reasoningItem);
+      }
+
+      const contentType = msg.role === ROLE.USER ? RESPONSES_ITEM.INPUT_TEXT : RESPONSES_ITEM.OUTPUT_TEXT;
+      const content = typeof msg.content === "string"
+        ? [{ type: contentType, text: msg.content }]
+        : Array.isArray(msg.content)
+          ? msg.content.map(c => {
+            if (c.type === OPENAI_BLOCK.TEXT) return { type: contentType, text: c.text };
+
+            if (c.type === OPENAI_BLOCK.IMAGE_URL) {
+              const url = typeof c.image_url === "string" ? c.image_url : c.image_url?.url;
+              return { type: RESPONSES_ITEM.INPUT_IMAGE, image_url: url, detail: c.image_url?.detail || "auto" };
+            }
+            if (c.type === RESPONSES_ITEM.INPUT_IMAGE) return c;
+
+            const text = c.text || c.content || JSON.stringify(c);
+            return { type: contentType, text: typeof text === "string" ? text : JSON.stringify(text) };
+          })
+          : [];
+
+      if (content.length > 0) {
+        result.input.push({
+          type: RESPONSES_ITEM.MESSAGE,
+          role: msg.role,
+          content
+        });
+      }
+    }
+
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) {
+      for (const tc of msg.tool_calls) {
+        result.input.push({
+          type: RESPONSES_ITEM.FUNCTION_CALL,
+          call_id: clampCallId(tc.id),
+          name: tc.function?.name || "_unknown",
+          arguments: tc.function?.arguments || "{}"
+        });
+      }
+    }
+
+    if (msg.role === ROLE.TOOL) {
+      const output = typeof msg.content === "string"
+        ? msg.content
+        : Array.isArray(msg.content)
+          ? msg.content.map(c => c.text || JSON.stringify(c)).join("")
+          : JSON.stringify(msg.content);
+      result.input.push({
+        type: RESPONSES_ITEM.FUNCTION_CALL_OUTPUT,
+        call_id: clampCallId(msg.tool_call_id),
+        output
+      });
+    }
+  }
+
+  if (systemParts.length > 0) result.instructions = systemParts.join("\n\n");
+
+  if (body.tools && Array.isArray(body.tools)) {
+    result.tools = body.tools.map(tool => {
+      if (tool.type === OPENAI_BLOCK.FUNCTION) {
+        return {
+          type: OPENAI_BLOCK.FUNCTION,
+          name: tool.function.name,
+          description: String(tool.function.description || ""),
+          parameters: normalizeToolParameters(tool.function.parameters),
+          strict: tool.function.strict
+        };
+      }
+      return tool;
+    });
+  }
+
+  if (body.temperature !== undefined) result.temperature = body.temperature;
+  if (body.max_tokens !== undefined) result.max_tokens = body.max_tokens;
+  if (body.top_p !== undefined) result.top_p = body.top_p;
+  if (body.reasoning !== undefined) result.reasoning = body.reasoning;
+  if (body.reasoning_effort !== undefined) result.reasoning = { effort: body.reasoning_effort, summary: "auto" };
+  if (body.service_tier !== undefined) result.service_tier = body.service_tier;
+
+  return result;
+}
+
+register(FORMATS.OPENAI_RESPONSES, FORMATS.OPENAI, openaiResponsesToOpenAIRequest, null);
+register(FORMATS.OPENAI, FORMATS.OPENAI_RESPONSES, openaiToOpenAIResponsesRequest, null);

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

@@ -0,0 +1,260 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { adjustMaxTokens } from "../formats/maxTokens.js";
+import { safeParseJSON } from "../concerns/json.js";
+import { parseDataUri } from "../concerns/image.js";
+import { extractTextContent } from "../formats/gemini.js";
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK } from "../schema/index.js";
+import { getCapabilitiesForModel } from "../../providers/capabilities.js";
+
+export function openaiToClaudeRequest(model, body, stream) {
+
+  const modelCeiling = getCapabilitiesForModel(null, model).maxOutput || undefined;
+  const result = {
+    model: model,
+    max_tokens: adjustMaxTokens(body, modelCeiling),
+    stream: stream
+  };
+
+  if (body.temperature !== undefined) {
+    result.temperature = body.temperature;
+  }
+
+  result.messages = [];
+  const systemParts = [];
+
+  if (body.messages && Array.isArray(body.messages)) {
+
+    for (const msg of body.messages) {
+      if (msg.role === ROLE.SYSTEM || msg.role === ROLE.DEVELOPER) {
+        systemParts.push(typeof msg.content === "string" ? msg.content : extractTextContent(msg.content, "\n"));
+      }
+    }
+
+    const nonSystemMessages = body.messages.filter(m => m.role !== ROLE.SYSTEM && m.role !== ROLE.DEVELOPER);
+
+    let currentRole = undefined;
+    let currentParts = [];
+
+    const flushCurrentMessage = () => {
+      if (currentRole && currentParts.length > 0) {
+        result.messages.push({ role: currentRole, content: currentParts });
+        currentParts = [];
+      }
+    };
+
+    for (const msg of nonSystemMessages) {
+      const newRole = (msg.role === ROLE.USER || msg.role === ROLE.TOOL) ? ROLE.USER : ROLE.ASSISTANT;
+      const blocks = getContentBlocksFromMessage(msg);
+      const hasToolUse = blocks.some(b => b.type === CLAUDE_BLOCK.TOOL_USE);
+      const hasToolResult = blocks.some(b => b.type === CLAUDE_BLOCK.TOOL_RESULT);
+
+      if (hasToolResult) {
+        const toolResultBlocks = blocks.filter(b => b.type === CLAUDE_BLOCK.TOOL_RESULT);
+        const otherBlocks = blocks.filter(b => b.type !== CLAUDE_BLOCK.TOOL_RESULT);
+
+        flushCurrentMessage();
+
+        if (toolResultBlocks.length > 0) {
+          result.messages.push({ role: ROLE.USER, content: toolResultBlocks });
+        }
+
+        if (otherBlocks.length > 0) {
+          currentRole = newRole;
+          currentParts.push(...otherBlocks);
+        }
+        continue;
+      }
+
+      if (currentRole !== newRole) {
+        flushCurrentMessage();
+        currentRole = newRole;
+      }
+
+      currentParts.push(...blocks);
+
+      if (hasToolUse) {
+        flushCurrentMessage();
+      }
+    }
+
+    flushCurrentMessage();
+
+    for (let i = result.messages.length - 1; i >= 0; i--) {
+      const message = result.messages[i];
+      if (message.role === ROLE.ASSISTANT && Array.isArray(message.content) && message.content.length > 0) {
+
+        const validBlockTypes = [CLAUDE_BLOCK.TEXT, CLAUDE_BLOCK.TOOL_USE, CLAUDE_BLOCK.TOOL_RESULT, CLAUDE_BLOCK.IMAGE];
+        for (let j = message.content.length - 1; j >= 0; j--) {
+          const block = message.content[j];
+          if (validBlockTypes.includes(block.type)) {
+            block.cache_control = { type: "ephemeral" };
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  if (systemParts.length > 0) {
+    const systemText = systemParts.join("\n\n");
+    result.system = [
+      { type: CLAUDE_BLOCK.TEXT, text: systemText, cache_control: { type: "ephemeral", ttl: "1h" } }
+    ];
+  }
+
+  if (body.tools && Array.isArray(body.tools)) {
+    result.tools = [];
+    for (const tool of body.tools) {
+
+      const toolType = tool.type;
+      if (toolType && toolType !== OPENAI_BLOCK.FUNCTION) {
+        result.tools.push(tool);
+        continue;
+      }
+
+      const toolData = tool.function ?? tool;
+      result.tools.push({
+        name: toolData.name,
+        description: toolData.description || "",
+        input_schema: toolData.parameters || toolData.input_schema || { type: "object", properties: {}, required: [] }
+      });
+    }
+
+    if (result.tools.length > 0) {
+      result.tools[result.tools.length - 1].cache_control = { type: "ephemeral", ttl: "1h" };
+    }
+  }
+
+  if (body.tool_choice) {
+    result.tool_choice = convertOpenAIToolChoice(body.tool_choice);
+  }
+
+  return result;
+}
+
+function getContentBlocksFromMessage(msg) {
+  const blocks = [];
+
+  if (msg.role === ROLE.TOOL) {
+    blocks.push({
+      type: CLAUDE_BLOCK.TOOL_RESULT,
+      tool_use_id: msg.tool_call_id,
+      content: msg.content
+    });
+  } else if (msg.role === ROLE.USER) {
+    if (typeof msg.content === "string") {
+      if (msg.content) {
+        blocks.push({ type: CLAUDE_BLOCK.TEXT, text: msg.content });
+      }
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === OPENAI_BLOCK.TEXT && part.text) {
+          blocks.push({ type: CLAUDE_BLOCK.TEXT, text: part.text });
+        } else if (part.type === CLAUDE_BLOCK.TOOL_RESULT) {
+          blocks.push({
+            type: CLAUDE_BLOCK.TOOL_RESULT,
+            tool_use_id: part.tool_use_id,
+            content: part.content,
+            ...(part.is_error && { is_error: part.is_error })
+          });
+        } else if (part.type === OPENAI_BLOCK.IMAGE_URL) {
+          const url = part.image_url.url;
+          const parsed = parseDataUri(url);
+          if (parsed) {
+            blocks.push({
+              type: CLAUDE_BLOCK.IMAGE,
+              source: { type: "base64", media_type: parsed.mimeType, data: parsed.base64 }
+            });
+          } else if (url.startsWith("http://") || url.startsWith("https://")) {
+            blocks.push({
+              type: CLAUDE_BLOCK.IMAGE,
+              source: { type: "url", url }
+            });
+          }
+        } else if (part.type === OPENAI_BLOCK.IMAGE && part.source) {
+          blocks.push({ type: CLAUDE_BLOCK.IMAGE, source: part.source });
+        } else if (part.type === OPENAI_BLOCK.FILE && part.file) {
+
+          const fileData = part.file.file_data;
+          const parsed = parseDataUri(fileData);
+          if (parsed && parsed.mimeType === "application/pdf") {
+            blocks.push({
+              type: CLAUDE_BLOCK.DOCUMENT,
+              source: { type: "base64", media_type: parsed.mimeType, data: parsed.base64 }
+            });
+          }
+        }
+      }
+    }
+  } else if (msg.role === ROLE.ASSISTANT) {
+    if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === OPENAI_BLOCK.TEXT && part.text) {
+          blocks.push({ type: CLAUDE_BLOCK.TEXT, text: part.text });
+        } else if (part.type === CLAUDE_BLOCK.TOOL_USE) {
+
+          blocks.push({ type: CLAUDE_BLOCK.TOOL_USE, id: part.id, name: part.name, input: part.input });
+        } else if (part.type === CLAUDE_BLOCK.THINKING) {
+
+          const { cache_control, ...thinkingBlock } = part;
+          blocks.push(thinkingBlock);
+        }
+      }
+    } else if (msg.content) {
+      const text = typeof msg.content === "string" ? msg.content : extractTextContent(msg.content, "\n");
+      if (text) {
+        blocks.push({ type: CLAUDE_BLOCK.TEXT, text });
+      }
+    }
+
+    if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+      for (const tc of msg.tool_calls) {
+        if (tc.type === OPENAI_BLOCK.FUNCTION) {
+
+          blocks.push({
+            type: CLAUDE_BLOCK.TOOL_USE,
+            id: tc.id,
+            name: tc.function.name,
+            input: safeParseJSON(tc.function.arguments, tc.function.arguments)
+          });
+        }
+      }
+    }
+  }
+
+  return blocks;
+}
+
+const CLAUDE_TOOL_CHOICE_TYPES = new Set(["auto", "any", "tool", "none"]);
+
+function convertOpenAIToolChoice(choice) {
+  if (!choice) return { type: "auto" };
+
+  if (typeof choice === "string") {
+    if (choice === "required") return { type: "any" };
+    return { type: "auto" };
+  }
+
+  if (typeof choice === "object") {
+
+    if (choice.function?.name) {
+      return { type: "tool", name: choice.function.name };
+    }
+
+    if (CLAUDE_TOOL_CHOICE_TYPES.has(choice.type)) {
+      return choice;
+    }
+  }
+
+  return { type: "auto" };
+}
+
+function openaiToClaudeRequestForAntigravity(model, body, stream) {
+  return openaiToClaudeRequest(model, body, stream);
+}
+
+export { openaiToClaudeRequestForAntigravity };
+
+register(FORMATS.OPENAI, FORMATS.CLAUDE, openaiToClaudeRequest, null);