iflow-local-proxy 1.0.0

package/src/anthropic/adapter.js

@@ -0,0 +1,457 @@
+/**
+ * Anthropic Messages API <-> OpenAI Chat Completions API 格式转换适配器
+ * 支持: 文本消息、system prompt、tool_use / tool_result、图片(base64)、流式/非流式
+ */
+
+import { randomBytes } from 'crypto';
+
+// ========================================
+// Anthropic 请求 → OpenAI 请求
+// ========================================
+
+export function anthropicToOpenAI(req) {
+  const openai = {
+    model: req.model,
+    max_tokens: req.max_tokens,
+    stream: req.stream || false,
+    messages: [],
+  };
+
+  // system prompt
+  if (req.system) {
+    if (typeof req.system === 'string') {
+      openai.messages.push({ role: 'system', content: req.system });
+    } else if (Array.isArray(req.system)) {
+      const text = req.system.filter(b => b.type === 'text').map(b => b.text).join('\n');
+      if (text) openai.messages.push({ role: 'system', content: text });
+    }
+  }
+
+  // messages
+  for (const msg of req.messages || []) {
+    if (msg.role === 'assistant') {
+      const converted = convertAssistantMsg(msg);
+      if (Array.isArray(converted)) {
+        openai.messages.push(...converted);
+      } else {
+        openai.messages.push(converted);
+      }
+    } else if (msg.role === 'user') {
+      const expanded = expandUserMsg(msg);
+      openai.messages.push(...expanded);
+    }
+  }
+
+  // optional params
+  if (req.temperature !== undefined) openai.temperature = req.temperature;
+  if (req.top_p !== undefined) openai.top_p = req.top_p;
+  if (req.stop_sequences) openai.stop = req.stop_sequences;
+
+  // tools
+  if (req.tools?.length) {
+    openai.tools = req.tools.map(t => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description || '',
+        parameters: t.input_schema || { type: 'object' },
+      },
+    }));
+  }
+
+  // tool_choice
+  if (req.tool_choice) {
+    const tc = req.tool_choice;
+    if (tc.type === 'auto') openai.tool_choice = 'auto';
+    else if (tc.type === 'any') openai.tool_choice = 'required';
+    else if (tc.type === 'tool') openai.tool_choice = { type: 'function', function: { name: tc.name } };
+    else if (tc.type === 'none') openai.tool_choice = 'none';
+  }
+
+  return openai;
+}
+
+function convertAssistantMsg(msg) {
+  if (typeof msg.content === 'string') {
+    return { role: 'assistant', content: msg.content };
+  }
+
+  const textParts = [];
+  const toolCalls = [];
+
+  for (const block of msg.content || []) {
+    if (block.type === 'text') {
+      textParts.push(block.text);
+    } else if (block.type === 'thinking') {
+      if (block.thinking) textParts.push(block.thinking);
+    } else if (block.type === 'tool_use') {
+      toolCalls.push({
+        id: block.id,
+        type: 'function',
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input),
+        },
+      });
+    }
+  }
+
+  const result = { role: 'assistant', content: textParts.join('\n') || null };
+  if (toolCalls.length) result.tool_calls = toolCalls;
+  return result;
+}
+
+function expandUserMsg(msg) {
+  if (typeof msg.content === 'string') {
+    return [{ role: 'user', content: msg.content }];
+  }
+
+  const results = [];
+  const contentParts = [];
+  let hasImage = false;
+
+  for (const block of msg.content || []) {
+    if (block.type === 'tool_result') {
+      results.push({
+        role: 'tool',
+        tool_call_id: block.tool_use_id,
+        content: extractTextContent(block.content),
+      });
+    } else if (block.type === 'text') {
+      contentParts.push({ type: 'text', text: block.text });
+    } else if (block.type === 'image') {
+      if (block.source?.type === 'base64') {
+        hasImage = true;
+        contentParts.push({
+          type: 'image_url',
+          image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` },
+        });
+      }
+    }
+  }
+
+  if (contentParts.length) {
+    if (hasImage) {
+      results.push({ role: 'user', content: contentParts });
+    } else {
+      results.push({ role: 'user', content: contentParts.map(p => p.text).join('\n') });
+    }
+  }
+
+  return results.length ? results : [{ role: 'user', content: '' }];
+}
+
+function extractTextContent(content) {
+  if (!content) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+  }
+  return JSON.stringify(content);
+}
+
+// ========================================
+// OpenAI 响应 → Anthropic 响应
+// ========================================
+
+export function openAIToAnthropic(resp, model) {
+  const content = [];
+
+  for (const choice of resp.choices || []) {
+    if (choice?.message?.content) {
+      content.push({ type: 'text', text: choice.message.content });
+    }
+    if (choice?.message?.tool_calls) {
+      for (const tc of choice.message.tool_calls) {
+        content.push({
+          type: 'tool_use',
+          id: tc.id || `toolu_${randomBytes(12).toString('hex')}`,
+          name: tc.function.name,
+          input: safeJsonParse(tc.function.arguments),
+        });
+      }
+    }
+  }
+
+  if (!content.length) content.push({ type: 'text', text: '' });
+
+  const firstChoice = resp.choices?.[0];
+  const cachedTokens = resp.usage?.prompt_tokens_details?.cached_tokens;
+  const usage = {
+    input_tokens: (resp.usage?.prompt_tokens || 0) - (cachedTokens || 0),
+    output_tokens: resp.usage?.completion_tokens || 0,
+  };
+  if (cachedTokens !== undefined) {
+    usage.cache_read_input_tokens = cachedTokens;
+  }
+
+  return {
+    id: `msg_${randomBytes(12).toString('hex')}`,
+    type: 'message',
+    role: 'assistant',
+    content,
+    model: model || resp.model,
+    stop_reason: mapStopReason(firstChoice?.finish_reason),
+    stop_sequence: null,
+    usage,
+  };
+}
+
+function mapStopReason(reason) {
+  switch (reason) {
+    case 'stop': return 'end_turn';
+    case 'length': return 'max_tokens';
+    case 'tool_calls': return 'tool_use';
+    case 'tool_call': return 'tool_use';
+    case 'content_filter': return 'end_turn';
+    default: return 'end_turn';
+  }
+}
+
+function safeJsonParse(str) {
+  try { return JSON.parse(str); } catch { return {}; }
+}
+
+// ========================================
+// Anthropic 格式错误响应
+// ========================================
+
+export function anthropicError(status, message) {
+  const typeMap = {
+    400: 'invalid_request_error',
+    401: 'authentication_error',
+    403: 'permission_error',
+    404: 'not_found_error',
+    429: 'rate_limit_error',
+    500: 'api_error',
+    529: 'overloaded_error',
+  };
+  return {
+    type: 'error',
+    error: {
+      type: typeMap[status] || 'api_error',
+      message,
+    },
+  };
+}
+
+// ========================================
+// 流式适配器: OpenAI SSE → Anthropic SSE
+// ========================================
+
+export class AnthropicStreamAdapter {
+  constructor(res, model) {
+    this.res = res;
+    this.model = model;
+    this.msgId = `msg_${randomBytes(12).toString('hex')}`;
+
+    this.started = false;
+    this.contentBlockOpen = false;
+    this.finished = false;
+    this.blockIndex = 0;
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.cachedTokens = undefined;
+    this.lastFinishReason = null;
+
+    this.toolBlockMap = new Map();
+    this.textBlockOpen = false;
+    this.buffer = '';
+  }
+
+  _emit(event, data) {
+    this.res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  }
+
+  _ensureStarted() {
+    if (this.started) return;
+    this.started = true;
+    this._emit('message_start', {
+      type: 'message_start',
+      message: {
+        id: this.msgId, type: 'message', role: 'assistant',
+        content: [], model: this.model,
+        stop_reason: null, stop_sequence: null,
+        usage: { input_tokens: this.inputTokens, output_tokens: 0 },
+      },
+    });
+    this._emit('ping', { type: 'ping' });
+  }
+
+  _openTextBlock() {
+    if (this.textBlockOpen) return;
+    this._ensureStarted();
+    this.textBlockOpen = true;
+    this._emit('content_block_start', {
+      type: 'content_block_start',
+      index: this.blockIndex,
+      content_block: { type: 'text', text: '' },
+    });
+  }
+
+  _closeTextBlock() {
+    if (this.textBlockOpen) {
+      this._emit('content_block_stop', { type: 'content_block_stop', index: this.blockIndex });
+      this.blockIndex++;
+      this.textBlockOpen = false;
+      this.contentBlockOpen = false;
+    }
+  }
+
+  _closeToolBlock(openaiIdx) {
+    const info = this.toolBlockMap.get(openaiIdx);
+    if (info && info.open) {
+      this._emit('content_block_stop', { type: 'content_block_stop', index: info.anthropicBlockIndex });
+      info.open = false;
+      this.contentBlockOpen = false;
+    }
+  }
+
+  _closeAllOpenBlocks() {
+    this._closeTextBlock();
+    for (const [idx] of this.toolBlockMap) {
+      this._closeToolBlock(idx);
+    }
+  }
+
+  feed(rawData) {
+    this.buffer += rawData;
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('data:')) {
+        this._processDataLine(trimmed);
+      }
+    }
+  }
+
+  _processDataLine(line) {
+    let payload;
+    if (line.startsWith('data: ')) {
+      payload = line.slice(6).trim();
+    } else if (line.startsWith('data:')) {
+      payload = line.slice(5).trim();
+    } else {
+      return;
+    }
+    if (payload === '[DONE]') {
+      this._finalize();
+      return;
+    }
+
+    let chunk;
+    try { chunk = JSON.parse(payload); } catch { return; }
+
+    const choice = chunk.choices?.[0];
+    if (!choice) return;
+
+    const delta = choice.delta || {};
+    this._ensureStarted();
+
+    // usage
+    if (chunk.usage) {
+      this.inputTokens = chunk.usage.prompt_tokens || 0;
+      this.outputTokens = chunk.usage.completion_tokens || 0;
+      if (chunk.usage.prompt_tokens_details?.cached_tokens !== undefined) {
+        this.cachedTokens = chunk.usage.prompt_tokens_details.cached_tokens;
+      }
+    }
+
+    // text
+    if (delta.content) {
+      for (const [idx] of this.toolBlockMap) {
+        this._closeToolBlock(idx);
+      }
+      this._openTextBlock();
+      this._emit('content_block_delta', {
+        type: 'content_block_delta',
+        index: this.blockIndex,
+        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;
+        const existingInfo = this.toolBlockMap.get(idx);
+
+        if (tc.id && !existingInfo) {
+          this._closeAllOpenBlocks();
+          const bi = this.blockIndex;
+          this.toolBlockMap.set(idx, { anthropicBlockIndex: bi, open: true, id: tc.id });
+          this._emit('content_block_start', {
+            type: 'content_block_start',
+            index: bi,
+            content_block: { type: 'tool_use', id: tc.id, name: tc.function?.name || '', input: {} },
+          });
+          this.contentBlockOpen = true;
+          this.blockIndex++;
+
+          if (tc.function?.arguments) {
+            this._emit('content_block_delta', {
+              type: 'content_block_delta',
+              index: bi,
+              delta: { type: 'input_json_delta', partial_json: tc.function.arguments },
+            });
+          }
+        } else if (tc.function?.arguments) {
+          const info = existingInfo || this.toolBlockMap.get(idx);
+          const bi = info ? info.anthropicBlockIndex : (this.blockIndex - 1);
+          this._emit('content_block_delta', {
+            type: 'content_block_delta',
+            index: bi,
+            delta: { type: 'input_json_delta', partial_json: tc.function.arguments },
+          });
+        }
+      }
+    }
+
+    // finish_reason
+    if (choice.finish_reason && choice.finish_reason !== '') {
+      const reason = choice.finish_reason;
+      if (reason === 'tool_calls' || reason === 'tool_call') {
+        this.lastFinishReason = reason;
+      } else if (!this.lastFinishReason || (this.lastFinishReason !== 'tool_calls' && this.lastFinishReason !== 'tool_call')) {
+        this.lastFinishReason = reason;
+      }
+    }
+  }
+
+  flush() {
+    if (this.buffer.trim()) {
+      const trimmed = this.buffer.trim();
+      this.buffer = '';
+      if (trimmed.startsWith('data:')) {
+        this._processDataLine(trimmed);
+      }
+    }
+    this._finalize();
+  }
+
+  _finalize() {
+    if (this.finished) return;
+    this._ensureStarted();
+    this._closeAllOpenBlocks();
+    this.toolBlockMap.clear();
+
+    const stopReason = mapStopReason(this.lastFinishReason) || 'end_turn';
+    const usage = { output_tokens: this.outputTokens };
+    if (this.cachedTokens !== undefined) {
+      usage.input_tokens = this.inputTokens - this.cachedTokens;
+      usage.cache_read_input_tokens = this.cachedTokens;
+    } else {
+      usage.input_tokens = this.inputTokens;
+    }
+
+    this._emit('message_delta', {
+      type: 'message_delta',
+      delta: { stop_reason: stopReason, stop_sequence: null },
+      usage,
+    });
+    this._emit('message_stop', { type: 'message_stop' });
+    this.finished = true;
+  }
+}

package/src/auth/credentials.js

@@ -0,0 +1,239 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * iFlow 凭据管理 - 加载、保存、刷新
+ */
+
+export function resolveAuthDir(authDir) {
+  if (authDir.startsWith('~')) {
+    return path.join(os.homedir(), authDir.slice(1));
+  }
+  return path.resolve(authDir);
+}
+
+/**
+ * 加载所有 iFlow 凭据文件（跳过 disabled）
+ */
+export function loadCredentials(authDir) {
+  const dir = resolveAuthDir(authDir);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    return [];
+  }
+
+  const files = fs.readdirSync(dir).filter(f => f.startsWith('iflow-') && f.endsWith('.json'));
+  const credentials = [];
+
+  for (const filename of files) {
+    try {
+      const content = fs.readFileSync(path.join(dir, filename), 'utf-8');
+      const data = JSON.parse(content);
+      if (!data.disabled) {
+        credentials.push({ filename, data });
+      }
+    } catch (err) {
+      console.warn(`[warn] 加载凭据失败: ${filename}`, err.message);
+    }
+  }
+
+  return credentials;
+}
+
+/**
+ * 加载单个凭据（单账号模式，取第一个非 disabled 的）
+ */
+export function loadCredential(authDir) {
+  const creds = loadCredentials(authDir);
+  return creds.length > 0 ? creds[0] : null;
+}
+
+/**
+ * 加载全部凭据（含 disabled）
+ */
+export function loadAllCredentials(authDir) {
+  const dir = resolveAuthDir(authDir);
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir).filter(f => f.startsWith('iflow-') && f.endsWith('.json'));
+  return files.map(filename => {
+    try {
+      const content = fs.readFileSync(path.join(dir, filename), 'utf-8');
+      return { filename, data: JSON.parse(content) };
+    } catch { return null; }
+  }).filter(Boolean);
+}
+
+/**
+ * 保存凭据
+ */
+export function saveCredential(authDir, filename, data) {
+  const dir = resolveAuthDir(authDir);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(path.join(dir, filename), JSON.stringify(data, null, 2), 'utf-8');
+}
+
+// ========================
+// OAuth Token 刷新
+// ========================
+
+const OAUTH_TOKEN_URL = 'https://iflow.cn/oauth/token';
+const CLIENT_ID = '10009311001';
+const CLIENT_SECRET = '4Z3YjXycVsQvyGF1etiNlIBB4RsqSDtW';
+const USER_INFO_URL = 'https://iflow.cn/api/oauth/getUserInfo';
+
+/**
+ * 使用 refresh_token 刷新 OAuth 凭据
+ */
+export async function refreshOAuthToken(credential, authDir) {
+  const { data, filename } = credential;
+  if (!data.refresh_token) return false;
+
+  try {
+    const basicAuth = Buffer.from(`${CLIENT_ID}:${CLIENT_SECRET}`).toString('base64');
+
+    const tokenResp = await fetch(OAUTH_TOKEN_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Authorization': `Basic ${basicAuth}`,
+      },
+      body: new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: data.refresh_token,
+      }),
+    });
+
+    if (!tokenResp.ok) {
+      console.error(`[error] OAuth 刷新失败 [${filename}]: HTTP ${tokenResp.status}`);
+      return false;
+    }
+
+    const tokenData = await tokenResp.json();
+
+    if (!tokenData.access_token) {
+      console.error(`[error] OAuth 刷新返回空 access_token [${filename}]`);
+      return false;
+    }
+
+    // 获取用户信息验证
+    const userResp = await fetch(`${USER_INFO_URL}?accessToken=${encodeURIComponent(tokenData.access_token)}`, {
+      headers: { 'Accept': 'application/json' },
+    });
+
+    let apiKey = data.api_key;
+
+    if (userResp.ok) {
+      const userInfo = await userResp.json();
+      if (userInfo.success === false || userInfo.code === 'INVALID_TOKEN') {
+        console.error(`[error] 刷新获得的 access_token 无效 [${filename}]`);
+        data.refresh_failed_at = new Date().toISOString();
+        saveCredential(authDir, filename, data);
+        return false;
+      }
+      if (userInfo.data?.apiKey) {
+        apiKey = userInfo.data.apiKey;
+      }
+      if (data.email === 'unknown') {
+        const newEmail = (userInfo.data?.email || userInfo.data?.phone || '').trim();
+        if (newEmail) data.email = newEmail;
+      }
+    } else {
+      console.error(`[error] getUserInfo HTTP 失败 [${filename}]: ${userResp.status}`);
+      return false;
+    }
+
+    // 更新凭据
+    data.access_token = tokenData.access_token;
+    if (tokenData.refresh_token) data.refresh_token = tokenData.refresh_token;
+    data.api_key = apiKey;
+    data.last_refresh = new Date().toISOString();
+    delete data.refresh_failed_at;
+    if (tokenData.expires_in) {
+      data.expired = new Date(Date.now() + tokenData.expires_in * 1000).toISOString();
+    }
+
+    saveCredential(authDir, filename, data);
+    console.log(`[info] OAuth 刷新成功: ${filename} (到期: ${data.expired})`);
+    return true;
+  } catch (err) {
+    console.error(`[error] OAuth 刷新异常 [${filename}]:`, err.message);
+    return false;
+  }
+}
+
+/**
+ * 使用 Cookie 刷新 API Key
+ */
+export async function refreshCookieApiKey(credential, authDir) {
+  const { data, filename } = credential;
+  if (!data.cookie) return false;
+
+  try {
+    const resp = await fetch('https://platform.iflow.cn/api/openapi/apikey', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Cookie': data.cookie,
+      },
+      body: JSON.stringify({ name: data.email || 'iflow-proxy' }),
+    });
+
+    if (!resp.ok) {
+      console.error(`[error] Cookie 刷新失败 [${filename}]: ${resp.status}`);
+      return false;
+    }
+
+    const result = await resp.json();
+    if (result.data?.apiKey) {
+      data.api_key = result.data.apiKey;
+      data.last_refresh = new Date().toISOString();
+      data.expired = new Date(Date.now() + 48 * 3600 * 1000).toISOString();
+      saveCredential(authDir, filename, data);
+      console.log(`[info] Cookie 刷新成功: ${filename}`);
+      return true;
+    }
+
+    return false;
+  } catch (err) {
+    console.error(`[error] Cookie 刷新异常 [${filename}]:`, err.message);
+    return false;
+  }
+}
+
+/**
+ * 刷新即将过期的凭据
+ */
+export async function refreshExpiring(credentials, authDir) {
+  const leadTime = 47 * 3600 * 1000;
+  const failedAccounts = [];
+
+  for (const cred of credentials) {
+    if (cred.data.disabled) continue;
+
+    const expired = new Date(cred.data.expired).getTime();
+    if (isNaN(expired)) continue;
+
+    if (Date.now() + leadTime > expired) {
+      const hoursLeft = Math.round((expired - Date.now()) / 3600000);
+      console.log(`[info] 凭据将在 ${hoursLeft}h 后过期，正在刷新: ${cred.filename}`);
+
+      let success = false;
+      if (cred.data.cookie) {
+        success = await refreshCookieApiKey(cred, authDir);
+      } else if (cred.data.refresh_token) {
+        success = await refreshOAuthToken(cred, authDir);
+      }
+
+      if (!success) {
+        failedAccounts.push({ filename: cred.filename, email: cred.data.email });
+        console.error(`[ALERT] 凭据刷新失败: ${cred.filename} (${cred.data.email})`);
+      }
+    }
+  }
+
+  return failedAccounts;
+}