swayrouter 1.0.0

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

@@ -0,0 +1,161 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { randomUUID } from "crypto";
+import { ROLE, OPENAI_BLOCK } from "../schema/index.js";
+import { DEFAULT_MAX_TOKENS } from "../../config/runtimeConfig.js";
+
+function flattenText(content) {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const p of content) {
+      if (typeof p === "string") parts.push(p);
+      else if (p && typeof p === "object" && typeof p.text === "string") parts.push(p.text);
+    }
+    return parts.join("\n");
+  }
+  return String(content);
+}
+
+function toContentBlocks(content) {
+  if (content == null) return [{ type: OPENAI_BLOCK.TEXT, text: "" }];
+  if (typeof content === "string") return [{ type: OPENAI_BLOCK.TEXT, text: content }];
+  if (Array.isArray(content)) {
+    const blocks = [];
+    for (const part of content) {
+      if (typeof part === "string") {
+        blocks.push({ type: OPENAI_BLOCK.TEXT, text: part });
+      } else if (part && typeof part === "object") {
+        if (part.type === OPENAI_BLOCK.TEXT && typeof part.text === "string") {
+          blocks.push({ type: OPENAI_BLOCK.TEXT, text: part.text });
+        } else if (part.type === OPENAI_BLOCK.IMAGE_URL || part.type === OPENAI_BLOCK.IMAGE) {
+          blocks.push({ type: OPENAI_BLOCK.TEXT, text: "[image omitted]" });
+        } else if (typeof part.text === "string") {
+          blocks.push({ type: OPENAI_BLOCK.TEXT, text: part.text });
+        }
+      }
+    }
+    return blocks.length ? blocks : [{ type: OPENAI_BLOCK.TEXT, text: "" }];
+  }
+  return [{ type: OPENAI_BLOCK.TEXT, text: String(content) }];
+}
+
+function safeParseJson(s) {
+  if (s == null) return {};
+  if (typeof s !== "string") return s;
+  try { return JSON.parse(s); } catch { return {}; }
+}
+
+function convertMessages(messages = []) {
+  const out = [];
+  const systemTexts = [];
+
+  for (const m of messages) {
+    if (!m) continue;
+    const role = m.role;
+
+    if (role === ROLE.SYSTEM || role === ROLE.DEVELOPER) {
+      const t = flattenText(m.content);
+      if (t) systemTexts.push(t);
+      continue;
+    }
+
+    if (role === ROLE.TOOL) {
+      const value = typeof m.content === "string" ? m.content : flattenText(m.content);
+      out.push({
+        role: ROLE.TOOL,
+        content: [{
+          type: "tool-result",
+          toolCallId: m.tool_call_id || "",
+          toolName: m.name || "",
+          output: { type: "text", value },
+        }],
+      });
+      continue;
+    }
+
+    if (role === ROLE.ASSISTANT) {
+      const blocks = [];
+      const text = flattenText(m.content);
+      if (text) blocks.push({ type: OPENAI_BLOCK.TEXT, text });
+      if (Array.isArray(m.tool_calls)) {
+        for (const tc of m.tool_calls) {
+          const fn = tc.function || {};
+          blocks.push({
+            type: "tool-call",
+            toolCallId: tc.id || "",
+            toolName: fn.name || "",
+            input: safeParseJson(fn.arguments),
+          });
+        }
+      }
+      out.push({ role: ROLE.ASSISTANT, content: blocks.length ? blocks : [{ type: OPENAI_BLOCK.TEXT, text: "" }] });
+      continue;
+    }
+
+    out.push({ role: ROLE.USER, content: toContentBlocks(m.content) });
+  }
+
+  return { messages: out, system: systemTexts.join("\n\n") };
+}
+
+function convertTools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) return undefined;
+  const result = [];
+  for (const t of tools) {
+    if (!t) continue;
+    if (t.type === OPENAI_BLOCK.FUNCTION && t.function) {
+      result.push({
+        name: t.function.name,
+        description: t.function.description,
+        input_schema: t.function.parameters || { type: "object" },
+      });
+    } else if (t.name && (t.input_schema || t.parameters)) {
+      result.push({
+        name: t.name,
+        description: t.description,
+        input_schema: t.input_schema || t.parameters,
+      });
+    }
+  }
+  return result.length ? result : undefined;
+}
+
+export function openaiToCommandCodeRequest(model, body, stream                    ) {
+  const { messages, system } = convertMessages(body.messages);
+  const params = {
+    model,
+    messages,
+    stream: stream !== false,
+    max_tokens: body.max_tokens ?? body.max_output_tokens ?? DEFAULT_MAX_TOKENS,
+    temperature: body.temperature ?? 0.3,
+  };
+
+  if (system) params.system = system;
+
+  const tools = convertTools(body.tools);
+  if (tools) params.tools = tools;
+  if (body.top_p != null) params.top_p = body.top_p;
+
+  const today = new Date().toISOString().slice(0, 10);
+
+  return {
+    threadId: randomUUID(),
+    memory: "",
+    config: {
+      workingDir: process.cwd(),
+      date: today,
+      environment: process.platform,
+      structure: [],
+      isGitRepo: false,
+      currentBranch: "",
+      mainBranch: "",
+      gitStatus: "",
+      recentCommits: [],
+    },
+    params,
+  };
+}
+
+register(FORMATS.OPENAI, FORMATS.COMMANDCODE, openaiToCommandCodeRequest, null);

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

