@halilertekin/claude-code-router-config 2.0.0 → 2.0.1

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 2.0.1
+- Include router files in the published npm package.
+
+## 2.0.0
+- Unified router service built into this package (no external router dependency).
+- Native CLI lifecycle commands (start/stop/restart/status/code/ui).
+- Streaming translation between Anthropic and OpenAI-style endpoints.
+- Dashboard now served by the router at `/ui`.
+- Default config uses `smart-intent-router.js` and adds HOST/PORT.

package/README.md

@@ -1,15 +1,16 @@
 # Claude Code Router Config - Advanced Multi-Provider Setup
 
-🚀 **v2.0.0** - Unified router + config package with z.ai (GLM 4.7) support, advanced CLI tools, analytics, smart routing, and configuration templates!
+🚀 **v2.0.1** - Unified router + config package with z.ai (GLM 4.7) support, advanced CLI tools, analytics, smart routing, and configuration templates!
 
 Use Claude Code as a single interface to access multiple AI providers with intelligent routing for optimal performance, cost, and quality.
 
-## ✨ New in v2.0.0
+## ✨ New in v2.0.1
 - **z.ai Support**: Native integration for GLM-4.7 via z.ai (PPInfra).
 - **Lightweight Mode**: New `ccc` function for zero-dependency routing.
 - **Direct GLM Alias**: Type `glm` to launch Claude Code with GLM-4.7 immediately.
 - **Non-interactive install**: CI-friendly installer flags and env controls.
 - **Unified router**: Built-in router service, no external dependency required.
