@khanglvm/llm-router 1.0.5

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

@@ -0,0 +1,241 @@
+/**
+ * OpenAI -> Claude request translator.
+ */
+
+const DEFAULT_MAX_TOKENS = 1024;
+
+function safeJsonParse(raw, fallback = {}) {
+  if (typeof raw !== "string" || raw.length === 0) return fallback;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+function normalizeTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const text = [];
+    for (const part of content) {
+      if (!part || typeof part !== "object") continue;
+      if ((part.type === "text" || part.type === "input_text") && typeof part.text === "string") {
+        text.push(part.text);
+      }
+    }
+    return text.join("\n");
+  }
+  return "";
+}
+
+function parseDataUrl(url) {
+  if (typeof url !== "string") return null;
+  const match = url.match(/^data:([^;]+);base64,(.+)$/);
+  if (!match) return null;
+  return {
+    mediaType: match[1],
+    data: match[2]
+  };
+}
+
+function convertOpenAIContentToClaudeBlocks(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", text: content }];
+  }
+
+  if (!Array.isArray(content)) {
+    return [{ type: "text", text: "" }];
+  }
+
+  const blocks = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+
+    if ((part.type === "text" || part.type === "input_text") && typeof part.text === "string") {
+      blocks.push({ type: "text", text: part.text });
+      continue;
+    }
+
+    if (part.type === "image_url" && part.image_url?.url) {
+      const parsed = parseDataUrl(part.image_url.url);
+      if (parsed) {
+        blocks.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: parsed.mediaType,
+            data: parsed.data
+          }
+        });
+      } else {
+        // Claude image blocks do not accept remote URLs directly.
+        blocks.push({
+          type: "text",
+          text: `[image_url:${part.image_url.url}]`
+        });
+      }
+      continue;
+    }
+  }
+
+  if (blocks.length === 0) {
+    blocks.push({ type: "text", text: "" });
+  }
+  return blocks;
+}
+
+function mapToolChoice(choice) {
+  if (!choice) return undefined;
+  if (typeof choice === "string") {
+    if (choice === "required") return { type: "any" };
+    if (choice === "none") return { type: "auto" };
+    return { type: "auto" };
+  }
+
+  if (choice.type === "function") {
+    return {
+      type: "tool",
+      name: choice.function?.name
+    };
+  }
+
+  if (choice.type === "auto") return { type: "auto" };
+  if (choice.type === "any") return { type: "any" };
+  if (choice.type === "tool") return { type: "tool", name: choice.name };
+
+  return { type: "auto" };
+}
+
+function normalizeSystemText(messages, explicitSystem) {
+  const parts = [];
+  if (typeof explicitSystem === "string" && explicitSystem.trim()) {
+    parts.push(explicitSystem);
+  } else if (Array.isArray(explicitSystem)) {
+    for (const item of explicitSystem) {
+      if (item?.type === "text" && typeof item.text === "string") {
+        parts.push(item.text);
+      }
+    }
+  }
+
+  for (const message of messages) {
+    if (message?.role !== "system") continue;
+    const text = normalizeTextContent(message.content);
+    if (text) parts.push(text);
+  }
+
+  return parts.join("\n").trim();
+}
+
+function convertOpenAIMessages(messages) {
+  const result = [];
+
+  for (const message of messages) {
+    if (!message || typeof message !== "object") continue;
+
+    if (message.role === "system") {
+      continue;
+    }
+
+    if (message.role === "tool") {
+      const toolUseId = message.tool_call_id || message.tool_use_id;
+      if (!toolUseId) continue;
+
+      const content = normalizeTextContent(message.content);
+      result.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: toolUseId,
+            content
+          }
+        ]
+      });
+      continue;
+    }
+
+    if (message.role === "assistant") {
+      const contentBlocks = convertOpenAIContentToClaudeBlocks(message.content);
+      const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+
+      for (const call of toolCalls) {
+        if (!call || typeof call !== "object") continue;
+        contentBlocks.push({
+          type: "tool_use",
+          id: call.id || `tool_${Date.now()}`,
+          name: call.function?.name || "tool",
+          input: safeJsonParse(call.function?.arguments, {})
+        });
+      }
+
+      result.push({
+        role: "assistant",
+        content: contentBlocks
+      });
+      continue;
+    }
+
+    // default user role
+    result.push({
+      role: "user",
+      content: convertOpenAIContentToClaudeBlocks(message.content)
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Convert OpenAI chat completion request to Claude messages request.
+ */
+export function openAIToClaudeRequest(model, body, stream = false) {
+  const messages = Array.isArray(body?.messages) ? body.messages : [];
+  const result = {
+    model,
+    messages: convertOpenAIMessages(messages),
+    stream: Boolean(stream),
+    max_tokens: Number.isFinite(body?.max_tokens)
+      ? Number(body.max_tokens)
+      : (Number.isFinite(body?.max_completion_tokens) ? Number(body.max_completion_tokens) : DEFAULT_MAX_TOKENS)
+  };
+
+  const system = normalizeSystemText(messages, body?.system);
+  if (system) {
+    result.system = system;
+  }
+
+  if (body?.temperature !== undefined) {
+    result.temperature = body.temperature;
+  }
+
+  if (Array.isArray(body?.tools)) {
+    result.tools = body.tools
+      .map((tool) => {
+        if (!tool || typeof tool !== "object") return null;
+        if (tool.type === "function" && tool.function) {
+          return {
+            name: tool.function.name,
+            description: tool.function.description,
+            input_schema: tool.function.parameters || { type: "object", properties: {} }
+          };
+        }
+        if (tool.name) {
+          return {
+            name: tool.name,
+            description: tool.description,
+            input_schema: tool.input_schema || { type: "object", properties: {} }
+          };
+        }
+        return null;
+      })
+      .filter(Boolean);
+  }
+
+  const mappedChoice = mapToolChoice(body?.tool_choice);
+  if (mappedChoice) {
+    result.tool_choice = mappedChoice;
+  }
+
+  return result;
+}

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

@@ -0,0 +1,204 @@
+/**
+ * Claude (Anthropic) -> OpenAI response translator (stream + non-stream helpers).
+ */
+
+function mapStopReason(reason) {
+  switch (reason) {
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool_calls";
+    case "end_turn":
+    case "stop_sequence":
+    default:
+      return "stop";
+  }
+}
+
+function toOpenAIUsage(usage) {
+  if (!usage || typeof usage !== "object") return undefined;
+  const prompt = usage.input_tokens || 0;
+  const completion = usage.output_tokens || 0;
+  return {
+    prompt_tokens: prompt,
+    completion_tokens: completion,
+    total_tokens: prompt + completion
+  };
+}
+
+function stringifyToolInput(input) {
+  if (typeof input === "string") return input;
+  try {
+    return JSON.stringify(input || {});
+  } catch {
+    return "{}";
+  }
+}
+
+export function claudeToOpenAINonStreamResponse(message) {
+  const contentBlocks = Array.isArray(message?.content) ? message.content : [];
+  const textParts = [];
+  const toolCalls = [];
+
+  for (let i = 0; i < contentBlocks.length; i += 1) {
+    const block = contentBlocks[i];
+    if (!block || typeof block !== "object") continue;
+
+    if (block.type === "text" && typeof block.text === "string") {
+      textParts.push(block.text);
+      continue;
+    }
+
+    if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id || `call_${i}`,
+        type: "function",
+        function: {
+          name: block.name || "tool",
+          arguments: stringifyToolInput(block.input)
+        }
+      });
+    }
+  }
+
+  const text = textParts.join("");
+  const responseMessage = {
+    role: "assistant",
+    content: text.length > 0 ? text : null
+  };
+
+  if (toolCalls.length > 0) {
+    responseMessage.tool_calls = toolCalls;
+  }
+
+  return {
+    id: message?.id?.startsWith("chatcmpl_") ? message.id : `chatcmpl_${message?.id || Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model: message?.model || "unknown",
+    choices: [
+      {
+        index: 0,
+        message: responseMessage,
+        finish_reason: mapStopReason(message?.stop_reason)
+      }
+    ],
+    usage: toOpenAIUsage(message?.usage)
+  };
+}
+
+export function initClaudeToOpenAIState() {
+  return {
+    chatId: `chatcmpl_${Date.now()}`,
+    created: Math.floor(Date.now() / 1000),
+    model: "unknown",
+    toolCallByBlockIndex: new Map(),
+    nextToolCallIndex: 0,
+    usage: undefined
+  };
+}
+
+function makeChunk(state, delta = {}, finishReason = null, usage = undefined) {
+  const chunk = {
+    id: state.chatId,
+    object: "chat.completion.chunk",
+    created: state.created,
+    model: state.model || "unknown",
+    choices: [
+      {
+        index: 0,
+        delta,
+        finish_reason: finishReason
+      }
+    ]
+  };
+
+  if (usage) {
+    chunk.usage = usage;
+  }
+
+  return chunk;
+}
+
+export function claudeEventToOpenAIChunks(eventType, event, state) {
+  if (!event || typeof event !== "object") {
+    if (eventType === "message_stop") return ["[DONE]"];
+    return [];
+  }
+
+  switch (eventType) {
+    case "message_start": {
+      const message = event.message || {};
+      state.chatId = message.id?.startsWith("chatcmpl_") ? message.id : `chatcmpl_${message.id || Date.now()}`;
+      state.model = message.model || state.model || "unknown";
+      state.usage = toOpenAIUsage(message.usage);
+      return [makeChunk(state, { role: "assistant" }, null)];
+    }
+
+    case "content_block_start": {
+      const block = event.content_block || {};
+      if (block.type !== "tool_use") return [];
+
+      const toolIndex = state.nextToolCallIndex++;
+      state.toolCallByBlockIndex.set(event.index, toolIndex);
+
+      return [
+        makeChunk(state, {
+          tool_calls: [
+            {
+              index: toolIndex,
+              id: block.id || `call_${toolIndex}`,
+              type: "function",
+              function: {
+                name: block.name || "tool",
+                arguments: ""
+              }
+            }
+          ]
+        }, null)
+      ];
+    }
+
+    case "content_block_delta": {
+      const delta = event.delta || {};
+      if (delta.type === "text_delta") {
+        return [makeChunk(state, { content: delta.text || "" }, null)];
+      }
+
+      if (delta.type === "input_json_delta") {
+        const toolIndex = state.toolCallByBlockIndex.get(event.index);
+        if (toolIndex === undefined) return [];
+        return [
+          makeChunk(state, {
+            tool_calls: [
+              {
+                index: toolIndex,
+                function: {
+                  arguments: delta.partial_json || ""
+                }
+              }
+            ]
+          }, null)
+        ];
+      }
+
+      // thinking_delta and other Anthropic-specific blocks are ignored for OpenAI chat compat.
+      return [];
+    }
+
+    case "message_delta": {
+      const usage = toOpenAIUsage(event.usage);
+      if (usage) state.usage = usage;
+      const stopReason = event.delta?.stop_reason ? mapStopReason(event.delta.stop_reason) : null;
+      if (!stopReason && !usage) return [];
+      return [makeChunk(state, {}, stopReason, usage)];
+    }
+
+    case "message_stop":
+      return ["[DONE]"];
+
+    default:
+      return [];
+  }
+}
+

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

@@ -0,0 +1,197 @@
+/**
+ * OpenAI -> Claude (Anthropic) Response Translator
+ */
+
+import { FORMATS } from "../formats.js";
+
+/**
+ * Convert OpenAI stream chunk to Claude format
+ */
+export function openaiToClaudeResponse(chunk, state) {
+  if (!chunk || !chunk.choices?.[0]) return null;
+
+  const results = [];
+  const choice = chunk.choices[0];
+  const delta = choice.delta;
+
+  // Track usage
+  if (chunk.usage && typeof chunk.usage === "object") {
+    const promptTokens = chunk.usage.prompt_tokens || 0;
+    const outputTokens = chunk.usage.completion_tokens || 0;
+    
+    state.usage = {
+      input_tokens: promptTokens,
+      output_tokens: outputTokens
+    };
+  }
+
+  // First chunk - send message_start
+  if (!state.messageStartSent) {
+    state.messageStartSent = true;
+    state.messageId = chunk.id?.replace("chatcmpl-", "") || `msg_${Date.now()}`;
+    state.model = chunk.model || "unknown";
+    state.nextBlockIndex = 0;
+    
+    results.push({
+      type: "message_start",
+      message: {
+        id: state.messageId,
+        type: "message",
+        role: "assistant",
+        model: state.model,
+        content: [],
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 }
+      }
+    });
+  }
+
+  // Handle thinking/reasoning content
+  const reasoningContent = delta?.reasoning_content || delta?.reasoning;
+  if (reasoningContent) {
+    stopTextBlock(state, results);
+
+    if (!state.thinkingBlockStarted) {
+      state.thinkingBlockIndex = state.nextBlockIndex++;
+      state.thinkingBlockStarted = true;
+      results.push({
+        type: "content_block_start",
+        index: state.thinkingBlockIndex,
+        content_block: { type: "thinking", thinking: "" }
+      });
+    }
+
+    results.push({
+      type: "content_block_delta",
+      index: state.thinkingBlockIndex,
+      delta: { type: "thinking_delta", thinking: reasoningContent }
+    });
+  }
+
+  // Handle regular content
+  if (delta?.content) {
+    stopThinkingBlock(state, results);
+
+    if (!state.textBlockStarted) {
+      state.textBlockIndex = state.nextBlockIndex++;
+      state.textBlockStarted = true;
+      state.textBlockClosed = false;
+      results.push({
+        type: "content_block_start",
+        index: state.textBlockIndex,
+        content_block: { type: "text", text: "" }
+      });
+    }
+
+    results.push({
+      type: "content_block_delta",
+      index: state.textBlockIndex,
+      delta: { type: "text_delta", text: delta.content }
+    });
+  }
+
+  // Tool calls
+  if (delta?.tool_calls) {
+    for (const tc of delta.tool_calls) {
+      const idx = tc.index ?? 0;
+
+      if (tc.id) {
+        stopThinkingBlock(state, results);
+        stopTextBlock(state, results);
+
+        const toolBlockIndex = state.nextBlockIndex++;
+        state.toolCalls.set(idx, { 
+          id: tc.id, 
+          name: tc.function?.name || "", 
+          blockIndex: toolBlockIndex 
+        });
+        
+        results.push({
+          type: "content_block_start",
+          index: toolBlockIndex,
+          content_block: {
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function?.name || "",
+            input: {}
+          }
+        });
+      }
+
+      if (tc.function?.arguments) {
+        const toolInfo = state.toolCalls.get(idx);
+        if (toolInfo) {
+          results.push({
+            type: "content_block_delta",
+            index: toolInfo.blockIndex,
+            delta: { type: "input_json_delta", partial_json: tc.function.arguments }
+          });
+        }
+      }
+    }
+  }
+
+  // Finish
+  if (choice.finish_reason) {
+    stopThinkingBlock(state, results);
+    stopTextBlock(state, results);
+
+    // Stop all tool blocks
+    for (const [, toolInfo] of state.toolCalls) {
+      results.push({
+        type: "content_block_stop",
+        index: toolInfo.blockIndex
+      });
+    }
+
+    state.finishReason = choice.finish_reason;
+    
+    const finalUsage = state.usage || { input_tokens: 0, output_tokens: 0 };
+    results.push({
+      type: "message_delta",
+      delta: { stop_reason: convertFinishReason(choice.finish_reason) },
+      usage: finalUsage
+    });
+    results.push({ type: "message_stop" });
+  }
+
+  return results.length > 0 ? results : null;
+}
+
+/**
+ * Stop thinking block
+ */
+function stopThinkingBlock(state, results) {
+  if (!state.thinkingBlockStarted) return;
+  results.push({
+    type: "content_block_stop",
+    index: state.thinkingBlockIndex
+  });
+  state.thinkingBlockStarted = false;
+}
+
+/**
+ * Stop text block
+ */
+function stopTextBlock(state, results) {
+  if (!state.textBlockStarted || state.textBlockClosed) return;
+  state.textBlockClosed = true;
+  results.push({
+    type: "content_block_stop",
+    index: state.textBlockIndex
+  });
+  state.textBlockStarted = false;
+}
+
+/**
+ * Convert finish reason
+ */
+function convertFinishReason(reason) {
+  switch (reason) {
+    case "stop": return "end_turn";
+    case "length": return "max_tokens";
+    case "tool_calls": return "tool_use";
+    default: return "end_turn";
+  }
+}

package/wrangler.toml

@@ -0,0 +1,20 @@
+name = "llm-router-route"
+main = "src/index.js"
+compatibility_date = "2024-01-01"
+workers_dev = false
+preview_urls = false
+
+# No custom routes are defined by default.
+# Configure routes/domains per environment in your own deployment setup.
+
+# Optional non-secret vars
+[vars]
+ENVIRONMENT = "production"
+
+# Required secret(s):
+# LLM_ROUTER_CONFIG_JSON  - All-in-one JSON config exported by:
+#                          llm-router deploy --export-only=true --out=.llm-router.worker.json
+#                          wrangler secret put LLM_ROUTER_CONFIG_JSON < .llm-router.worker.json
+#
+# Optional override:
+# LLM_ROUTER_MASTER_KEY   - Overrides config.masterKey at runtime