swayrouter 1.0.0

package/src/translator/index.js

@@ -0,0 +1,237 @@
+import { FORMATS } from "./formats.js";
+import { ensureToolCallIds, fixMissingToolResponses } from "./concerns/toolCall.js";
+import { prepareClaudeRequest } from "./formats/claude.js";
+import { filterToOpenAIFormat } from "./formats/openai.js";
+import { normalizeThinkingConfig } from "../services/provider.js";
+import { applyThinking, captureThinking } from "./concerns/thinkingUnified.js";
+import { captureSessionId } from "../utils/sessionManager.js";
+import { AntigravityExecutor } from "../executors/antigravity.js";
+import { PROVIDERS } from "../providers/index.js";
+
+export { inferFeatureIntent, normalizeTranslationRequest, resolveTranslationSurface, unsupportedFeatures } from "./canonical.js";
+
+var requestRegistry;
+var responseRegistry;
+
+export function register(from, to, requestFn, responseFn) {
+  requestRegistry ??= new Map();
+  responseRegistry ??= new Map();
+  const key = `${from}:${to}`;
+  if (requestFn) {
+    requestRegistry.set(key, requestFn);
+  }
+  if (responseFn) {
+    responseRegistry.set(key, responseFn);
+  }
+}
+
+function ensureInitialized() {}
+
+function stripContentTypes(body, stripList = []) {
+  if (!stripList.length || !body.messages || !Array.isArray(body.messages)) return;
+  const imageTypes = new Set(["image_url", "image"]);
+  const audioTypes = new Set(["audio_url", "input_audio"]);
+  const shouldStrip = (type) => {
+    if (imageTypes.has(type)) return stripList.includes("image");
+    if (audioTypes.has(type)) return stripList.includes("audio");
+    return false;
+  };
+  for (const msg of body.messages) {
+    if (!Array.isArray(msg.content)) continue;
+    msg.content = msg.content.filter(part => !shouldStrip(part.type));
+    if (msg.content.length === 0) msg.content = "";
+  }
+}
+
+export function translateRequest(sourceFormat, targetFormat, model, body, stream = true, credentials = null, provider = null, reqLogger = null, stripList = [], connectionId = null, clientTool = null, capabilityOverride = null) {
+  ensureInitialized();
+  let result = body;
+
+  stripContentTypes(result, stripList);
+
+  normalizeThinkingConfig(result);
+
+  ensureToolCallIds(result);
+
+  if (targetFormat !== FORMATS.KIRO) {
+    fixMissingToolResponses(result);
+  }
+
+  const thinkingIntent = captureThinking(result);
+
+  const clientSessionId = captureSessionId(result, credentials, connectionId, targetFormat);
+
+  if (credentials) credentials._clientSessionId = clientSessionId;
+
+  if (sourceFormat !== targetFormat) {
+
+    const directFn = requestRegistry.get(`${sourceFormat}:${targetFormat}`);
+    if (directFn) {
+      result = directFn(model, result, stream, credentials);
+    } else {
+
+      if (sourceFormat !== FORMATS.OPENAI) {
+        const toOpenAI = requestRegistry.get(`${sourceFormat}:${FORMATS.OPENAI}`);
+        if (toOpenAI) {
+          result = toOpenAI(model, result, stream, credentials);
+
+          reqLogger?.logOpenAIRequest?.(result);
+        }
+      }
+
+      if (targetFormat !== FORMATS.OPENAI) {
+        const fromOpenAI = requestRegistry.get(`${FORMATS.OPENAI}:${targetFormat}`);
+        if (fromOpenAI) {
+          result = fromOpenAI(model, result, stream, credentials);
+        }
+      }
+    }
+  }
+
+  const kiroThinkingMappedByTranslator =
+    targetFormat === FORMATS.KIRO &&
+    (sourceFormat === FORMATS.OPENAI || sourceFormat === FORMATS.CLAUDE);
+  if (!kiroThinkingMappedByTranslator) {
+    applyThinking(targetFormat, model, result, provider, thinkingIntent, capabilityOverride);
+  }
+
+  if (targetFormat === FORMATS.OPENAI) {
+    result = filterToOpenAIFormat(result, {
+      preserveCacheControl: !!PROVIDERS[provider]?.quirks?.preserveCacheControl,
+    });
+  }
+
+  if (targetFormat === FORMATS.CLAUDE) {
+    const apiKey = credentials?.accessToken || credentials?.apiKey || null;
+    result = prepareClaudeRequest(result, provider, apiKey, connectionId, credentials?.rawHeaders, clientSessionId);
+  }
+
+  return result;
+}
+
+export function translateResponse(targetFormat, sourceFormat, chunk, state) {
+  ensureInitialized();
+
+  if (sourceFormat === targetFormat) {
+    return [chunk];
+  }
+
+  let results = [chunk];
+  let openaiResults = null;
+
+  const directFn = responseRegistry.get(`${targetFormat}:${sourceFormat}`);
+  if (directFn) {
+    const converted = directFn(chunk, state);
+    return converted ? (Array.isArray(converted) ? converted : [converted]) : [];
+  }
+
+  if (targetFormat !== FORMATS.OPENAI) {
+    const toOpenAI = responseRegistry.get(`${targetFormat}:${FORMATS.OPENAI}`);
+    if (toOpenAI) {
+      results = [];
+      const converted = toOpenAI(chunk, state);
+      if (converted) {
+        results = Array.isArray(converted) ? converted : [converted];
+        openaiResults = results;
+      }
+    }
+  }
+
+  if (sourceFormat !== FORMATS.OPENAI) {
+    const fromOpenAI = responseRegistry.get(`${FORMATS.OPENAI}:${sourceFormat}`);
+    if (fromOpenAI) {
+      const finalResults = [];
+      for (const r of results) {
+        const converted = fromOpenAI(r, state);
+        if (converted) {
+          finalResults.push(...(Array.isArray(converted) ? converted : [converted]));
+        }
+      }
+      results = finalResults;
+    }
+  }
+
+  if (openaiResults && sourceFormat !== FORMATS.OPENAI && targetFormat !== FORMATS.OPENAI) {
+    results._openaiIntermediate = openaiResults;
+  }
+
+  return results;
+}
+
+export function needsTranslation(sourceFormat, targetFormat) {
+  return sourceFormat !== targetFormat;
+}
+
+export function initState(sourceFormat) {
+
+  const base = {
+    messageId: null,
+    model: null,
+    textBlockStarted: false,
+    thinkingBlockStarted: false,
+    inThinkingBlock: false,
+    currentBlockIndex: null,
+    toolCalls: new Map(),
+    finishReason: null,
+    finishReasonSent: false,
+    usage: null,
+    contentBlockIndex: -1
+  };
+
+  if (sourceFormat === FORMATS.OPENAI_RESPONSES) {
+    return {
+      ...base,
+      seq: 0,
+      responseId: `resp_${Date.now()}`,
+      created: Math.floor(Date.now() / 1000),
+      started: false,
+      msgTextBuf: {},
+      msgItemAdded: {},
+      msgContentAdded: {},
+      msgItemDone: {},
+      reasoningId: "",
+      reasoningIndex: -1,
+      reasoningBuf: "",
+      reasoningPartAdded: false,
+      reasoningDone: false,
+      inThinking: false,
+      funcArgsBuf: {},
+      funcNames: {},
+      funcCallIds: {},
+      funcItemAdded: {},
+      funcArgsDone: {},
+      funcItemDone: {},
+      customToolNames: new Set(),
+      completedSent: false
+    };
+  }
+
+  return base;
+}
+
+export function initTranslators() {
+  ensureInitialized();
+}
+
+import "./request/claude-to-openai.js";
+import "./request/openai-to-claude.js";
+import "./request/gemini-to-openai.js";
+import "./request/openai-to-gemini.js";
+import "./request/openai-to-vertex.js";
+import "./request/antigravity-to-openai.js";
+import "./request/openai-responses.js";
+import "./request/openai-to-kiro.js";
+import "./request/openai-to-cursor.js";
+import "./request/openai-to-ollama.js";
+import "./request/openai-to-commandcode.js";
+import "./request/claude-to-kiro.js";
+import "./response/claude-to-openai.js";
+import "./response/openai-to-claude.js";
+import "./response/gemini-to-openai.js";
+import "./response/openai-to-antigravity.js";
+import "./response/openai-responses.js";
+import "./response/kiro-to-openai.js";
+import "./response/cursor-to-openai.js";
+import "./response/ollama-to-openai.js";
+import "./response/commandcode-to-openai.js";
+import "./response/kiro-to-claude.js";

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

