swayrouter 1.0.0

package/src/translator/formats/gemini.js

@@ -0,0 +1,366 @@
+import { safeParseJSON } from "../concerns/json.js";
+import { OPENAI_BLOCK } from "../schema/index.js";
+
+export const UNSUPPORTED_SCHEMA_CONSTRAINTS = [
+
+  "minLength", "maxLength", "exclusiveMinimum", "exclusiveMaximum",
+  "minItems", "maxItems", "format", "multipleOf",
+
+  "uniqueItems", "contains",
+
+  "unevaluatedProperties", "unevaluatedItems", "contentSchema",
+
+  "default", "examples",
+
+  "$schema", "$defs", "definitions", "const", "$ref", "$comment",
+
+  "deprecated", "readOnly", "writeOnly",
+
+  "additionalProperties", "propertyNames", "patternProperties", "enumDescriptions",
+
+  "anyOf", "oneOf", "allOf", "not",
+
+  "dependencies", "dependentSchemas", "dependentRequired",
+
+  "title", "optional", "deprecated", "if", "then", "else", "contentMediaType", "contentEncoding",
+
+  "cornerRadius", "fillColor", "fontFamily", "fontSize", "fontWeight",
+  "gap", "padding", "strokeColor", "strokeThickness", "textColor"
+];
+
+export const DEFAULT_SAFETY_SETTINGS = [
+  { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "OFF" },
+  { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_HARASSMENT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "OFF" }
+];
+
+export function convertOpenAIContentToParts(content) {
+  const parts = [];
+
+  if (typeof content === "string") {
+    parts.push({ text: content });
+  } else if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item.type === OPENAI_BLOCK.TEXT) {
+        parts.push({ text: item.text });
+      } else if (item.type === OPENAI_BLOCK.IMAGE_URL && item.image_url?.url?.startsWith("data:")) {
+        const url = item.image_url.url;
+        const commaIndex = url.indexOf(",");
+        if (commaIndex !== -1) {
+          const mimePart = url.substring(5, commaIndex);
+          const data = url.substring(commaIndex + 1);
+          const mimeType = mimePart.split(";")[0];
+
+          parts.push({
+            inlineData: { mime_type: mimeType, data: data }
+          });
+        }
+      } else if (item.type === OPENAI_BLOCK.IMAGE_URL && item.image_url?.url && (item.image_url.url.startsWith("http://") || item.image_url.url.startsWith("https://"))) {
+        parts.push({
+          fileData: { fileUri: item.image_url.url, mimeType: "image/*" }
+        });
+      } else if (item.type === OPENAI_BLOCK.INPUT_AUDIO && item.input_audio?.data) {
+        const format = item.input_audio.format || "wav";
+        const mimeType = format === "mp3" ? "audio/mpeg" : `audio/${format}`;
+        parts.push({
+          inlineData: { mime_type: mimeType, data: item.input_audio.data }
+        });
+      } else if (item.type === OPENAI_BLOCK.AUDIO_URL && item.audio_url?.url?.startsWith("data:")) {
+        const url = item.audio_url.url;
+        const commaIndex = url.indexOf(",");
+        if (commaIndex !== -1) {
+          const mimePart = url.substring(5, commaIndex);
+          const data = url.substring(commaIndex + 1);
+          const mimeType = mimePart.split(";")[0];
+          parts.push({
+            inlineData: { mime_type: mimeType, data: data }
+          });
+        }
+      } else if (item.type === OPENAI_BLOCK.FILE && item.file?.file_data?.startsWith("data:")) {
+        const url = item.file.file_data;
+        const commaIndex = url.indexOf(",");
+        if (commaIndex !== -1) {
+          const mimeType = url.substring(5, commaIndex).split(";")[0];
+          const data = url.substring(commaIndex + 1);
+          parts.push({ inlineData: { mime_type: mimeType, data: data } });
+        }
+      }
+    }
+  }
+
+  return parts;
+}
+
+export function extractTextContent(content, separator = "") {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter(c => c.type === OPENAI_BLOCK.TEXT).map(c => c.text).join(separator);
+  }
+  return "";
+}
+
+export function tryParseJSON(str) {
+  return safeParseJSON(str, null);
+}
+
+export function generateRequestId() {
+  return `agent-${crypto.randomUUID()}`;
+}
+
+export function generateSessionId() {
+  return crypto.randomUUID() + Date.now().toString();
+}
+
+export function generateProjectId() {
+  const adjectives = ["useful", "bright", "swift", "calm", "bold"];
+  const nouns = ["fuze", "wave", "spark", "flow", "core"];
+  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
+  const noun = nouns[Math.floor(Math.random() * nouns.length)];
+  return `${adj}-${noun}-${crypto.randomUUID().slice(0, 5)}`;
+}
+
+function removeUnsupportedKeywords(obj, keywords) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      removeUnsupportedKeywords(item, keywords);
+    }
+    return;
+  }
+
+  for (const key of Object.keys(obj)) {
+    if (keywords.includes(key) || key.startsWith("x-")) {
+      delete obj[key];
+      continue;
+    }
+
+    const value = obj[key];
+    if (value && typeof value === "object") {
+      removeUnsupportedKeywords(value, keywords);
+    }
+  }
+}
+
+function convertConstToEnum(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.const !== undefined && !obj.enum) {
+    obj.enum = [obj.const];
+    delete obj.const;
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      convertConstToEnum(value);
+    }
+  }
+}
+
+function convertEnumValuesToStrings(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.enum && Array.isArray(obj.enum)) {
+    obj.enum = obj.enum.map(v => String(v));
+
+    if (!obj.type) {
+      obj.type = "string";
+    }
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      convertEnumValuesToStrings(value);
+    }
+  }
+}
+
+function mergeAllOf(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.allOf && Array.isArray(obj.allOf)) {
+    const merged = {};
+
+    for (const item of obj.allOf) {
+      if (item.properties) {
+        if (!merged.properties) merged.properties = {};
+        Object.assign(merged.properties, item.properties);
+      }
+      if (item.required && Array.isArray(item.required)) {
+        if (!merged.required) merged.required = [];
+        for (const req of item.required) {
+          if (!merged.required.includes(req)) {
+            merged.required.push(req);
+          }
+        }
+      }
+    }
+
+    delete obj.allOf;
+    if (merged.properties) obj.properties = { ...obj.properties, ...merged.properties };
+    if (merged.required) obj.required = [...(obj.required || []), ...merged.required];
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      mergeAllOf(value);
+    }
+  }
+}
+
+function selectBest(items) {
+  let bestIdx = 0;
+  let bestScore = -1;
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    let score = 0;
+    const type = item.type;
+
+    if (type === "object" || item.properties) {
+      score = 3;
+    } else if (type === "array" || item.items) {
+      score = 2;
+    } else if (type && type !== "null") {
+      score = 1;
+    }
+
+    if (score > bestScore) {
+      bestScore = score;
+      bestIdx = i;
+    }
+  }
+
+  return bestIdx;
+}
+
+function flattenAnyOfOneOf(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.anyOf && Array.isArray(obj.anyOf) && obj.anyOf.length > 0) {
+    const nonNullSchemas = obj.anyOf.filter(s => s && s.type !== "null");
+    if (nonNullSchemas.length > 0) {
+      const bestIdx = selectBest(nonNullSchemas);
+      const selected = nonNullSchemas[bestIdx];
+      delete obj.anyOf;
+      Object.assign(obj, selected);
+    }
+  }
+
+  if (obj.oneOf && Array.isArray(obj.oneOf) && obj.oneOf.length > 0) {
+    const nonNullSchemas = obj.oneOf.filter(s => s && s.type !== "null");
+    if (nonNullSchemas.length > 0) {
+      const bestIdx = selectBest(nonNullSchemas);
+      const selected = nonNullSchemas[bestIdx];
+      delete obj.oneOf;
+      Object.assign(obj, selected);
+    }
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      flattenAnyOfOneOf(value);
+    }
+  }
+}
+
+function flattenTypeArrays(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.type && Array.isArray(obj.type)) {
+    const nonNullTypes = obj.type.filter(t => t !== "null");
+    obj.type = nonNullTypes.length > 0 ? nonNullTypes[0] : "string";
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      flattenTypeArrays(value);
+    }
+  }
+}
+
+function ensureObjectType(obj) {
+  if (!obj || typeof obj !== "object") return;
+  if (obj.properties && !obj.type) obj.type = "object";
+  for (const v of Object.values(obj)) if (v && typeof v === "object") ensureObjectType(v);
+}
+
+export function cleanJSONSchemaForAntigravity(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+
+  let cleaned = schema;
+
+  convertConstToEnum(cleaned);
+  convertEnumValuesToStrings(cleaned);
+
+  mergeAllOf(cleaned);
+  flattenAnyOfOneOf(cleaned);
+  flattenTypeArrays(cleaned);
+
+  ensureObjectType(cleaned);
+
+  removeUnsupportedKeywords(cleaned, UNSUPPORTED_SCHEMA_CONSTRAINTS);
+
+  function cleanupRequired(obj) {
+    if (!obj || typeof obj !== "object") return;
+
+    if (obj.required && Array.isArray(obj.required) && obj.properties) {
+      const validRequired = obj.required.filter(field =>
+        Object.prototype.hasOwnProperty.call(obj.properties, field)
+      );
+      if (validRequired.length === 0) {
+        delete obj.required;
+      } else {
+        obj.required = validRequired;
+      }
+    }
+
+    for (const value of Object.values(obj)) {
+      if (value && typeof value === "object") {
+        cleanupRequired(value);
+      }
+    }
+  }
+
+  cleanupRequired(cleaned);
+
+  function addPlaceholders(obj) {
+    if (!obj || typeof obj !== "object") return;
+
+    if (Object.keys(obj).length === 0) {
+      obj.type = "object";
+      obj.properties = {
+        reason: {
+          type: "string",
+          description: "Brief explanation of why you are calling this tool"
+        }
+      };
+      obj.required = ["reason"];
+      return;
+    }
+
+    if (obj.type === "object") {
+      if (!obj.properties || Object.keys(obj.properties).length === 0) {
+        obj.properties = {
+          reason: {
+            type: "string",
+            description: "Brief explanation of why you are calling this tool"
+          }
+        };
+        obj.required = ["reason"];
+      }
+    }
+
+    for (const value of Object.values(obj)) {
+      if (value && typeof value === "object") {
+        addPlaceholders(value);
+      }
+    }
+  }
+
+  addPlaceholders(cleaned);
+
+  return cleaned;
+}

