claude-router.mjs

#!/usr/bin/env node
// ~/bin/claude-router.mjs

import http from "http";

const CODER_MODEL  = "qwen/qwen3-coder-next";
const VISION_MODEL = "mistralai/devstral-small-2-2512";
const PROXY_PORT   = 3000;

const imageDescriptionCache = new Map();

function hashImage(imageBlock) {
  const data = imageBlock?.source?.data ?? imageBlock?.image_url?.url ?? "";
  return data.slice(0, 64);
}

function hasUncachedImagesInLastUserMessage(messages) {
  const lastUser = [...messages].reverse().find(m => m.role === "user");
  if (!lastUser || !Array.isArray(lastUser.content)) return false;
  for (const block of lastUser.content) {
    if (block.type === "image" || block.type === "image_url") {
      if (!imageDescriptionCache.has(hashImage(block))) return true;
    }
    if (block.type === "tool_result" && Array.isArray(block.content)) {
      for (const inner of block.content) {
        if (inner.type === "image" && !imageDescriptionCache.has(hashImage(inner))) return true;
      }
    }
  }
  return false;
}

function hasImagesAnywhere(messages) {
  return messages.some(msg => {
    if (!Array.isArray(msg.content)) return false;
    return msg.content.some(block => {
      if (block.type === "image" || block.type === "image_url") return true;
      if (block.type === "tool_result" && Array.isArray(block.content)) {
        return block.content.some(b => b.type === "image" || b.type === "image_url");
      }
      return false;
    });
  });
}

function collectImages(messages) {
  const images = [];
  for (const msg of messages) {
    if (!Array.isArray(msg.content)) continue;
    for (const block of msg.content) {
      if (block.type === "image" || block.type === "image_url") images.push(block);
      if (block.type === "tool_result" && Array.isArray(block.content)) {
        for (const inner of block.content) {
          if (inner.type === "image") images.push(inner);
        }
      }
    }
  }
  return images;
}

function imageToText(block) {
  const key  = hashImage(block);
  const desc = imageDescriptionCache.get(key);
  return desc ? `<<IMAGE DESCRIPTION: ${desc}>>` : "<<IMAGE: binary image file>>";
}

function flattenUserBlock(block) {
  if (block.type === "image" || block.type === "image_url") {
    return { type: "text", text: imageToText(block) };
  }
  if (block.type === "tool_result" && Array.isArray(block.content)) {
    const textBlocks  = block.content.filter(b => b.type === "text");
    const imageBlocks = block.content.filter(b => b.type === "image");
    const allText = [
      ...textBlocks.map(b => b.text),
      ...imageBlocks.map(imageToText),
    ].join("\n") || "[file content]";
    return { ...block, content: allText };
  }
  return block;
}

function rewriteForVision(messages) {
  let lastVisionIdx = -1;
  for (let i = messages.length - 1; i >= 0; i--) {
    const msg = messages[i];
    if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
    const hasImg = msg.content.some(b => {
      if (b.type === "image" || b.type === "image_url") return true;
      if (b.type === "tool_result" && Array.isArray(b.content)) {
        return b.content.some(inner => inner.type === "image");
      }
      return false;
    });
    if (hasImg) { lastVisionIdx = i; break; }
  }

  const result = [];

  for (let i = 0; i < messages.length; i++) {
    const msg = messages[i];

    if (msg.role !== "user" || !Array.isArray(msg.content)) {
      result.push(msg);
      continue;
    }

    if (i < lastVisionIdx) {
      result.push({ ...msg, content: msg.content.map(flattenUserBlock) });
      continue;
    }

    const cleanContent    = [];
    const extractedImages = [];

    for (const block of msg.content) {
      if (block.type === "tool_result" && Array.isArray(block.content)) {
        const textBlocks  = block.content.filter(b => b.type === "text");
        const imageBlocks = block.content.filter(b => b.type === "image");
        cleanContent.push({
          ...block,
          content: textBlocks.map(b => b.text).join("\n") || "[image file]",
        });
        extractedImages.push(...imageBlocks);
      } else if (block.type === "image" || block.type === "image_url") {
        extractedImages.push(block);
      } else {
        cleanContent.push(block);
      }
    }

    result.push({ ...msg, content: cleanContent });

    if (extractedImages.length > 0) {
      result.push({
        role: "assistant",
        content: [{ type: "text", text: "I can see the images. Let me analyze them." }],
      });
      result.push({
        role: "user",
        content: extractedImages,
      });
    }
  }

  return result;
}

function substituteImagesWithDescriptions(messages) {
  return messages.map(msg => {
    if (!Array.isArray(msg.content)) return msg;
    return { ...msg, content: msg.content.map(flattenUserBlock) };
  });
}