@@ -0,0 +1,217 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { adjustMaxTokens } from "../formats/maxTokens.js";
+import { encodeDataUri } from "../concerns/image.js";
+import { ROLE, GEMINI_ROLE, OPENAI_BLOCK } from "../schema/index.js";
+import { budgetToEffort } from "../concerns/thinking.js";
+import { collapseTextParts } from "../concerns/message.js";
+
+export function antigravityToOpenAIRequest(model, body, stream) {
+  const req = body.request || body;
+  const result = {
+    model: model,
+    messages: [],
+    stream: stream
+  };
+
+  if (req.generationConfig) {
+    const config = req.generationConfig;
+    if (config.maxOutputTokens) {
+      const tempBody = { max_tokens: config.maxOutputTokens, tools: req.tools };
+      result.max_tokens = adjustMaxTokens(tempBody);
+    }
+    if (config.temperature !== undefined) {
+      result.temperature = config.temperature;
+    }
+    if (config.topP !== undefined) {
+      result.top_p = config.topP;
+    }
+    if (config.topK !== undefined) {
+      result.top_k = config.topK;
+    }
+
+    if (config.thinkingConfig) {
+      const effort = budgetToEffort(config.thinkingConfig.thinkingBudget || 0);
+      if (effort) result.reasoning_effort = effort;
+    }
+  }
+
+  if (req.systemInstruction) {
+    const systemText = extractText(req.systemInstruction);
+    if (systemText) {
+      result.messages.push({ role: ROLE.SYSTEM, content: systemText });
+    }
+  }
+
+  if (req.contents && Array.isArray(req.contents)) {
+    for (const content of req.contents) {
+      const converted = convertContent(content);
+      if (converted) {
+        if (Array.isArray(converted)) {
+          result.messages.push(...converted);
+        } else {
+          result.messages.push(converted);
+        }
+      }
+    }
+  }
+
+  if (req.tools && Array.isArray(req.tools)) {
+    result.tools = [];
+    for (const tool of req.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: normalizeSchemaTypes(func.parameters) || { type: "object", properties: {} }
+            }
+          });
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+function normalizeSchemaTypes(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+
+  const result = Array.isArray(schema) ? [...schema] : { ...schema };
+
+  if (typeof result.type === "string") {
+    result.type = result.type.toLowerCase();
+  }
+
+  delete result.enumDescriptions;
+
+  if (result.properties) {
+    const normalized = {};
+    for (const [key, val] of Object.entries(result.properties)) {
+      normalized[key] = normalizeSchemaTypes(val);
+    }
+    result.properties = normalized;
+  }
+
+  if (result.items) {
+    result.items = normalizeSchemaTypes(result.items);
+  }
+
+  return result;
+}
+
+function convertContent(content) {
+  const role = content.role === GEMINI_ROLE.MODEL ? ROLE.ASSISTANT : content.role === GEMINI_ROLE.USER ? ROLE.USER : content.role;
+
+  if (!content.parts || !Array.isArray(content.parts)) {
+    return null;
+  }
+
+  const textParts = [];
+  const toolCalls = [];
+  const toolResults = [];
+  let reasoningContent = "";
+
+  for (const part of content.parts) {
+
+    if (part.thought === true && part.text) {
+      reasoningContent += part.text;
+      continue;
+    }
+
+    if (part.thoughtSignature && part.text !== undefined) {
+      if (part.text) {
+        textParts.push({ type: OPENAI_BLOCK.TEXT, text: part.text });
+      }
+      continue;
+    }
+
+    if (part.text !== undefined && part.text !== "") {
+      textParts.push({ type: OPENAI_BLOCK.TEXT, text: part.text });
+    }
+
+    if (part.inlineData) {
+      textParts.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) {
+      toolResults.push({
+        role: ROLE.TOOL,
+        tool_call_id: part.functionResponse.id || `call_${part.functionResponse.name}`,
+        content: JSON.stringify(part.functionResponse.response?.result || part.functionResponse.response || {})
+      });
+    }
+  }
+
+  if (toolResults.length > 0) {
+    if (toolCalls.length > 0 || textParts.length > 0 || reasoningContent) {
+      const assistantMsg = { role: ROLE.ASSISTANT };
+      if (textParts.length > 0) {
+        assistantMsg.content = collapseTextParts(textParts);
+      }
+      if (reasoningContent) {
+        assistantMsg.reasoning_content = reasoningContent;
+      }
+      if (toolCalls.length > 0) {
+        assistantMsg.tool_calls = toolCalls;
+      }
+      return [...toolResults, assistantMsg];
+    }
+    return toolResults;
+  }
+
+  if (toolCalls.length > 0) {
+    const msg = { role: ROLE.ASSISTANT };
+    if (textParts.length > 0) {
+      msg.content = collapseTextParts(textParts);
+    }
+    if (reasoningContent) {
+      msg.reasoning_content = reasoningContent;
+    }
+    msg.tool_calls = toolCalls;
+    return msg;
+  }
+
+  if (textParts.length > 0 || reasoningContent) {
+    const msg = { role };
+    if (textParts.length > 0) {
+      msg.content = collapseTextParts(textParts);
+    }
+    if (reasoningContent) {
+      msg.reasoning_content = reasoningContent;
+    }
+    return msg;
+  }
+
+  return null;
+}
+
+function extractText(instruction) {
+  if (typeof instruction === "string") return instruction;
+  if (instruction.parts && Array.isArray(instruction.parts)) {
+    return instruction.parts.map(p => p.text || "").join("");
+  }
+  return "";
+}
+
+register(FORMATS.ANTIGRAVITY, FORMATS.OPENAI, antigravityToOpenAIRequest, null);