package/src/translator/formats/maxTokens.js

@@ -0,0 +1,19 @@
+import { DEFAULT_MAX_TOKENS, DEFAULT_MIN_TOKENS } from "../../config/runtimeConfig.js";
+
+export function adjustMaxTokens(body, ceiling = DEFAULT_MAX_TOKENS) {
+  let maxTokens = body.max_tokens || DEFAULT_MAX_TOKENS;
+
+  if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
+    if (maxTokens < DEFAULT_MIN_TOKENS) {
+      maxTokens = DEFAULT_MIN_TOKENS;
+    }
+  }
+
+  if (body.thinking?.budget_tokens && maxTokens <= body.thinking.budget_tokens) {
+    maxTokens = body.thinking.budget_tokens + 1024;
+  }
+
+  if (maxTokens > ceiling) maxTokens = ceiling;
+
+  return maxTokens;
+}

package/src/translator/formats/openai.js

@@ -0,0 +1,116 @@
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK, VALID_OPENAI_CONTENT_TYPES, VALID_OPENAI_MESSAGE_TYPES } from "../schema/index.js";
+
+export { VALID_OPENAI_CONTENT_TYPES, VALID_OPENAI_MESSAGE_TYPES };
+
+export function filterToOpenAIFormat(body, opts = {}) {
+  if (!body.messages || !Array.isArray(body.messages)) return body;
+  const keepCache = !!opts.preserveCacheControl;
+
+  function stripBlock(block) {
+    const { signature, cache_control, ...rest } = block;
+    return keepCache && cache_control ? { ...rest, cache_control } : rest;
+  }
+
+  body.messages = body.messages.map(msg => {
+
+    if (msg.role === ROLE.DEVELOPER) msg = { ...msg, role: ROLE.SYSTEM };
+
+    if (msg.role === ROLE.TOOL) return msg;
+
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) return msg;
+
+    if (typeof msg.content === "string") return msg;
+
+    if (Array.isArray(msg.content)) {
+      const filteredContent = [];
+
+      for (const block of msg.content) {
+
+        if (block.type === CLAUDE_BLOCK.THINKING || block.type === CLAUDE_BLOCK.REDACTED_THINKING) continue;
+
+        if (VALID_OPENAI_CONTENT_TYPES.includes(block.type)) {
+          filteredContent.push(stripBlock(block));
+        } else if (block.type === CLAUDE_BLOCK.TOOL_USE) {
+
+          continue;
+        } else if (block.type === CLAUDE_BLOCK.TOOL_RESULT) {
+
+          filteredContent.push(stripBlock(block));
+        }
+      }
+
+      if (filteredContent.length === 0) {
+        filteredContent.push({ type: OPENAI_BLOCK.TEXT, text: "" });
+      }
+
+      return { ...msg, content: filteredContent };
+    }
+
+    return msg;
+  });
+
+  body.messages = body.messages.filter(msg => {
+
+    if (msg.role === ROLE.TOOL) return true;
+
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) return true;
+
+    if (typeof msg.content === "string") return msg.content.trim() !== "";
+    if (Array.isArray(msg.content)) {
+      return msg.content.some(b =>
+        (b.type === OPENAI_BLOCK.TEXT && b.text?.trim()) ||
+        b.type !== OPENAI_BLOCK.TEXT
+      );
+    }
+    return true;
+  });
+
+  if (body.tools && Array.isArray(body.tools) && body.tools.length === 0) {
+    delete body.tools;
+  }
+
+  if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
+    body.tools = body.tools.map(tool => {
+
+      if (tool.type === OPENAI_BLOCK.FUNCTION && tool.function) return tool;
+
+      if (tool.name && (tool.input_schema || tool.description)) {
+        return {
+          type: OPENAI_BLOCK.FUNCTION,
+          function: {
+            name: tool.name,
+            description: String(tool.description || ""),
+            parameters: tool.input_schema || { type: "object", properties: {} }
+          }
+        };
+      }
+
+      if (tool.functionDeclarations && Array.isArray(tool.functionDeclarations)) {
+        return tool.functionDeclarations.map(fn => ({
+          type: OPENAI_BLOCK.FUNCTION,
+          function: {
+            name: fn.name,
+            description: String(fn.description || ""),
+            parameters: fn.parameters || { type: "object", properties: {} }
+          }
+        }));
+      }
+
+      return tool;
+    }).flat();
+  }
+
+  if (body.tool_choice && typeof body.tool_choice === "object") {
+    const choice = body.tool_choice;
+
+    if (choice.type === "auto") {
+      body.tool_choice = "auto";
+    } else if (choice.type === "any") {
+      body.tool_choice = "required";
+    } else if (choice.type === "tool" && choice.name) {
+      body.tool_choice = { type: OPENAI_BLOCK.FUNCTION, function: { name: choice.name } };
+    }
+  }
+
+  return body;
+}