+- **Packaging fix**: Router files are bundled in the npm package.
 
 ## 🚀 Setup on Another Machine (Fastest Way)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halilertekin/claude-code-router-config",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Multi-provider configuration for Claude Code Router with intent-based routing, advanced CLI tools, analytics, and smart routing. Setup OpenAI, Anthropic, Gemini, Qwen, GLM, OpenRouter, and GitHub Copilot with intelligent routing.",
   "main": "install.js",
   "bin": {
@@ -25,6 +25,7 @@
     "bin/",
     "config/",
     "cli/",
+    "router/",
     "logging/",
     "templates/",
     "plugins/",
@@ -35,6 +36,7 @@
     "postinstall.js",
     ".env.example",
     "docs/",
+    "CHANGELOG.md",
     "LICENSE",
     "README.md",
     "NPM_README.md"

package/router/config.js

@@ -0,0 +1,82 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const DEFAULT_CONFIG_DIR = path.join(os.homedir(), '.claude-code-router');
+const DEFAULT_CONFIG_PATH = path.join(DEFAULT_CONFIG_DIR, 'config.json');
+
+function resolveEnv(value) {
+  if (typeof value !== 'string') return value;
+
+  const withHome = value
+    .replace(/\$HOME/g, os.homedir())
+    .replace(/\${HOME}/g, os.homedir());
+
+  if (!withHome.includes('$')) return withHome;
+
+  return withHome.replace(/\$([A-Z0-9_]+)/gi, (_, key) => {
+    return process.env[key] ?? '';
+  });
+}
+
+function resolveConfigValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(resolveConfigValue);
+  }
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [key, resolveConfigValue(val)])
+    );
+  }
+  return resolveEnv(value);
+}
+
+function applyDefaults(config) {
+  const defaults = {
+    HOST: '127.0.0.1',
+    PORT: 3456,
+    LOG: true,
+    LOG_LEVEL: 'info',
+    API_TIMEOUT_MS: 300000
+  };
+
+  return {
+    ...defaults,
+    ...config
+  };
+}
+
+function loadConfig() {
+  const configPath = process.env.CCR_CONFIG_PATH || DEFAULT_CONFIG_PATH;
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file not found at ${configPath}`);
+  }
+
+  const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const resolved = resolveConfigValue(raw);
+  return applyDefaults(resolved);
+}
+
+function getConfigPath() {
+  return process.env.CCR_CONFIG_PATH || DEFAULT_CONFIG_PATH;
+}
+
+function getConfigDir() {
+  return process.env.CCR_CONFIG_DIR || DEFAULT_CONFIG_DIR;
+}
+
+function resolveProviderKey(provider) {
+  if (!provider?.api_key) return null;
+  if (typeof provider.api_key === 'string' && provider.api_key.startsWith('$')) {
+    const envKey = provider.api_key.slice(1);
+    return process.env[envKey] || null;
+  }
+  return provider.api_key;
+}
+
+module.exports = {
+  loadConfig,
+  getConfigPath,
+  getConfigDir,
+  resolveProviderKey
+};

package/router/format.js

@@ -0,0 +1,209 @@
+const crypto = require('crypto');
+
+function toText(value) {
+  if (typeof value === 'string') return value;
+  if (value == null) return '';
+  return JSON.stringify(value);
+}
+
+function normalizeAnthropicSystem(system) {
+  if (!system) return '';
+  if (typeof system === 'string') return system;
+  if (Array.isArray(system)) {
+    return system
+      .map((item) => {
+        if (typeof item === 'string') return item;
+        if (item?.type === 'text') return item.text || '';
+        return toText(item);
+      })
+      .join('\n');
+  }
+  return toText(system);
+}
+
+function anthropicMessagesToOpenAI(messages = []) {
+  return messages.map((message) => {
+    if (typeof message?.content === 'string') {
+      return { role: message.role, content: message.content };
+    }
+    if (Array.isArray(message?.content)) {
+      const text = message.content
+        .map((part) => {
+          if (part?.type === 'text') return part.text || '';
+          return toText(part);
+        })
+        .join('');
+      return { role: message.role, content: text };
+    }
+    return { role: message.role, content: toText(message?.content) };
+  });
+}
+
+function openAIMessagesToAnthropic(messages = []) {
+  return messages
+    .filter((message) => message.role !== 'system')
+    .map((message) => {
+      if (typeof message.content === 'string') {
+        return { role: message.role, content: message.content };
+      }
+      if (Array.isArray(message.content)) {
+        const parts = message.content
+          .map((part) => {
+            if (part?.type === 'text') {
+              return { type: 'text', text: part.text || '' };
+            }
+            return { type: 'text', text: toText(part) };
+          });
+        return { role: message.role, content: parts };
+      }
+      return { role: message.role, content: toText(message.content) };
+    });
+}
+
+function openAIToolsToAnthropic(tools = []) {
+  return tools
+    .map((tool) => {
+      if (tool?.type === 'function' && tool.function) {
+        return {
+          name: tool.function.name,
+          description: tool.function.description || '',
+          input_schema: tool.function.parameters || {}
+        };
+      }
+      return null;
+    })
+    .filter(Boolean);
+}
+
+function anthropicToolsToOpenAI(tools = []) {
+  return tools
+    .map((tool) => {
+      if (!tool?.name) return null;
+      return {
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description || '',
+          parameters: tool.input_schema || {}
+        }
+      };
+    })
+    .filter(Boolean);
+}
+
+function anthropicToOpenAI(body) {
+  const system = normalizeAnthropicSystem(body.system);
+  const messages = anthropicMessagesToOpenAI(body.messages || []);
+  const openAIMessages = system
+    ? [{ role: 'system', content: system }, ...messages]
+    : messages;
+
+  const openai = {
+    model: body.model,
+    messages: openAIMessages,
+    stream: Boolean(body.stream),
+    temperature: body.temperature,
+    max_tokens: body.max_tokens
+  };
+
+  if (body.top_p != null) openai.top_p = body.top_p;
+  if (body.tools) openai.tools = anthropicToolsToOpenAI(body.tools);
+  if (body.tool_choice) openai.tool_choice = body.tool_choice;
+  if (body.metadata) openai.metadata = body.metadata;
+
+  return openai;
+}
+
+function openAIToAnthropic(body) {
+  const systemMessages = (body.messages || []).filter((m) => m.role === 'system');
+  const system = systemMessages.map((m) => toText(m.content)).join('\n');
+  const messages = openAIMessagesToAnthropic(body.messages || []);
+
+  const anthropic = {
+    model: body.model,
+    messages,
+    system: system || undefined,
+    stream: Boolean(body.stream),
+    max_tokens: body.max_tokens,
+    temperature: body.temperature
+  };
+
+  if (body.top_p != null) anthropic.top_p = body.top_p;
+  if (body.tools) anthropic.tools = openAIToolsToAnthropic(body.tools);
+  if (body.tool_choice) anthropic.tool_choice = body.tool_choice;
+  if (body.metadata) anthropic.metadata = body.metadata;
+
+  return anthropic;
+}
+
+function extractOpenAIText(response) {
+  const choice = response?.choices?.[0];
+  if (!choice) return '';
+  if (choice.message?.content) return choice.message.content;
+  if (choice.delta?.content) return choice.delta.content;
+  return '';
+}
+
+function extractAnthropicText(response) {
+  if (!Array.isArray(response?.content)) return toText(response?.content);
+  return response.content
+    .map((part) => (part?.type === 'text' ? part.text || '' : toText(part)))
+    .join('');
+}
+
+function openAIResponseToAnthropic(response, fallbackModel) {
+  const text = extractOpenAIText(response);
+  const id = response?.id || `msg_${crypto.randomUUID()}`;
+  const model = response?.model || fallbackModel;
+  const finish = response?.choices?.[0]?.finish_reason || 'stop';
+
+  return {
+    id,
+    type: 'message',
+    role: 'assistant',
+    model,
+    content: [{ type: 'text', text }],
+    stop_reason: finish,
+    usage: {
+      input_tokens: response?.usage?.prompt_tokens || 0,
+      output_tokens: response?.usage?.completion_tokens || 0
+    }
+  };
+}
+
+function anthropicResponseToOpenAI(response, fallbackModel) {
+  const text = extractAnthropicText(response);
+  const model = response?.model || fallbackModel;
+  const created = Math.floor(Date.now() / 1000);
+  const finish = response?.stop_reason || 'stop';
+  const promptTokens = response?.usage?.input_tokens || 0;
+  const completionTokens = response?.usage?.output_tokens || 0;
+
+  return {
+    id: response?.id || `chatcmpl_${crypto.randomUUID()}`,
+    object: 'chat.completion',
+    created,
+    model,
+    choices: [
+      {
+        index: 0,
+        message: { role: 'assistant', content: text },
+        finish_reason: finish
+      }
+    ],
+    usage: {
+      prompt_tokens: promptTokens,
+      completion_tokens: completionTokens,
+      total_tokens: promptTokens + completionTokens
+    }
+  };
+}
+
+module.exports = {
+  anthropicToOpenAI,
+  openAIToAnthropic,
+  openAIResponseToAnthropic,
+  anthropicResponseToOpenAI,
+  anthropicToolsToOpenAI,
+  openAIToolsToAnthropic
+};

package/router/http.js

@@ -0,0 +1,55 @@
+const { request } = require('undici');
+
+async function readStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function sendJsonRequest({ url, headers, body, timeoutMs }) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await request(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+
+    const rawBody = await readStream(response.body);
+    return {
+      statusCode: response.statusCode,
+      headers: response.headers,
+      rawBody
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function sendStreamRequest({ url, headers, body, timeoutMs }) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  const response = await request(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+    signal: controller.signal
+  });
+
+  response.body.on('end', () => clearTimeout(timeout));
+  response.body.on('error', () => clearTimeout(timeout));
+
+  return response;
+}
+
+module.exports = {
+  sendJsonRequest,
+  sendStreamRequest,
+  readStream
+};

package/router/providers.js

@@ -0,0 +1,53 @@
+const { resolveProviderKey } = require('./config');
+
+function inferProviderFormat(provider) {
+  const name = (provider?.name || '').toLowerCase();
+  const baseUrl = provider?.api_base_url || '';
+  const transformers = provider?.transformer?.use || [];
+
+  if (name === 'anthropic' || name === 'glm') return 'anthropic';
+  if (baseUrl.includes('/v1/messages') || baseUrl.includes('/anthropic')) return 'anthropic';
+  if (transformers.some((t) => t.toLowerCase() === 'anthropic')) return 'anthropic';
+
+  return 'openai';
+}
+
+function resolveAuthHeader(provider, apiKey) {
+  if (!apiKey) return {};
+
+  const name = (provider?.name || '').toLowerCase();
+  const headerName = provider.api_key_header
+    || (name === 'gemini' ? 'x-goog-api-key' : 'authorization');
+  const headerValue = headerName.toLowerCase() === 'authorization'
+    ? `Bearer ${apiKey}`
+    : apiKey;
+
+  return { [headerName]: headerValue };
+}
+
+function buildProviderHeaders(provider) {
+  const apiKey = resolveProviderKey(provider);
+  const headers = {
+    'content-type': 'application/json',
+    ...resolveAuthHeader(provider, apiKey),
+    ...(provider.headers || {})
+  };
+
+  if (inferProviderFormat(provider) === 'anthropic') {
+    headers['anthropic-version'] = headers['anthropic-version'] || '2023-06-01';
+  }
+
+  if ((provider?.name || '').toLowerCase() === 'openrouter') {
+    const referer = provider.referer || process.env.OPENROUTER_REFERRER;
+    const title = provider.app_name || process.env.OPENROUTER_APP_NAME;
+    if (referer) headers['http-referer'] = referer;
+    if (title) headers['x-title'] = title;
+  }
+
+  return { headers, apiKey };
+}
+
+module.exports = {
+  inferProviderFormat,
+  buildProviderHeaders
+};

package/router/route.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+
+function estimateTokens(messages = [], system) {
+  const systemText = Array.isArray(system)
+    ? system.map((s) => (typeof s === 'string' ? s : s?.text || '')).join(' ')
+    : (system || '');
+  const messageText = (messages || [])
+    .map((m) => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '')))
+    .join(' ');
+  const text = `${systemText} ${messageText}`;
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+
+function parseExplicitRoute(model) {
+  if (!model || !model.includes(',')) return null;
+  const [provider, ...rest] = model.split(',');
+  const modelName = rest.join(',');
+  return provider && modelName ? { provider, model: modelName } : null;
+}
+
+function extractSubagentModel(system) {
+  const systemText = Array.isArray(system)
+    ? system.map((item) => (item?.text ? item.text : '')).join(' ')
+    : (system || '');
+  const match = systemText.match(/<CCR-SUBAGENT-MODEL>(.*?)<\/CCR-SUBAGENT-MODEL>/s);
+  return match ? match[1].trim() : null;
+}
+
+function loadCustomRouter(routerPath) {
+  try {
+    if (!routerPath) return null;
+    if (!fs.existsSync(routerPath)) return null;
+    delete require.cache[require.resolve(routerPath)];
+    return require(routerPath);
+  } catch {
+    return null;
+  }
+}
+
+async function resolveRoute(req, config) {
+  if (!req?.body) return config.Router?.default || null;
+
+  const explicit = parseExplicitRoute(req.body.model);
+  if (explicit) {
+    return `${explicit.provider},${explicit.model}`;
+  }
+
+  const tokenCount = estimateTokens(req.body.messages || [], req.body.system);
+  req.tokenCount = tokenCount;
+
+  const subagentModel = extractSubagentModel(req.body.system);
+  if (subagentModel) {
+    return subagentModel;
+  }
+
+  const customRouter = loadCustomRouter(config.CUSTOM_ROUTER_PATH);
+  if (customRouter) {
+    try {
+      const route = await customRouter(req, config);
+      if (route) return route;
+    } catch {
+      // Fall through to defaults
+    }
+  }
+
+  const routerConfig = config.Router || {};
+  const longContextThreshold = routerConfig.longContextThreshold || 60000;
+  if (tokenCount > longContextThreshold && routerConfig.longContext) {
+    return routerConfig.longContext;
+  }
+
+  if (req.body.thinking && routerConfig.think) {
+    return routerConfig.think;
+  }
+
+  if (Array.isArray(req.body.tools) && req.body.tools.some((tool) => {
+    return typeof tool?.type === 'string' && tool.type.startsWith('web_search');
+  }) && routerConfig.webSearch) {
+    return routerConfig.webSearch;
+  }
+
+  if (req.body.model?.includes('haiku') && routerConfig.background) {
+    return routerConfig.background;
+  }
+
+  return routerConfig.default || null;
+}
+
+module.exports = {
+  resolveRoute,
+  parseExplicitRoute,
+  estimateTokens
+};

package/router/server.js

@@ -0,0 +1,520 @@
+#!/usr/bin/env node
+
+const express = require('express');
+const cors = require('cors');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { loadConfig, getConfigPath, getConfigDir } = require('./config');
+const { resolveRoute, estimateTokens } = require('./route');
+const {
+  anthropicToOpenAI,
+  openAIToAnthropic,
+  openAIResponseToAnthropic,
+  anthropicResponseToOpenAI
+} = require('./format');
+const { inferProviderFormat, buildProviderHeaders } = require('./providers');
+const { sendJsonRequest, sendStreamRequest } = require('./http');
+const { readStream } = require('./http');
+const {
+  pipeStream,
+  streamOpenAIToAnthropic,
+  streamAnthropicToOpenAI
+} = require('./stream');
+const { recordRequest, calculateCost, getTodayAnalytics, getAnalyticsSummary, exportAnalytics } = require('../cli/analytics');
+const { logger } = require('../logging/enhanced-logger');
+const { HealthMonitor } = require('../logging/health-monitor');
+
+function getRequestFormat(req) {
+  return req.path.startsWith('/v1/messages') ? 'anthropic' : 'openai';
+}
+
+function pickProvider(route, config) {
+  if (!route) return null;
+  const [providerName, ...modelParts] = route.split(',');
+  const model = modelParts.join(',').trim();
+  const provider = config.Providers.find(
+    (p) => p.name.toLowerCase() === providerName.toLowerCase()
+  );
+  if (!provider) return null;
+  return {
+    provider,
+    model: model || provider.models?.[0]
+  };
+}
+
+function ensureAnthropicDefaults(body) {
+  if (!body.max_tokens) {
+    body.max_tokens = 1024;
+  }
+  return body;
+}
+
+function extractUsage(providerFormat, response) {
+  if (providerFormat === 'anthropic') {
+    return {
+      inputTokens: response?.usage?.input_tokens || 0,
+      outputTokens: response?.usage?.output_tokens || 0
+    };
+  }
+  return {
+    inputTokens: response?.usage?.prompt_tokens || 0,
+    outputTokens: response?.usage?.completion_tokens || 0
+  };
+}
+
+function buildFallbackRoutes(config, usedRoute) {
+  const fallbackRoutes = [];
+  const routerFallbacks = config.Router?.fallbacks || [];
+  for (const route of routerFallbacks) {
+    if (route && route !== usedRoute) fallbackRoutes.push(route);
+  }
+
+  if (config.Router?.default && config.Router.default !== usedRoute) {
+    fallbackRoutes.push(config.Router.default);
+  }
+
+  config.Providers.forEach((provider) => {
+    const model = provider.models?.[0];
+    const route = model ? `${provider.name},${model}` : null;
+    if (route && route !== usedRoute && !fallbackRoutes.includes(route)) {
+      fallbackRoutes.push(route);
+    }
+  });
+
+  return fallbackRoutes;
+}
+
+async function handleProxy(req, res) {
+  let config;
+  try {
+    config = loadConfig();
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+    return;
+  }
+
+  const requestFormat = getRequestFormat(req);
+  const route = await resolveRoute(req, config);
+  let selection = pickProvider(route, config);
+
+  if (!selection) {
+    res.status(400).json({ error: 'No matching provider found' });
+    return;
+  }
+
+  let providerFormat = inferProviderFormat(selection.provider);
+  let { headers, apiKey } = buildProviderHeaders(selection.provider);
+
+  if (!apiKey) {
+    res.status(400).json({ error: `Missing API key for provider ${selection.provider.name}` });
+    return;
+  }
+
+  let outgoingBody;
+  if (requestFormat === providerFormat) {
+    outgoingBody = { ...req.body };
+  } else if (providerFormat === 'openai') {
+    outgoingBody = anthropicToOpenAI(req.body);
+  } else {
+    outgoingBody = openAIToAnthropic(req.body);
+  }
+
+  outgoingBody.model = selection.model;
+  if (providerFormat === 'anthropic') {
+    ensureAnthropicDefaults(outgoingBody);
+  }
+
+  const timeoutMs = config.API_TIMEOUT_MS || 300000;
+  const upstreamUrl = selection.provider.api_base_url;
+
+  const start = Date.now();
+  const shouldStream = Boolean(outgoingBody.stream);
+
+  const attemptRequest = async () => {
+    if (shouldStream) {
+      return sendStreamRequest({
+        url: upstreamUrl,
+        headers,
+        body: outgoingBody,
+        timeoutMs
+      });
+    }
+    return sendJsonRequest({
+      url: upstreamUrl,
+      headers,
+      body: outgoingBody,
+      timeoutMs
+    });
+  };
+
+  let upstream;
+  let usedRoute = route;
+
+  try {
+    upstream = await attemptRequest();
+  } catch (error) {
+    const fallbacks = buildFallbackRoutes(config, usedRoute);
+    for (const fallback of fallbacks) {
+      const fallbackSelection = pickProvider(fallback, config);
+      if (!fallbackSelection) continue;
+
+      const fallbackFormat = inferProviderFormat(fallbackSelection.provider);
+      const fallbackHeaders = buildProviderHeaders(fallbackSelection.provider).headers;
+
+      outgoingBody.model = fallbackSelection.model;
+      if (fallbackFormat === 'anthropic') {
+        ensureAnthropicDefaults(outgoingBody);
+      }
+
+      try {
+        upstream = shouldStream
+          ? await sendStreamRequest({
+              url: fallbackSelection.provider.api_base_url,
+              headers: fallbackHeaders,
+              body: outgoingBody,
+              timeoutMs
+            })
+          : await sendJsonRequest({
+              url: fallbackSelection.provider.api_base_url,
+              headers: fallbackHeaders,
+              body: outgoingBody,
+              timeoutMs
+            });
+        usedRoute = fallback;
+        selection = fallbackSelection;
+        providerFormat = fallbackFormat;
+        headers = fallbackHeaders;
+        break;
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  if (!upstream) {
+    res.status(502).json({ error: 'Failed to reach provider' });
+    return;
+  }
+
+  if (shouldStream) {
+    if (upstream.statusCode >= 400) {
+      const errorText = await readStream(upstream.body);
+      res.status(upstream.statusCode).json({ error: errorText || 'Upstream error' });
+      return;
+    }
+
+    res.status(200);
+    if (requestFormat === providerFormat) {
+      await pipeStream(res, upstream.body, upstream.headers);
+      return;
+    }
+    if (providerFormat === 'openai' && requestFormat === 'anthropic') {
+      await streamOpenAIToAnthropic(upstream.body, res, { model: selection.model });
+      return;
+    }
+    if (providerFormat === 'anthropic' && requestFormat === 'openai') {
+      await streamAnthropicToOpenAI(upstream.body, res, { model: selection.model });
+      return;
+    }
+  }
+
+  if (upstream.statusCode >= 400) {
+    res.status(upstream.statusCode).send(upstream.rawBody || { error: 'Upstream error' });
+    return;
+  }
+
+  let responsePayload;
+  try {
+    responsePayload = JSON.parse(upstream.rawBody || '{}');
+  } catch {
+    responsePayload = { error: 'Invalid upstream response' };
+  }
+
+  const latency = Date.now() - start;
+  const usage = extractUsage(providerFormat, responsePayload);
+  const cost = calculateCost(selection.provider.name, selection.model, usage.inputTokens, usage.outputTokens);
+
+  logger.logRequest(selection.provider.name, selection.model, usage.inputTokens, usage.outputTokens, latency, true, cost);
+  recordRequest(selection.provider.name, selection.model, usage.inputTokens, usage.outputTokens, latency, true);
+
+  if (requestFormat !== providerFormat) {
+    if (requestFormat === 'anthropic') {
+      responsePayload = openAIResponseToAnthropic(responsePayload, selection.model);
+    } else {
+      responsePayload = anthropicResponseToOpenAI(responsePayload, selection.model);
+    }
+  }
+
+  res.status(200).json(responsePayload);
+}
+
+function setupApi(app) {
+  app.get('/health', (req, res) => {
+    res.json({ status: 'ok', timestamp: new Date().toISOString() });
+  });
+
+  app.post('/v1/messages', handleProxy);
+  app.post('/v1/messages/count_tokens', (req, res) => {
+    const tokenCount = estimateTokens(req.body?.messages || [], req.body?.system);
+    res.json({ input_tokens: tokenCount });
+  });
+  app.post('/v1/chat/completions', handleProxy);
+
+  app.post('/v1/responses', (req, res) => {
+    req.body = req.body || {};
+    if (!req.body.messages && req.body.input) {
+      if (typeof req.body.input === 'string') {
+        req.body.messages = [{ role: 'user', content: req.body.input }];
+      } else if (Array.isArray(req.body.input)) {
+        req.body.messages = req.body.input;
+      } else {
+        req.body.messages = [];
+      }
+    }
+    handleProxy(req, res);
+  });
+
+  app.get('/api/status', (req, res) => {
+    res.json({
+      success: true,
+      data: {
+        uptime: process.uptime(),
+        timestamp: new Date().toISOString(),
+        version: require('../package.json').version,
+        nodeVersion: process.version,
+        platform: os.platform(),
+        arch: os.arch()
+      }
+    });
+  });
+
+  app.get('/api/config', (req, res) => {
+    try {
+      const config = loadConfig();
+      res.json({ success: true, data: config });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.post('/api/config', (req, res) => {
+    try {
+      const configPath = getConfigPath();
+      const backupDir = path.join(getConfigDir(), 'backups');
+      if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupPath = path.join(backupDir, `config-${timestamp}.json`);
+      fs.copyFileSync(configPath, backupPath);
+
+      fs.writeFileSync(configPath, JSON.stringify(req.body, null, 2));
+      res.json({ success: true, message: 'Config saved', backup: backupPath });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/config/templates', (req, res) => {
+    try {
+      const templatesDir = path.join(__dirname, '..', 'templates');
+      const files = fs.readdirSync(templatesDir).filter((file) => file.endsWith('.json'));
+      const templates = files.map((file) => {
+        const content = JSON.parse(fs.readFileSync(path.join(templatesDir, file), 'utf8'));
+        return {
+          name: file.replace('.json', ''),
+          description: content._description || content._comment || '',
+          config: content
+        };
+      });
+      res.json({ success: true, data: templates });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/providers', (req, res) => {
+    try {
+      const config = loadConfig();
+      res.json({ success: true, data: config.Providers || [] });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/analytics/today', (req, res) => {
+    try {
+      res.json({ success: true, data: getTodayAnalytics() });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/analytics/summary', (req, res) => {
+    try {
+      const period = req.query.period || 'week';
+      res.json({ success: true, data: getAnalyticsSummary(period) });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/analytics/export', (req, res) => {
+    try {
+      const format = req.query.format || 'json';
+      const period = req.query.period || 'all';
+      const filepath = exportAnalytics(format, period);
+      res.download(filepath, (err) => {
+        if (err) {
+          res.status(500).json({ success: false, error: 'Export failed' });
+        }
+        fs.unlink(filepath, () => {});
+      });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/health/providers', async (req, res) => {
+    try {
+      const config = loadConfig();
+      const monitor = new HealthMonitor({ enabled: true });
+      config.Providers.forEach((provider) => monitor.addProvider(provider.name, provider));
+      const results = await monitor.checkAllProviders();
+      res.json({ success: true, data: Object.values(results) });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/health/system', (req, res) => {
+    const monitor = new HealthMonitor({ enabled: false });
+    res.json({
+      success: true,
+      data: {
+        uptime: process.uptime(),
+        memory: process.memoryUsage(),
+        cpu: monitor.getCPUUsage(),
+        nodeVersion: process.version
+      }
+    });
+  });
+
+  app.get('/api/logs/files', (req, res) => {
+    try {
+      const logDir = path.join(os.homedir(), '.claude-code-router', 'logs');
+      const logFiles = [];
+      if (fs.existsSync(logDir)) {
+        const files = fs.readdirSync(logDir);
+        for (const file of files) {
+          if (file.endsWith('.log') || file.endsWith('.json')) {
+            const filePath = path.join(logDir, file);
+            const stats = fs.statSync(filePath);
+            logFiles.push({
+              name: file,
+              path: filePath,
+              size: stats.size,
+              lastModified: stats.mtime.toISOString()
+            });
+          }
+        }
+      }
+      res.json({ success: true, data: logFiles });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/logs', (req, res) => {
+    try {
+      const filePath = req.query.file
+        ? req.query.file
+        : path.join(os.homedir(), '.claude-code-router', 'logs', 'app.log');
+      if (!fs.existsSync(filePath)) {
+        res.json({ success: true, data: [] });
+        return;
+      }
+      const logContent = fs.readFileSync(filePath, 'utf8');
+      const logLines = logContent.split('\n').filter((line) => line.trim());
+      res.json({ success: true, data: logLines });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.delete('/api/logs', (req, res) => {
+    try {
+      const filePath = req.query.file
+        ? req.query.file
+        : path.join(os.homedir(), '.claude-code-router', 'logs', 'app.log');
+      if (fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, '', 'utf8');
+      }
+      res.json({ success: true, message: 'Logs cleared' });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+}
+
+function setupUi(app) {
+  const uiRoot = path.join(__dirname, '..', 'web-dashboard', 'public');
+  app.use('/ui', express.static(uiRoot));
+  app.get('/', (req, res) => res.redirect('/ui'));
+}
+
+function startServer() {
+  const app = express();
+  app.use(cors());
+  app.use(express.json({ limit: '50mb' }));
+
+  app.use((req, res, next) => {
+    if (req.path === '/health' || req.path.startsWith('/ui')) {
+      return next();
+    }
+    let config;
+    try {
+      config = loadConfig();
+    } catch {
+      return next();
+    }
+    if (!config.APIKEY) {
+      return next();
+    }
+    const authHeader = req.headers.authorization || req.headers['x-api-key'];
+    if (!authHeader) {
+      res.status(401).json({ error: 'API key missing' });
+      return;
+    }
+    const token = authHeader.startsWith('Bearer ')
+      ? authHeader.slice('Bearer '.length)
+      : authHeader;
+    if (token !== config.APIKEY) {
+      res.status(401).json({ error: 'Invalid API key' });
+      return;
+    }
+    next();
+  });
+
+  setupApi(app);
+  setupUi(app);
+
+  const config = loadConfig();
+  logger.level = config.LOG_LEVEL || logger.level;
+  logger.enableConsole = config.LOG !== false;
+
+  const host = config.HOST || '127.0.0.1';
+  const port = parseInt(config.PORT || 3456, 10);
+
+  app.listen(port, host, () => {
+    logger.info(`Router server listening on http://${host}:${port}`);
+  });
+}
+
+if (require.main === module) {
+  startServer();
+}
+
+module.exports = {
+  startServer
+};

