llmapi-v2 2.1.0

package/public/robots.txt

@@ -0,0 +1,8 @@
+User-agent: *
+Allow: /
+Disallow: /api/
+Disallow: /admin
+Disallow: /dashboard
+Disallow: /settings
+
+Sitemap: https://llmapi.pro/sitemap.xml

package/src/config.ts

@@ -0,0 +1,140 @@
+export interface ProviderConfig {
+  name: string;
+  /** Native Anthropic-compatible endpoint (preferred) */
+  anthropicBaseUrl: string;
+  /** OpenAI-compatible endpoint (fallback for providers without native Anthropic support) */
+  openaiBaseUrl?: string;
+  apiKey: string;
+  enabled: boolean;
+  timeout: number;
+  /** Maps Claude model names to this provider's model names */
+  models: Record<string, string>;
+  /** Cost per 1M tokens in RMB: { input, output, cached_input } */
+  pricing: Record<string, { input: number; output: number; cached_input?: number }>;
+}
+
+export interface ModelRoute {
+  provider: string;
+  model: string;
+  priority: number;
+}
+
+/** Smart routing: which models to use based on task complexity */
+export interface SmartRoutingConfig {
+  /** Model for heavy coding tasks (tools present, complex) */
+  codingModel: { provider: string; model: string };
+  /** Model for simple/chat tasks (no tools or trivial) */
+  lightModel: { provider: string; model: string };
+  /** Threshold: if message count < this AND no tools, use light model */
+  lightTaskMaxMessages: number;
+}
+
+export interface AppConfig {
+  port: number;
+  jwtSecret: string;
+  databaseUrl: string;
+  providers: ProviderConfig[];
+  modelRouting: Record<string, ModelRoute[]>;
+  smartRouting: SmartRoutingConfig;
+  siteUrl: string;
+}
+
+function env(key: string, fallback?: string): string {
+  const val = process.env[key];
+  if (val !== undefined) return val;
+  if (fallback !== undefined) return fallback;
+  throw new Error(`Missing required env var: ${key}`);
+}
+
+function envBool(key: string, fallback: boolean): boolean {
+  const val = process.env[key];
+  if (val === undefined) return fallback;
+  return val === 'true' || val === '1';
+}
+
+function envInt(key: string, fallback: number): number {
+  const val = process.env[key];
+  if (val === undefined) return fallback;
+  const n = parseInt(val, 10);
+  return isNaN(n) ? fallback : n;
+}
+
+export function loadConfig(): AppConfig {
+  const providers: ProviderConfig[] = [];
+
+  // Alibaba Bailian (DashScope) - PRIMARY: native Anthropic endpoint (China domestic)
+  if (envBool('ALIYUN_ENABLED', false)) {
+    providers.push({
+      name: 'aliyun',
+      anthropicBaseUrl: env('ALIYUN_ANTHROPIC_URL', 'https://dashscope.aliyuncs.com/apps/anthropic'),
+      openaiBaseUrl: env('ALIYUN_OPENAI_URL', 'https://dashscope.aliyuncs.com/compatible-mode/v1'),
+      apiKey: env('ALIYUN_API_KEY', ''),
+      enabled: true,
+      timeout: 300_000,
+      models: {
+        'claude-sonnet-4-6': 'qwen3-coder-plus',
+        'claude-opus-4-6': 'qwen-max',
+        'claude-haiku-4-5': 'qwen-plus',
+      },
+      pricing: {
+        'qwen3-coder-plus': { input: 3.5, output: 7.0, cached_input: 0.35 },
+        'qwen-max': { input: 20.0, output: 60.0, cached_input: 2.0 },
+        'qwen-plus': { input: 0.5, output: 1.5, cached_input: 0.05 },
+      },
+    });
+  }
+
+  // DeepSeek - native Anthropic endpoint for simple tasks
+  if (envBool('DEEPSEEK_ENABLED', false)) {
+    providers.push({
+      name: 'deepseek',
+      anthropicBaseUrl: env('DEEPSEEK_ANTHROPIC_URL', 'https://api.deepseek.com/anthropic'),
+      openaiBaseUrl: env('DEEPSEEK_OPENAI_URL', 'https://api.deepseek.com/v1'),
+      apiKey: env('DEEPSEEK_API_KEY', ''),
+      enabled: true,
+      timeout: 300_000,
+      models: {
+        'claude-sonnet-4-6': 'deepseek-chat',
+        'claude-opus-4-6': 'deepseek-chat',
+        'claude-haiku-4-5': 'deepseek-chat',
+      },
+      pricing: {
+        'deepseek-chat': { input: 1.0, output: 2.0, cached_input: 0.1 },
+      },
+    });
+  }
+
+  // Build model routing
+  const modelRouting: Record<string, ModelRoute[]> = {};
+  const claudeModels = ['claude-sonnet-4-6', 'claude-opus-4-6', 'claude-haiku-4-5'];
+
+  for (const claudeModel of claudeModels) {
+    const routes: ModelRoute[] = [];
+    for (let i = 0; i < providers.length; i++) {
+      const p = providers[i];
+      if (p.models[claudeModel]) {
+        routes.push({ provider: p.name, model: p.models[claudeModel], priority: i });
+      }
+    }
+    if (routes.length > 0) {
+      modelRouting[claudeModel] = routes.sort((a, b) => a.priority - b.priority);
+    }
+  }
+
+  // Smart routing config
+  const smartRouting: SmartRoutingConfig = {
+    codingModel: { provider: 'aliyun', model: 'qwen3-coder-plus' },
+    lightModel: { provider: 'deepseek', model: 'deepseek-chat' },
+    lightTaskMaxMessages: envInt('SMART_ROUTING_LIGHT_MAX_MESSAGES', 4),
+  };
+
+  return {
+    port: envInt('PORT', 3000),
+    jwtSecret: env('JWT_SECRET', 'dev-secret-change-me'),
+    databaseUrl: env('DATABASE_URL', 'postgresql://llmapi_user:change-this@postgres:5432/llmapi'),
+    providers,
+    modelRouting,
+    smartRouting,
+    siteUrl: env('SITE_URL', 'http://localhost:3000'),
+  };
+}