package/src/translator/formats/responsesApi.js

@@ -0,0 +1,117 @@
+import { ROLE, OPENAI_BLOCK, RESPONSES_ITEM } from "../schema/index.js";
+
+export function normalizeResponsesInput(input) {
+  if (typeof input === "string") {
+    return [{ type: RESPONSES_ITEM.MESSAGE, role: ROLE.USER, content: [{ type: RESPONSES_ITEM.INPUT_TEXT, text: input }] }];
+  }
+  if (Array.isArray(input)) {
+    return input;
+  }
+  return null;
+}
+
+export function convertResponsesApiFormat(body) {
+  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 pendingToolCalls = [];
+  let pendingToolResults = [];
+
+  const inputItems = normalizeResponsesInput(body.input);
+  if (!inputItems) return body;
+
+  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;
+      result.messages.push({ role: item.role, content });
+    }
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL) {
+
+      if (!currentAssistantMsg) {
+        currentAssistantMsg = {
+          role: ROLE.ASSISTANT,
+          content: null,
+          tool_calls: []
+        };
+      }
+
+      if (!item.name || typeof item.name !== "string" || item.name.trim() === "") continue;
+      currentAssistantMsg.tool_calls.push({
+        id: item.call_id,
+        type: OPENAI_BLOCK.FUNCTION,
+        function: {
+          name: item.name,
+          arguments: item.arguments
+        }
+      });
+    }
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL_OUTPUT) {
+
+      if (currentAssistantMsg) {
+        result.messages.push(currentAssistantMsg);
+        currentAssistantMsg = null;
+      }
+
+      pendingToolResults.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.REASONING) {
+
+      continue;
+    }
+  }
+
+  if (currentAssistantMsg) {
+    result.messages.push(currentAssistantMsg);
+  }
+  if (pendingToolResults.length > 0) {
+    for (const tr of pendingToolResults) {
+      result.messages.push(tr);
+    }
+  }
+
+  delete result.input;
+  delete result.instructions;
+  delete result.include;
+  delete result.prompt_cache_key;
+  delete result.store;
+  delete result.reasoning;
+
+  return result;
+}

package/src/translator/formats.js

@@ -0,0 +1,28 @@
+export const FORMATS = {
+  OPENAI: "openai",
+  OPENAI_RESPONSES: "openai-responses",
+  OPENAI_RESPONSE: "openai-response",
+  CLAUDE: "claude",
+  GEMINI: "gemini",
+  GEMINI_CLI: "gemini-cli",
+  VERTEX: "vertex",
+  CODEX: "codex",
+  ANTIGRAVITY: "antigravity",
+  KIRO: "kiro",
+  CURSOR: "cursor",
+  OLLAMA: "ollama",
+  COMMANDCODE: "commandcode"
+};
+
+export function detectFormatByEndpoint(pathname, body) {
+
+  if (pathname.includes("/v1/responses")) return FORMATS.OPENAI_RESPONSES;
+
+  if (pathname.includes("/v1/messages")) return FORMATS.CLAUDE;
+
+  if (pathname.includes("/v1/chat/completions") && Array.isArray(body?.input)) {
+    return FORMATS.OPENAI;
+  }
+
+  return null;
+}