package/router/stream.js

@@ -0,0 +1,158 @@
+const crypto = require('crypto');
+const { createParser } = require('eventsource-parser');
+
+function setStreamHeaders(res) {
+  res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+  res.setHeader('Cache-Control', 'no-cache, no-transform');
+  res.setHeader('Connection', 'keep-alive');
+  res.flushHeaders?.();
+}
+
+function writeAnthropicEvent(res, event, data) {
+  res.write(`event: ${event}\n`);
+  res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+
+function writeOpenAIEvent(res, data) {
+  res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+
+async function pipeStream(res, upstream, headers) {
+  if (headers?.['content-type']) {
+    res.setHeader('Content-Type', headers['content-type']);
+  } else {
+    setStreamHeaders(res);
+  }
+  for await (const chunk of upstream) {
+    res.write(chunk);
+  }
+  res.end();
+}
+
+async function streamOpenAIToAnthropic(upstream, res, { model }) {
+  setStreamHeaders(res);
+
+  const messageId = `msg_${crypto.randomUUID()}`;
+  let started = false;
+  let finished = false;
+
+  const parser = createParser((event) => {
+    if (event.type !== 'event') return;
+    if (!event.data) return;
+
+    if (event.data === '[DONE]') {
+      if (!finished) {
+        writeAnthropicEvent(res, 'message_stop', {
+          type: 'message_stop'
+        });
+        finished = true;
+      }
+      return;
+    }
+
+    let payload;
+    try {
+      payload = JSON.parse(event.data);
+    } catch {
+      return;
+    }
+
+    const delta = payload?.choices?.[0]?.delta;
+    const text = delta?.content;
+    if (text == null) return;
+
+    if (!started) {
+      writeAnthropicEvent(res, 'message_start', {
+        type: 'message_start',
+        message: {
+          id: messageId,
+          type: 'message',
+          role: 'assistant',
+          model,
+          content: []
+        }
+      });
+      writeAnthropicEvent(res, 'content_block_start', {
+        type: 'content_block_start',
+        index: 0,
+        content_block: { type: 'text', text: '' }
+      });
+      started = true;
+    }
+
+    writeAnthropicEvent(res, 'content_block_delta', {
+      type: 'content_block_delta',
+      index: 0,
+      delta: { type: 'text_delta', text }
+    });
+  });
+
+  for await (const chunk of upstream) {
+    parser.feed(chunk.toString());
+  }
+
+  if (!finished) {
+    writeAnthropicEvent(res, 'message_stop', { type: 'message_stop' });
+  }
+  res.end();
+}
+
+async function streamAnthropicToOpenAI(upstream, res, { model }) {
+  setStreamHeaders(res);
+
+  const responseId = `chatcmpl_${crypto.randomUUID()}`;
+  let started = false;
+
+  const parser = createParser((event) => {
+    if (event.type !== 'event') return;
+    if (!event.data) return;
+
+    let payload;
+    try {
+      payload = JSON.parse(event.data);
+    } catch {
+      return;
+    }
+
+    if (payload.type === 'content_block_delta') {
+      const text = payload.delta?.text || '';
+      if (!started) {
+        writeOpenAIEvent(res, {
+          id: responseId,
+          object: 'chat.completion.chunk',
+          created: Math.floor(Date.now() / 1000),
+          model,
+          choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }]
+        });
+        started = true;
+      }
+      if (text) {
+        writeOpenAIEvent(res, {
+          id: responseId,
+          object: 'chat.completion.chunk',
+          created: Math.floor(Date.now() / 1000),
+          model,
+          choices: [{ index: 0, delta: { content: text }, finish_reason: null }]
+        });
+      }
+    }
+
+    if (payload.type === 'message_stop') {
+      res.write('data: [DONE]\n\n');
+    }
+  });
+
+  for await (const chunk of upstream) {
+    parser.feed(chunk.toString());
+  }
+
+  res.write('data: [DONE]\n\n');
+  res.end();
+}
+
+module.exports = {
+  pipeStream,
+  streamOpenAIToAnthropic,
+  streamAnthropicToOpenAI,
+  setStreamHeaders
+};