package/src/converter/request.ts

@@ -0,0 +1,207 @@
+import type {
+  AnthropicRequest,
+  AnthropicMessage,
+  AnthropicContentBlock,
+  AnthropicToolDefinition,
+  AnthropicToolChoice,
+  OpenAIRequest,
+  OpenAIMessage,
+  OpenAITool,
+  OpenAIToolCall,
+  OpenAIContentPart,
+} from './types';
+
+/**
+ * Convert an Anthropic Messages API request to OpenAI Chat Completions format.
+ * This is the inbound conversion: Claude Code -> our proxy -> provider.
+ */
+export function convertRequest(req: AnthropicRequest): OpenAIRequest {
+  const openaiMessages = convertMessages(req.messages, req.system);
+  const openaiTools = convertTools(req.tools);
+  const openaiToolChoice = convertToolChoice(req.tool_choice);
+
+  const body: OpenAIRequest = {
+    model: '', // Will be set by the router
+    messages: openaiMessages,
+    stream: !!req.stream,
+  };
+
+  if (req.max_tokens) body.max_tokens = req.max_tokens;
+  if (req.temperature !== undefined) body.temperature = req.temperature;
+  if (req.top_p !== undefined) body.top_p = req.top_p;
+  if (req.stop_sequences) body.stop = req.stop_sequences;
+  if (openaiTools) body.tools = openaiTools;
+  if (openaiToolChoice) body.tool_choice = openaiToolChoice;
+  if (req.stream) body.stream_options = { include_usage: true };
+
+  return body;
+}
+
+/**
+ * Convert Anthropic messages array + system prompt to OpenAI messages.
+ */
+function convertMessages(
+  messages: AnthropicMessage[],
+  system?: string | { type: string; text: string }[],
+): OpenAIMessage[] {
+  const result: OpenAIMessage[] = [];
+
+  // System prompt
+  if (system) {
+    const systemText = typeof system === 'string'
+      ? system
+      : system.map(b => b.text).join('\n');
+    if (systemText) {
+      result.push({ role: 'system', content: systemText });
+    }
+  }
+
+  for (const msg of messages) {
+    if (msg.role === 'user') {
+      convertUserMessage(msg, result);
+    } else if (msg.role === 'assistant') {
+      convertAssistantMessage(msg, result);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Convert a user message. Anthropic user messages can contain interleaved
+ * text and tool_result blocks. OpenAI requires tool results as separate messages.
+ */
+function convertUserMessage(msg: AnthropicMessage, result: OpenAIMessage[]): void {
+  if (typeof msg.content === 'string') {
+    result.push({ role: 'user', content: msg.content });
+    return;
+  }
+
+  const textParts: string[] = [];
+  const imageParts: OpenAIContentPart[] = [];
+
+  for (const block of msg.content) {
+    switch (block.type) {
+      case 'text':
+        textParts.push(block.text);
+        break;
+
+      case 'tool_result': {
+        // Each tool_result becomes a separate OpenAI tool message
+        let content: string;
+        if (typeof block.content === 'string') {
+          content = block.content;
+        } else if (Array.isArray(block.content)) {
+          content = block.content
+            .map(b => ('text' in b ? b.text : JSON.stringify(b)))
+            .join('\n');
+        } else {
+          content = '';
+        }
+        if (block.is_error) {
+          content = `[ERROR] ${content}`;
+        }
+        result.push({
+          role: 'tool',
+          tool_call_id: block.tool_use_id,
+          content,
+        });
+        break;
+      }
+
+      case 'image': {
+        // Convert base64 image to OpenAI image_url format
+        const dataUrl = `data:${block.source.media_type};base64,${block.source.data}`;
+        imageParts.push({ type: 'image_url', image_url: { url: dataUrl } });
+        break;
+      }
+    }
+  }
+
+  // Emit text/image as user message
+  if (textParts.length > 0 && imageParts.length === 0) {
+    result.push({ role: 'user', content: textParts.join('\n') });
+  } else if (imageParts.length > 0) {
+    const parts: OpenAIContentPart[] = [];
+    if (textParts.length > 0) {
+      parts.push({ type: 'text', text: textParts.join('\n') });
+    }
+    parts.push(...imageParts);
+    result.push({ role: 'user', content: parts });
+  }
+}
+
+/**
+ * Convert an assistant message. Anthropic assistant messages can contain
+ * text, thinking, and tool_use blocks. OpenAI uses tool_calls array.
+ */
+function convertAssistantMessage(msg: AnthropicMessage, result: OpenAIMessage[]): void {
+  if (typeof msg.content === 'string') {
+    result.push({ role: 'assistant', content: msg.content });
+    return;
+  }
+
+  const textParts: string[] = [];
+  const toolCalls: OpenAIToolCall[] = [];
+
+  for (const block of msg.content) {
+    switch (block.type) {
+      case 'text':
+        textParts.push(block.text);
+        break;
+
+      case 'thinking':
+        // Thinking blocks: some providers support reasoning_content,
+        // but for history replay we skip them (provider generates its own thinking)
+        break;
+
+      case 'tool_use':
+        toolCalls.push({
+          id: block.id,
+          type: 'function',
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input),
+          },
+        });
+        break;
+    }
+  }
+
+  const assistantMsg: any = { role: 'assistant' };
+  assistantMsg.content = textParts.length > 0 ? textParts.join('\n') : null;
+  if (toolCalls.length > 0) assistantMsg.tool_calls = toolCalls;
+
+  result.push(assistantMsg as OpenAIMessage);
+}
+
+/**
+ * Convert Anthropic tool definitions to OpenAI format.
+ */
+function convertTools(tools?: AnthropicToolDefinition[]): OpenAITool[] | undefined {
+  if (!tools || tools.length === 0) return undefined;
+  return tools.map(tool => ({
+    type: 'function' as const,
+    function: {
+      name: tool.name,
+      description: tool.description || '',
+      parameters: tool.input_schema || {},
+    },
+  }));
+}
+
+/**
+ * Convert Anthropic tool_choice to OpenAI format.
+ */
+function convertToolChoice(
+  choice?: AnthropicToolChoice,
+): string | { type: 'function'; function: { name: string } } | undefined {
+  if (!choice) return undefined;
+
+  switch (choice.type) {
+    case 'auto': return 'auto';
+    case 'any': return 'required';
+    case 'tool': return { type: 'function', function: { name: choice.name } };
+    default: return 'auto';
+  }
+}

package/src/converter/response.ts

@@ -0,0 +1,85 @@
+import type {
+  AnthropicResponse,
+  AnthropicResponseBlock,
+  OpenAIResponse,
+} from './types';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Convert an OpenAI Chat Completions response to Anthropic Messages format.
+ * Used for non-streaming requests only.
+ */
+export function convertResponse(
+  openaiResp: OpenAIResponse,
+  displayModel: string,
+): AnthropicResponse {
+  const choice = openaiResp.choices?.[0];
+  if (!choice) {
+    return {
+      id: `msg_${uuidv4().replace(/-/g, '')}`,
+      type: 'message',
+      role: 'assistant',
+      model: displayModel,
+      content: [{ type: 'text', text: 'No response from backend.' }],
+      stop_reason: 'end_turn',
+      stop_sequence: null,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    };
+  }
+
+  const msg = choice.message;
+  const content: AnthropicResponseBlock[] = [];
+
+  // Reasoning / thinking content
+  if (msg.reasoning_content) {
+    content.push({ type: 'thinking', thinking: msg.reasoning_content });
+  }
+
+  // Text content
+  if (msg.content) {
+    content.push({ type: 'text', text: msg.content });
+  }
+
+  // Tool calls
+  if (msg.tool_calls && msg.tool_calls.length > 0) {
+    for (const tc of msg.tool_calls) {
+      let input: Record<string, unknown> = {};
+      try { input = JSON.parse(tc.function.arguments); } catch {}
+      content.push({
+        type: 'tool_use',
+        id: tc.id || `toolu_${uuidv4().replace(/-/g, '').slice(0, 24)}`,
+        name: tc.function.name,
+        input,
+      });
+    }
+  }
+
+  // If no content at all, add empty text
+  if (content.length === 0) {
+    content.push({ type: 'text', text: '' });
+  }
+
+  // Determine stop reason
+  let stopReason: AnthropicResponse['stop_reason'] = 'end_turn';
+  if (msg.tool_calls && msg.tool_calls.length > 0) {
+    stopReason = 'tool_use';
+  } else if (choice.finish_reason === 'length') {
+    stopReason = 'max_tokens';
+  }
+
+  const usage = openaiResp.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+
+  return {
+    id: `msg_${uuidv4().replace(/-/g, '')}`,
+    type: 'message',
+    role: 'assistant',
+    model: displayModel,
+    content,
+    stop_reason: stopReason,
+    stop_sequence: null,
+    usage: {
+      input_tokens: usage.prompt_tokens,
+      output_tokens: usage.completion_tokens,
+    },
+  };
+}