function normalizeAssistantMessages(messages) {
  return messages.map(msg => {
    if (msg.role !== "assistant" || !Array.isArray(msg.content)) return msg;
    const textBlocks    = msg.content.filter(b => b.type === "text");
    const toolUseBlocks = msg.content.filter(b => b.type === "tool_use");
    const otherBlocks   = msg.content.filter(b => b.type !== "text" && b.type !== "tool_use");
    const mergedText    = textBlocks.map(b => b.text).filter(Boolean).join("\n").trim();
    const newContent    = [];
    if (mergedText) newContent.push({ type: "text", text: mergedText });
    newContent.push(...toolUseBlocks);
    newContent.push(...otherBlocks);
    return { ...msg, content: newContent };
  });
}

function ensureAssistantText(messages) {
  return messages.map(msg => {
    if (msg.role !== "assistant" || !Array.isArray(msg.content)) return msg;
    const hasText = msg.content.some(b => b.type === "text");
    if (hasText) return msg;
    return { ...msg, content: [{ type: "text", text: "." }, ...msg.content] };
  });
}

function splitMixedUserMessages(messages) {
  const result = [];
  for (const msg of messages) {
    if (msg.role !== "user" || !Array.isArray(msg.content)) {
      result.push(msg);
      continue;
    }
    const toolResultBlocks = msg.content.filter(b => b.type === "tool_result");
    const otherBlocks      = msg.content.filter(b => b.type !== "tool_result");
    if (toolResultBlocks.length > 0 && otherBlocks.length > 0) {
      result.push({ role: "user", content: toolResultBlocks });
      result.push({ role: "assistant", content: [{ type: "text", text: "Understood, continuing." }] });
      result.push({ role: "user", content: otherBlocks });
    } else {
      result.push(msg);
    }
  }
  return result;
}

function fixMessageAlternation(messages) {
  if (!messages?.length) return messages;
  const fixed = [{ ...messages[0] }];
  for (let i = 1; i < messages.length; i++) {
    const prev = fixed[fixed.length - 1];
    const curr = messages[i];
    if (curr.role === prev.role) {
      const prevContent = Array.isArray(prev.content) ? prev.content : [{ type: "text", text: prev.content }];
      const currContent = Array.isArray(curr.content) ? curr.content : [{ type: "text", text: curr.content }];
      prev.content = [...prevContent, ...currContent];
    } else {
      fixed.push({ ...curr });
    }
  }
  return fixed;
}

function prepareMessages(messages, isVision) {
  const base = isVision
    ? rewriteForVision(messages)
    : (hasImagesAnywhere(messages) ? substituteImagesWithDescriptions(messages) : messages);

  return fixMessageAlternation(
    splitMixedUserMessages(
      ensureAssistantText(
        normalizeAssistantMessages(base)
      )
    )
  );
}

function forward(body, res, onResponse) {
  let responseBody = "";
  const proxyReq = http.request({
    hostname: "127.0.0.1",
    port: 1234,
    path: "/v1/messages",
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "anthropic-version": "2023-06-01",
    },
  }, (proxyRes) => {
    res.writeHead(proxyRes.statusCode, proxyRes.headers);
    proxyRes.on("data", chunk => { responseBody += chunk; res.write(chunk); });
    proxyRes.on("end", () => { res.end(); if (onResponse) onResponse(responseBody); });
  });
  proxyReq.on("error", (e) => {
    console.error("Proxy error:", e.message);
    res.writeHead(502);
    res.end(JSON.stringify({ error: e.message }));
  });
  proxyReq.write(body);
  proxyReq.end();
}

http.createServer((req, res) => {
  if (req.method !== "POST") { res.writeHead(404); res.end(); return; }

  let body = "";
  req.on("data", chunk => body += chunk);
  req.on("end", () => {
    try {
      const parsed   = JSON.parse(body);
      const messages = parsed.messages ?? [];
      const isVision = hasUncachedImagesInLastUserMessage(messages);

      parsed.model    = isVision ? VISION_MODEL : CODER_MODEL;
      parsed.messages = prepareMessages(messages, isVision);

      delete parsed.thinking;
      delete parsed.betas;

      console.log(`→ ${isVision ? "vision  " : "coder   "} [${parsed.model}]`);

      if (isVision) {
        const imageBlocks = collectImages(messages);
        forward(JSON.stringify(parsed), res, (responseBody) => {
          try {
            const resp = JSON.parse(responseBody);
            const text = resp.content?.filter(b => b.type === "text").map(b => b.text).join("\n") ?? "";
            if (text && imageBlocks.length > 0) {
              for (const img of imageBlocks) imageDescriptionCache.set(hashImage(img), text);
              console.log(`  cached description for ${imageBlocks.length} image(s)`);
            }
          } catch { /* streaming, ignore */ }
        });
      } else {
        forward(JSON.stringify(parsed), res, null);
      }

    } catch (e) {
      console.error("Parse error:", e.message);
      res.writeHead(400);
      res.end(JSON.stringify({ error: "bad request" }));
    }
  });

}).listen(PROXY_PORT, () => {
  console.log(`🔀 claude-router on :${PROXY_PORT}`);
  console.log(`   coder  → ${CODER_MODEL}`);
  console.log(`   vision → ${VISION_MODEL}`);
});