@@ -0,0 +1,175 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK } from "../schema/index.js";
+import { DEFAULT_MIN_TOKENS } from "../../config/runtimeConfig.js";
+
+function extractContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter(part => {
+        if (!part || typeof part !== "object") return false;
+        return part.type === OPENAI_BLOCK.TEXT && typeof part.text === "string";
+      })
+      .map(part => part.text || "")
+      .join("");
+  }
+  return "";
+}
+
+function sanitizeToolResultText(text) {
+
+  return text.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
+}
+
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function buildToolResultBlock(toolName, toolCallId, resultText) {
+  const cleanResult = sanitizeToolResultText(resultText || "");
+  return [
+    "<tool_result>",
+    `<tool_name>${escapeXml(toolName || "tool")}</tool_name>`,
+    `<tool_call_id>${escapeXml(toolCallId || "")}</tool_call_id>`,
+    `<result>${escapeXml(cleanResult)}</result>`,
+    "</tool_result>"
+  ].join("\n");
+}
+
+function normalizeToolCallId(id) {
+  return typeof id === "string" ? id.split("\n")[0] : "";
+}
+
+function convertMessages(messages) {
+  const result = [];
+
+  const toolCallMetaMap = new Map();
+  const rememberToolMeta = (toolCallId, toolName) => {
+    if (!toolCallId) return;
+    const name = toolName || "tool";
+    toolCallMetaMap.set(toolCallId, { name });
+    const normalized = normalizeToolCallId(toolCallId);
+    if (normalized && normalized !== toolCallId) {
+      toolCallMetaMap.set(normalized, { name });
+    }
+  };
+
+  for (const msg of messages) {
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) {
+      for (const tc of msg.tool_calls) {
+        rememberToolMeta(tc.id || "", tc.function?.name || "tool");
+      }
+    }
+    if (msg.role === ROLE.ASSISTANT && Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part?.type !== CLAUDE_BLOCK.TOOL_USE) continue;
+        rememberToolMeta(part.id || "", part.name || "tool");
+      }
+    }
+  }
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+
+    if (msg.role === ROLE.SYSTEM || msg.role === ROLE.DEVELOPER) {
+      result.push({
+        role: ROLE.SYSTEM,
+        content: extractContent(msg.content)
+      });
+      continue;
+    }
+
+    if (msg.role === ROLE.TOOL) {
+      const toolContent = extractContent(msg.content);
+      const toolCallId = msg.tool_call_id || "";
+      const toolMeta = toolCallMetaMap.get(toolCallId) || {};
+      const toolName = msg.name || toolMeta.name || "tool";
+      result.push({
+        role: ROLE.USER,
+        content: buildToolResultBlock(toolName, toolCallId, toolContent)
+      });
+      continue;
+    }
+
+    if (msg.role === ROLE.USER || msg.role === ROLE.ASSISTANT) {
+      if (msg.role === ROLE.USER && Array.isArray(msg.content)) {
+        const parts = [];
+        for (const block of msg.content) {
+          if (!block || typeof block !== "object") continue;
+          if (block.type === CLAUDE_BLOCK.TEXT) {
+            if (typeof block.text === "string") {
+              parts.push(block.text || "");
+            }
+            continue;
+          }
+          if (block.type === CLAUDE_BLOCK.TOOL_RESULT) {
+            const toolCallId = block.tool_use_id || "";
+            const toolMeta =
+              toolCallMetaMap.get(toolCallId) ||
+              toolCallMetaMap.get(normalizeToolCallId(toolCallId));
+            const toolName = toolMeta?.name || "tool";
+            const toolContent = extractContent(block.content);
+            parts.push(buildToolResultBlock(toolName, toolCallId, toolContent));
+          }
+        }
+        const joined = parts.filter(Boolean).join("\n");
+        if (joined) result.push({ role: ROLE.USER, content: joined });
+        continue;
+      }
+
+      const content = extractContent(msg.content);
+
+      if (msg.role === ROLE.ASSISTANT && msg.tool_calls && msg.tool_calls.length > 0) {
+        const assistantMsg = { role: ROLE.ASSISTANT, content: content || "" };
+        assistantMsg.tool_calls = msg.tool_calls.map(tc => {
+          const { index, ...rest } = tc || {};
+          return rest;
+        });
+        result.push(assistantMsg);
+      } else if (msg.role === ROLE.ASSISTANT && Array.isArray(msg.content)) {
+        const extractedToolCalls = msg.content
+          .filter(b => b?.type === CLAUDE_BLOCK.TOOL_USE)
+          .map(b => ({
+            id: b.id || "",
+            type: OPENAI_BLOCK.FUNCTION,
+            function: {
+              name: b.name || "tool",
+              arguments: JSON.stringify(b.input || {})
+            }
+          }))
+          .filter(tc => tc.id);
+
+        if (extractedToolCalls.length > 0) {
+          result.push({
+            role: ROLE.ASSISTANT,
+            content: content || "",
+            tool_calls: extractedToolCalls
+          });
+        } else if (content) {
+          result.push({ role: ROLE.ASSISTANT, content });
+        }
+      } else {
+        if (content) {
+          result.push({ role: msg.role, content });
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+export function openaiToCursorRequest(model, body, stream, credentials) {
+  const messages = convertMessages(body.messages || []);
+
+  const { user, metadata, tool_choice, stream_options, system, ...rest } = body;
+
+  return {
+    ...rest,
+    messages,
+    max_tokens: DEFAULT_MIN_TOKENS
+  };
+}
+
+register(FORMATS.OPENAI, FORMATS.CURSOR, openaiToCursorRequest, null);