Upload 19 files

anthropic-adapter.js

@@ -9,7 +9,8 @@
 import crypto from 'crypto';
 import { createContext, sendMessageStreaming } from './chat.js';
 import { anthropicToText, resolveModel } from './message-convert.js';
-import { transformToAnthropicSSE, collectFullResponse } from './stream-transform.js';
+import { transformToAnthropicSSE, collectFullResponse, transformToAnthropicSSEWithTools } from './stream-transform.js';
+import { parseToolCalls, toAnthropicToolUse } from './tool-prompt.js';
 
 const MAX_RETRY = 3;
 
@@ -44,10 +45,11 @@ export async function handleMessages(body, res, pool) {
     return;
   }
 
-  const text = anthropicToText(body.system, body.messages);
+  const text = anthropicToText(body.system, body.messages, body.tools, body.tool_choice);
   const model = resolveModel(body.model);
   const clientModel = body.model || 'claude-3-sonnet';
   const stream = body.stream === true;
+  const hasTools = body.tools && body.tools.length > 0;
 
   if (!text) {
     sendError(res, 400, 'No valid message content found');
@@ -74,15 +76,27 @@ export async function handleMessages(body, res, pool) {
         const result = await sendMessageStreaming(account.cookies, ctx.chatId, text, model);
         if (result.cookies) account.cookies = result.cookies;
 
-        transformToAnthropicSSE(result.stream, res, clientModel, requestId, (errMsg) => {
-          const msg = (errMsg || '').toLowerCase();
-          if (msg.includes('limit') || msg.includes('quota') || msg.includes('exhaust') || msg.includes('exceed')) {
-            pool.release(account, { quotaExhausted: true });
-          } else {
-            pool.release(account, { success: false });
-          }
-          account = null;
-        });
+        if (hasTools) {
+          transformToAnthropicSSEWithTools(result.stream, res, clientModel, requestId, (errMsg) => {
+            const msg = (errMsg || '').toLowerCase();
+            if (msg.includes('limit') || msg.includes('quota') || msg.includes('exhaust') || msg.includes('exceed')) {
+              pool.release(account, { quotaExhausted: true });
+            } else {
+              pool.release(account, { success: false });
+            }
+            account = null;
+          });
+        } else {
+          transformToAnthropicSSE(result.stream, res, clientModel, requestId, (errMsg) => {
+            const msg = (errMsg || '').toLowerCase();
+            if (msg.includes('limit') || msg.includes('quota') || msg.includes('exhaust') || msg.includes('exceed')) {
+              pool.release(account, { quotaExhausted: true });
+            } else {
+              pool.release(account, { success: false });
+            }
+            account = null;
+          });
+        }
         result.stream.on('end', () => { if (account) pool.release(account, { success: true }); });
         result.stream.on('error', (err) => {
           if (!account) return;
@@ -131,6 +145,22 @@ export async function handleMessages(body, res, pool) {
       const full = await collectFullResponse(result.stream);
       pool.release(account, { success: true });
 
+      // 检测工具调用
+      const { hasToolCalls, toolCalls, textContent } = hasTools
+        ? parseToolCalls(full.text)
+        : { hasToolCalls: false, toolCalls: [], textContent: full.text };
+
+      const content = [];
+      if (textContent) {
+        content.push({ type: 'text', text: textContent });
+      }
+      if (hasToolCalls) {
+        content.push(...toAnthropicToolUse(toolCalls));
+      }
+      if (content.length === 0) {
+        content.push({ type: 'text', text: full.text });
+      }
+
       res.writeHead(200, {
         'Content-Type': 'application/json',
         'Access-Control-Allow-Origin': '*',
@@ -140,8 +170,8 @@ export async function handleMessages(body, res, pool) {
         type: 'message',
         role: 'assistant',
         model: clientModel,
-        content: [{ type: 'text', text: full.text }],
-        stop_reason: 'end_turn',
+        content,
+        stop_reason: hasToolCalls ? 'tool_use' : 'end_turn',
         stop_sequence: null,
         usage: { input_tokens: 0, output_tokens: 0 },
       }));

mail.js

@@ -35,6 +35,25 @@ function prompt(question) {
 
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 
+/**
+ * 按域名限流器 — 确保对同一域名的请求间隔不小于 minGap ms
+ * 避免 Mail.tm 等服务 429
+ */
+const _rateLimitState = {};  // { [host]: { queue: Promise, lastReq: number } }
+function rateLimitWrap(host, fn, minGap = 1200) {
+  if (!_rateLimitState[host]) _rateLimitState[host] = { queue: Promise.resolve() };
+  const state = _rateLimitState[host];
+  const job = state.queue.then(async () => {
+    const now = Date.now();
+    const elapsed = now - (state.lastReq || 0);
+    if (elapsed < minGap) await sleep(minGap - elapsed);
+    state.lastReq = Date.now();
+    return fn();
+  });
+  state.queue = job.catch(() => {});  // 不让单次失败阻塞后续
+  return job;
+}
+
 function httpsGet(url, options = {}) {
   return new Promise((resolve, reject) => {
     const urlObj = new URL(url);
@@ -313,6 +332,7 @@ class GPTMailProvider extends MailProvider {
     return false;
   }
 
+  
   async _pickGoodEmail() {
     const candidates = [];
     const tasks = Array.from({ length: 8 }, () =>
@@ -618,9 +638,14 @@ class MailTmProvider extends MailProvider {
     this.accountPassword = null;
   }
 
+  /** 限流包装 — 所有 Mail.tm API 请求都走这里 */
+  _req(method, pathStr, body, extraHeaders) {
+    return rateLimitWrap(this.apiHost, () => httpsRequest(method, this.apiHost, pathStr, body, extraHeaders || {}));
+  }
+
   async createInbox() {
     // 1. 获取可用域名
-    const domainsResp = await httpsRequest('GET', this.apiHost, '/domains');
+    const domainsResp = await this._req('GET', '/domains');
     if (!domainsResp.ok) throw new Error(`Mail.tm 获取域名失败: ${domainsResp.status}`);
     const domains = domainsResp.data['hydra:member'] || domainsResp.data || [];
     if (!domains?.length) throw new Error('Mail.tm 无可用域名');
@@ -631,7 +656,7 @@ class MailTmProvider extends MailProvider {
     const email = `${user}@${domain}`;
     this.accountPassword = crypto.randomBytes(12).toString('base64url');
 
-    const createResp = await httpsRequest('POST', this.apiHost, '/accounts', {
+    const createResp = await this._req('POST', '/accounts', {
       address: email,
       password: this.accountPassword,
     });
@@ -639,7 +664,7 @@ class MailTmProvider extends MailProvider {
     this.accountId = createResp.data.id;
 
     // 3. 登录获取 JWT
-    const loginResp = await httpsRequest('POST', this.apiHost, '/token', {
+    const loginResp = await this._req('POST', '/token', {
       address: email,
       password: this.accountPassword,
     });
@@ -665,7 +690,7 @@ class MailTmProvider extends MailProvider {
 
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       try {
-        const resp = await httpsRequest('GET', this.apiHost, '/messages', null, {
+        const resp = await this._req('GET', '/messages', null, {
           'Authorization': `Bearer ${this.jwtToken}`,
         });
         if (!resp.ok) { await sleep(pollInterval); continue; }
@@ -684,7 +709,7 @@ class MailTmProvider extends MailProvider {
 
           // 获取邮件详情
           if (msg.id) {
-            const detailResp = await httpsRequest('GET', this.apiHost, `/messages/${msg.id}`, null, {
+            const detailResp = await this._req('GET', `/messages/${msg.id}`, null, {
               'Authorization': `Bearer ${this.jwtToken}`,
             });
             if (detailResp.ok) {
@@ -699,7 +724,7 @@ class MailTmProvider extends MailProvider {
               }
 
               // 如果详情解析失败，尝试 /sources 获取原始 MIME
-              const srcResp = await httpsRequest('GET', this.apiHost, `/sources/${msg.id}`, null, {
+              const srcResp = await this._req('GET', `/sources/${msg.id}`, null, {
                 'Authorization': `Bearer ${this.jwtToken}`,
               });
               if (srcResp.ok) {
@@ -726,7 +751,7 @@ class MailTmProvider extends MailProvider {
   async cleanup() {
     if (this.jwtToken && this.accountId) {
       try {
-        await httpsRequest('DELETE', this.apiHost, `/accounts/${this.accountId}`, null, {
+        await this._req('DELETE', `/accounts/${this.accountId}`, null, {
           'Authorization': `Bearer ${this.jwtToken}`,
         });
       } catch {}

message-convert.js

@@ -6,6 +6,7 @@
  */
 
 import config from './config.js';
+import { serializeTools, serializeToolsAnthropic } from './tool-prompt.js';
 
 /**
  * 从 content 字段提取纯文本
@@ -24,25 +25,55 @@ function extractText(content) {
 
 /**
  * OpenAI messages → chataibot text
- * @param {Array} messages - [{ role: 'system'|'user'|'assistant', content }]
+ * @param {Array} messages - [{ role: 'system'|'user'|'assistant'|'tool', content }]
+ * @param {Array} [tools] - OpenAI tools 数组
+ * @param {*} [toolChoice] - tool_choice 参数
  */
-export function openaiToText(messages) {
+export function openaiToText(messages, tools, toolChoice) {
   if (!messages || !messages.length) return '';
 
   const system = messages.filter(m => m.role === 'system').map(m => extractText(m.content)).join('\n');
   const conversation = messages.filter(m => m.role !== 'system');
 
+  // 工具定义注入到 system prompt 末尾
+  const toolPrompt = serializeTools(tools, toolChoice);
+
+  // 处理 tool 角色消息 (工具返回结果) — 转为文本格式
+  const processedConversation = [];
+  for (const msg of conversation) {
+    if (msg.role === 'tool') {
+      // 工具返回结果，格式化为文本
+      const toolName = msg.name || msg.tool_call_id || 'unknown';
+      processedConversation.push({
+        role: 'user',
+        content: `[Tool Result: ${toolName}]\n${extractText(msg.content)}`,
+      });
+    } else if (msg.role === 'assistant' && msg.tool_calls) {
+      // assistant 发起的工具调用 — 转为文本表示
+      let callText = extractText(msg.content) || '';
+      for (const tc of msg.tool_calls) {
+        const fn = tc.function || {};
+        callText += `\n\`\`\`tool_calls\n[{"name": "${fn.name}", "arguments": ${fn.arguments || '{}'}}]\n\`\`\``;
+      }
+      processedConversation.push({ role: 'assistant', content: callText.trim() });
+    } else {
+      processedConversation.push(msg);
+    }
+  }
+
+  const fullSystem = system + toolPrompt;
+
   // 单轮: 只有一条 user 消息
-  if (conversation.length === 1 && conversation[0].role === 'user') {
-    const userText = extractText(conversation[0].content);
-    return system ? `${system}\n\n${userText}` : userText;
+  if (processedConversation.length === 1 && processedConversation[0].role === 'user') {
+    const userText = extractText(processedConversation[0].content);
+    return fullSystem ? `${fullSystem}\n\n${userText}` : userText;
   }
 
   // 多轮: 格式化为带角色标签的文本
   let text = '';
-  if (system) text += `[System] ${system}\n\n`;
+  if (fullSystem) text += `[System] ${fullSystem}\n\n`;
 
-  for (const msg of conversation) {
+  for (const msg of processedConversation) {
     const role = msg.role === 'assistant' ? 'Assistant' : 'User';
     text += `[${role}] ${extractText(msg.content)}\n\n`;
   }
@@ -54,23 +85,58 @@ export function openaiToText(messages) {
  * Anthropic messages → chataibot text
  * @param {string|undefined} system - system prompt (Anthropic 单独字段)
  * @param {Array} messages - [{ role: 'user'|'assistant', content }]
+ * @param {Array} [tools] - Anthropic tools 数组
+ * @param {*} [toolChoice] - tool_choice 参数
  */
-export function anthropicToText(system, messages) {
+export function anthropicToText(system, messages, tools, toolChoice) {
   if (!messages || !messages.length) return system || '';
 
+  // 工具定义注入到 system prompt 末尾
+  const toolPrompt = serializeToolsAnthropic(tools, toolChoice);
+  const fullSystem = (system || '') + toolPrompt;
+
+  // 处理 Anthropic content 数组中的 tool_use 和 tool_result
+  const processedMessages = [];
+  for (const msg of messages) {
+    if (Array.isArray(msg.content)) {
+      // Anthropic content 可能包含 tool_use / tool_result blocks
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type === 'text') {
+          parts.push(block.text);
+        } else if (block.type === 'tool_use') {
+          parts.push(`\`\`\`tool_calls\n[{"name": "${block.name}", "arguments": ${JSON.stringify(block.input || {})}}]\n\`\`\``);
+        } else if (block.type === 'tool_result') {
+          const resultContent = typeof block.content === 'string'
+            ? block.content
+            : Array.isArray(block.content)
+              ? block.content.filter(c => c.type === 'text').map(c => c.text).join('\n')
+              : JSON.stringify(block.content);
+          parts.push(`[Tool Result: ${block.tool_use_id || 'unknown'}]\n${resultContent}`);
+        }
+      }
+      processedMessages.push({ role: msg.role, content: parts.join('\n') });
+    } else {
+      processedMessages.push(msg);
+    }
+  }
+
   // 单轮
-  if (messages.length === 1 && messages[0].role === 'user') {
-    const userText = extractText(messages[0].content);
-    return system ? `${system}\n\n${userText}` : userText;
+  if (processedMessages.length === 1 && processedMessages[0].role === 'user') {
+    const userText = typeof processedMessages[0].content === 'string'
+      ? processedMessages[0].content
+      : extractText(processedMessages[0].content);
+    return fullSystem ? `${fullSystem}\n\n${userText}` : userText;
   }
 
   // 多轮
   let text = '';
-  if (system) text += `[System] ${system}\n\n`;
+  if (fullSystem) text += `[System] ${fullSystem}\n\n`;
 
-  for (const msg of messages) {
+  for (const msg of processedMessages) {
     const role = msg.role === 'assistant' ? 'Assistant' : 'User';
-    text += `[${role}] ${extractText(msg.content)}\n\n`;
+    const content = typeof msg.content === 'string' ? msg.content : extractText(msg.content);
+    text += `[${role}] ${content}\n\n`;
   }
 
   return text.trim();

openai-adapter.js

@@ -9,7 +9,8 @@
 import crypto from 'crypto';
 import { createContext, sendMessageStreaming } from './chat.js';
 import { openaiToText, resolveModel } from './message-convert.js';
-import { transformToOpenAISSE, collectFullResponse } from './stream-transform.js';
+import { transformToOpenAISSE, collectFullResponse, transformToOpenAISSEWithTools } from './stream-transform.js';
+import { parseToolCalls, toOpenAIToolCalls } from './tool-prompt.js';
 
 const MAX_RETRY = 3;
 
@@ -52,10 +53,11 @@ export async function handleChatCompletions(body, res, pool) {
     return;
   }
 
-  const text = openaiToText(body.messages);
+  const text = openaiToText(body.messages, body.tools, body.tool_choice);
   const model = resolveModel(body.model);
   const clientModel = body.model || 'gpt-4o';
   const stream = body.stream === true;
+  const hasTools = body.tools && body.tools.length > 0;
 
   if (!text) {
     sendError(res, 400, 'No valid message content found');
@@ -83,16 +85,29 @@ export async function handleChatCompletions(body, res, pool) {
         if (result.cookies) account.cookies = result.cookies;
 
         // 流获取成功 — 开始写 SSE (此后无法重试)
-        transformToOpenAISSE(result.stream, res, clientModel, requestId, (errMsg) => {
-          // streamingError 回调 — 检测额度耗尽
-          const msg = (errMsg || '').toLowerCase();
-          if (msg.includes('limit') || msg.includes('quota') || msg.includes('exhaust') || msg.includes('exceed')) {
-            pool.release(account, { quotaExhausted: true });
-          } else {
-            pool.release(account, { success: false });
-          }
-          account = null; // 标记已释放
-        });
+        if (hasTools) {
+          // 有工具定义时，需要缓冲完整响应来检测 tool_calls
+          transformToOpenAISSEWithTools(result.stream, res, clientModel, requestId, (errMsg) => {
+            const msg = (errMsg || '').toLowerCase();
+            if (msg.includes('limit') || msg.includes('quota') || msg.includes('exhaust') || msg.includes('exceed')) {
+              pool.release(account, { quotaExhausted: true });
+            } else {
+              pool.release(account, { success: false });
+            }
+            account = null;
+          });
+        } else {
+          transformToOpenAISSE(result.stream, res, clientModel, requestId, (errMsg) => {
+            // streamingError 回调 — 检测额度耗尽
+            const msg = (errMsg || '').toLowerCase();
+            if (msg.includes('limit') || msg.includes('quota') || msg.includes('exhaust') || msg.includes('exceed')) {
+              pool.release(account, { quotaExhausted: true });
+            } else {
+              pool.release(account, { success: false });
+            }
+            account = null; // 标记已释放
+          });
+        }
         result.stream.on('end', () => { if (account) pool.release(account, { success: true }); });
         result.stream.on('error', (err) => {
           if (!account) return;
@@ -142,6 +157,19 @@ export async function handleChatCompletions(body, res, pool) {
       const full = await collectFullResponse(result.stream);
       pool.release(account, { success: true });
 
+      // 检测工具调用
+      const { hasToolCalls, toolCalls, textContent } = hasTools
+        ? parseToolCalls(full.text)
+        : { hasToolCalls: false, toolCalls: [], textContent: full.text };
+
+      const message = { role: 'assistant' };
+      if (hasToolCalls) {
+        message.content = textContent || null;
+        message.tool_calls = toOpenAIToolCalls(toolCalls);
+      } else {
+        message.content = full.text;
+      }
+
       res.writeHead(200, {
         'Content-Type': 'application/json',
         'Access-Control-Allow-Origin': '*',
@@ -153,8 +181,8 @@ export async function handleChatCompletions(body, res, pool) {
         model: clientModel,
         choices: [{
           index: 0,
-          message: { role: 'assistant', content: full.text },
-          finish_reason: 'stop',
+          message,
+          finish_reason: hasToolCalls ? 'tool_calls' : 'stop',
         }],
         usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
       }));

pool.js

@@ -301,11 +301,13 @@ export class AccountPool {
 
   /**
    * 批量并行注册多个账号
+   * @param {number} count
+   * @param {string} [provider] - 可选邮箱 provider 覆盖
    */
-  async _registerBatch(count) {
+  async _registerBatch(count, provider) {
     const tasks = [];
     for (let i = 0; i < count; i++) {
-      tasks.push(this._registerNew());
+      tasks.push(this._registerNew(provider));
       // 每个注册之间间隔一小段避免邮箱服务压力
       if (i < count - 1) await sleep(500);
     }
@@ -317,30 +319,35 @@ export class AccountPool {
 
   /**
    * 手动触发注册 (供 Dashboard 调用)
+   * @param {number} count
+   * @param {string} [provider] - 可选邮箱 provider 覆盖
+   * @param {number} [concurrency] - 可选并发数覆盖
    * @returns {{ registering: number, queued: number }}
    */
-  manualRegister(count = 5) {
+  manualRegister(count = 5, provider, concurrency) {
     count = Math.min(Math.max(1, count), 50);
+    if (concurrency) this._maxConcurrentRegister = Math.min(Math.max(1, concurrency), 20);
     const available = this._maxConcurrentRegister - this._registeringCount;
     const actual = Math.min(count, available);
     if (actual <= 0) {
       return { registering: this._registeringCount, queued: 0 };
     }
-    this._registerBatch(actual).catch(() => {});
+    this._registerBatch(actual, provider).catch(() => {});
     return { registering: this._registeringCount + actual, queued: actual };
   }
 
   /**
    * 自动注册新账号 (支持并行)
+   * @param {string} [overrideProvider] - 可选邮箱 provider 覆盖
    */
-  async _registerNew() {
+  async _registerNew(overrideProvider) {
     if (this._registeringCount >= this._maxConcurrentRegister) return null;
     this._registeringCount++;
 
     try {
       this._addLog('开始注册新账号...');
-      // 优先用配置的 provider，如果不可用则降级到 mailtm
-      let providerName = config.mailProvider === 'manual' ? 'mailtm' : config.mailProvider;
+      // 优先用 overrideProvider，否则用配置的 provider，如果不可用则降级到 mailtm
+      let providerName = overrideProvider || (config.mailProvider === 'manual' ? 'mailtm' : config.mailProvider);
       let providerOpts = config[providerName] || {};
       // 检查 provider 是否配置完整
       if (providerName === 'moemail' && !providerOpts.apiUrl) providerName = 'mailtm';

server.js

@@ -117,8 +117,10 @@ const server = http.createServer(async (req, res) => {
     try {
       const body = await parseBody(req);
       const count = Math.min(Math.max(1, body.count || 5), 50);
-      const result = pool.manualRegister(count);
-      sendJson(res, 200, { ok: true, message: `\u5DF2\u63D0\u4EA4 ${result.queued} \u4E2A\u6CE8\u518C\u4EFB\u52A1`, ...result });
+      const provider = body.provider || undefined;
+      const concurrency = body.concurrency ? Math.min(Math.max(1, body.concurrency), 20) : undefined;
+      const result = pool.manualRegister(count, provider, concurrency);
+      sendJson(res, 200, { ok: true, message: `已提交 ${result.queued} 个注册任务`, ...result });
     } catch (e) {
       sendJson(res, 200, { ok: false, message: e.message });
     }

stream-transform.js

@@ -6,6 +6,8 @@
  *   {"type":"finalResult","data":{"mainText":"...","questions":[...]}}
  */
 
+import { parseToolCalls, toOpenAIToolCalls, toAnthropicToolUse, detectToolCallStart } from './tool-prompt.js';
+
 /**
  * JSON 对象流解析器 — 通过花括号计数提取完整 JSON 对象
  * chataibot 返回的不是 NDJSON（无换行），而是紧凑的 JSON 对象序列
@@ -242,6 +244,292 @@ export function transformToAnthropicSSE(upstreamStream, res, model, requestId, o
   });
 }
 
+/**
+ * chataibot → OpenAI SSE (带工具调用检测)
+ *
+ * 策略: 先正常流式输出文本。当检测到 ```tool_calls 开头时，
+ * 停止流式文本输出，缓冲剩余内容。流结束后解析完整文本，
+ * 如果包含工具调用则发送 tool_calls chunk，否则补发剩余文本。
+ */
+export function transformToOpenAISSEWithTools(upstreamStream, res, model, requestId, onStreamError) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'Access-Control-Allow-Origin': '*',
+  });
+
+  const ts = Math.floor(Date.now() / 1000);
+  let fullText = '';
+  let toolCallDetected = false;
+  let streamError = false;
+
+  function writeChunk(delta, finishReason = null) {
+    const obj = {
+      id: requestId,
+      object: 'chat.completion.chunk',
+      created: ts,
+      model,
+      choices: [{ index: 0, delta, finish_reason: finishReason }],
+    };
+    res.write(`data: ${JSON.stringify(obj)}\n\n`);
+  }
+
+  writeChunk({ role: 'assistant', content: '' });
+
+  const parser = createJsonStreamParser((obj) => {
+    switch (obj.type) {
+      case 'chunk':
+        fullText += obj.data;
+        if (!toolCallDetected) {
+          if (detectToolCallStart(fullText)) {
+            toolCallDetected = true;
+            // 不再流式输出后续 chunk
+          } else {
+            writeChunk({ content: obj.data });
+          }
+        }
+        break;
+
+      case 'reasoningContent':
+        if (!toolCallDetected) {
+          writeChunk({ reasoning_content: obj.data });
+        }
+        break;
+
+      case 'finalResult':
+        if (obj.data?.mainText) fullText = obj.data.mainText;
+        // 最终处理在 end 事件中
+        break;
+
+      case 'streamingError':
+        streamError = true;
+        if (onStreamError) onStreamError(obj.data);
+        break;
+    }
+  });
+
+  upstreamStream.on('data', (chunk) => parser.feed(chunk));
+  upstreamStream.on('end', () => {
+    parser.flush();
+    if (res.writableEnded) return;
+
+    if (streamError) {
+      writeChunk({}, 'stop');
+      res.write('data: [DONE]\n\n');
+      res.end();
+      return;
+    }
+
+    // 解析完整文本中的 tool calls
+    const { hasToolCalls, toolCalls, textContent } = parseToolCalls(fullText);
+
+    if (hasToolCalls) {
+      // 如果之前已经流式输出了部分文本 (tool_calls 标记之前的文本)
+      // 而解析后 textContent 为空或很少，无需额外处理
+
+      // 发送 tool_calls
+      const openaiToolCalls = toOpenAIToolCalls(toolCalls);
+      for (let i = 0; i < openaiToolCalls.length; i++) {
+        const tc = openaiToolCalls[i];
+        // 首个 chunk: 含 tool call id, type, function.name, function.arguments 开始部分
+        writeChunk({
+          tool_calls: [{
+            index: i,
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.function.name, arguments: tc.function.arguments },
+          }],
+        });
+      }
+      writeChunk({}, 'tool_calls');
+    } else {
+      // 没有工具调用 — 如果之前因检测到 ```tool_calls 停了输出
+      // 需要补发被缓冲的文本
+      if (toolCallDetected) {
+        // 找到之前已输出的部分，补发剩余
+        const markerIdx = fullText.indexOf('```tool_calls');
+        if (markerIdx >= 0) {
+          writeChunk({ content: fullText.substring(markerIdx) });
+        }
+      }
+      writeChunk({}, 'stop');
+    }
+
+    res.write('data: [DONE]\n\n');
+    res.end();
+  });
+
+  upstreamStream.on('error', () => {
+    if (!res.writableEnded) {
+      res.write('data: [DONE]\n\n');
+      res.end();
+    }
+  });
+}
+
+/**
+ * chataibot → Anthropic SSE (带工具调用检测)
+ *
+ * 同 OpenAI 版本，先流式输出文本，检测到工具调用后缓冲，
+ * 最终解析并发送 tool_use content blocks。
+ */
+export function transformToAnthropicSSEWithTools(upstreamStream, res, model, requestId, onStreamError) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'Access-Control-Allow-Origin': '*',
+  });
+
+  function writeEvent(event, data) {
+    res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  }
+
+  let headerSent = false;
+  let textBlockIndex = 0;
+  let fullText = '';
+  let toolCallDetected = false;
+  let streamError = false;
+
+  function ensureHeader() {
+    if (headerSent) return;
+    headerSent = true;
+    writeEvent('message_start', {
+      type: 'message_start',
+      message: {
+        id: requestId,
+        type: 'message',
+        role: 'assistant',
+        model,
+        content: [],
+        stop_reason: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+      },
+    });
+    writeEvent('content_block_start', {
+      type: 'content_block_start',
+      index: textBlockIndex,
+      content_block: { type: 'text', text: '' },
+    });
+  }
+
+  const parser = createJsonStreamParser((obj) => {
+    switch (obj.type) {
+      case 'chunk':
+        fullText += obj.data;
+        if (!toolCallDetected) {
+          if (detectToolCallStart(fullText)) {
+            toolCallDetected = true;
+          } else {
+            ensureHeader();
+            writeEvent('content_block_delta', {
+              type: 'content_block_delta',
+              index: textBlockIndex,
+              delta: { type: 'text_delta', text: obj.data },
+            });
+          }
+        }
+        break;
+
+      case 'reasoningContent':
+        if (!toolCallDetected) {
+          ensureHeader();
+          writeEvent('content_block_delta', {
+            type: 'content_block_delta',
+            index: textBlockIndex,
+            delta: { type: 'text_delta', text: obj.data },
+          });
+        }
+        break;
+
+      case 'finalResult':
+        if (obj.data?.mainText) fullText = obj.data.mainText;
+        break;
+
+      case 'streamingError':
+        streamError = true;
+        if (onStreamError) onStreamError(obj.data);
+        break;
+    }
+  });
+
+  upstreamStream.on('data', (chunk) => parser.feed(chunk));
+  upstreamStream.on('end', () => {
+    parser.flush();
+    if (res.writableEnded) return;
+    ensureHeader();
+
+    if (streamError) {
+      writeEvent('content_block_stop', { type: 'content_block_stop', index: textBlockIndex });
+      writeEvent('message_delta', {
+        type: 'message_delta',
+        delta: { stop_reason: 'end_turn' },
+        usage: { output_tokens: 0 },
+      });
+      writeEvent('message_stop', { type: 'message_stop' });
+      res.end();
+      return;
+    }
+
+    const { hasToolCalls, toolCalls, textContent } = parseToolCalls(fullText);
+
+    if (hasToolCalls) {
+      // 关闭文本 block
+      writeEvent('content_block_stop', { type: 'content_block_stop', index: textBlockIndex });
+
+      // 发送 tool_use blocks
+      const toolUseBlocks = toAnthropicToolUse(toolCalls);
+      for (let i = 0; i < toolUseBlocks.length; i++) {
+        const blockIdx = textBlockIndex + 1 + i;
+        const tu = toolUseBlocks[i];
+        writeEvent('content_block_start', {
+          type: 'content_block_start',
+          index: blockIdx,
+          content_block: { type: 'tool_use', id: tu.id, name: tu.name, input: {} },
+        });
+        writeEvent('content_block_delta', {
+          type: 'content_block_delta',
+          index: blockIdx,
+          delta: { type: 'input_json_delta', partial_json: JSON.stringify(tu.input) },
+        });
+        writeEvent('content_block_stop', { type: 'content_block_stop', index: blockIdx });
+      }
+
+      writeEvent('message_delta', {
+        type: 'message_delta',
+        delta: { stop_reason: 'tool_use' },
+        usage: { output_tokens: 0 },
+      });
+    } else {
+      // 没有工具调用 — 补发被缓冲的文本
+      if (toolCallDetected) {
+        const markerIdx = fullText.indexOf('```tool_calls');
+        if (markerIdx >= 0) {
+          writeEvent('content_block_delta', {
+            type: 'content_block_delta',
+            index: textBlockIndex,
+            delta: { type: 'text_delta', text: fullText.substring(markerIdx) },
+          });
+        }
+      }
+      writeEvent('content_block_stop', { type: 'content_block_stop', index: textBlockIndex });
+      writeEvent('message_delta', {
+        type: 'message_delta',
+        delta: { stop_reason: 'end_turn' },
+        usage: { output_tokens: 0 },
+      });
+    }
+
+    writeEvent('message_stop', { type: 'message_stop' });
+    res.end();
+  });
+
+  upstreamStream.on('error', () => {
+    if (!res.writableEnded) res.end();
+  });
+}
+
 /**
  * 消费 NDJSON 流，收集完整响应 (用于非流式请求)
  */

tool-prompt.js

@@ -0,0 +1,239 @@
+/**
+ * tool-prompt.js - 工具调用提示词注入 & 响应解析
+ *
+ * 由于 chataibot.pro 不原生支持 function calling / tool use，
+ * 我们通过提示词注入实现：
+ *   1. 将 tools 定义序列化到 system prompt
+ *   2. 指示模型在需要调用工具时输出特定 JSON 格式
+ *   3. 从模型响应中解析 JSON 工具调用
+ *   4. 转换回 OpenAI tool_calls / Anthropic tool_use 标准格式
+ */
+
+/**
+ * 将 JSON Schema 参数描述转为简洁可读的文本
+ */
+function describeParams(schema) {
+  if (!schema || !schema.properties) return '  (no parameters)';
+  const required = new Set(schema.required || []);
+  const lines = [];
+  for (const [name, prop] of Object.entries(schema.properties)) {
+    const req = required.has(name) ? ' (required)' : ' (optional)';
+    const type = prop.type || 'any';
+    const desc = prop.description ? ` - ${prop.description}` : '';
+    const enumStr = prop.enum ? ` [enum: ${prop.enum.join(', ')}]` : '';
+    lines.push(`  - ${name}: ${type}${req}${desc}${enumStr}`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * 将 OpenAI 格式 tools 数组序列化为注入 prompt
+ * @param {Array} tools - OpenAI tools array [{ type: 'function', function: { name, description, parameters } }]
+ * @param {string} [toolChoice] - 'auto' | 'none' | 'required' | { type: 'function', function: { name } }
+ * @returns {string} 注入到 system prompt 的文本
+ */
+export function serializeTools(tools, toolChoice) {
+  if (!tools || tools.length === 0) return '';
+
+  // tool_choice=none 时不注入工具
+  if (toolChoice === 'none') return '';
+
+  // 取第一个工具生成示例
+  const exampleTool = tools[0]?.function || tools[0] || { name: 'example_func' };
+  const exampleArgs = {};
+  const exampleParams = (exampleTool.parameters || {}).properties || {};
+  for (const [k, v] of Object.entries(exampleParams)) {
+    if (v.type === 'number' || v.type === 'integer') exampleArgs[k] = 0;
+    else if (v.type === 'boolean') exampleArgs[k] = true;
+    else if (v.type === 'array') exampleArgs[k] = [];
+    else if (v.type === 'object') exampleArgs[k] = {};
+    else exampleArgs[k] = 'value';
+    if (Object.keys(exampleArgs).length >= 2) break; // 示例最多2个参数
+  }
+
+  let prompt = `\n\n---\nYou have access to the following tools/functions. When you need to call a tool, you MUST respond ONLY with a JSON block wrapped in \`\`\`tool_calls\`\`\` markers.
+
+FORMAT (follow this EXACTLY):
+\`\`\`tool_calls
+[{"name": "${exampleTool.name}", "arguments": ${JSON.stringify(exampleArgs)}}]
+\`\`\`
+
+CRITICAL RULES:
+1. The response must contain ONLY the \`\`\`tool_calls\`\`\` block when calling tools — no explanation, no extra text before or after.
+2. "arguments" must be a valid JSON object matching the function's parameter schema.
+3. The JSON array can contain one or multiple tool calls: [{"name": "func1", "arguments": {...}}, {"name": "func2", "arguments": {...}}]
+4. If you do NOT need to call any tool, respond normally with plain text (no \`\`\`tool_calls\`\`\` block).
+
+Available tools:\n`;
+
+  for (const tool of tools) {
+    const fn = tool.function || tool;
+    prompt += `\n### ${fn.name}\n`;
+    if (fn.description) prompt += `${fn.description}\n`;
+    prompt += `Parameters:\n${describeParams(fn.parameters)}\n`;
+  }
+
+  // tool_choice 处理
+  if (toolChoice === 'required') {
+    prompt += `\nIMPORTANT: You MUST call at least one tool. Always respond with a tool_calls block.\n`;
+  } else if (typeof toolChoice === 'object' && toolChoice?.function?.name) {
+    prompt += `\nIMPORTANT: You MUST call the tool "${toolChoice.function.name}". Always respond with a tool_calls block containing this tool.\n`;
+  }
+
+  prompt += '---\n';
+  return prompt;
+}
+
+/**
+ * 将 Anthropic 格式 tools 转为通用格式再序列化
+ * @param {Array} tools - Anthropic tools [{ name, description, input_schema }]
+ * @param {object} [toolChoice] - { type: 'auto'|'any'|'tool', name? }
+ */
+export function serializeToolsAnthropic(tools, toolChoice) {
+  if (!tools || tools.length === 0) return '';
+
+  // 转为 OpenAI 格式
+  const openaiTools = tools.map(t => ({
+    type: 'function',
+    function: {
+      name: t.name,
+      description: t.description || '',
+      parameters: t.input_schema || {},
+    },
+  }));
+
+  // 映射 toolChoice
+  let choice = 'auto';
+  if (toolChoice) {
+    if (toolChoice.type === 'any') choice = 'required';
+    else if (toolChoice.type === 'tool') choice = { function: { name: toolChoice.name } };
+    else if (toolChoice.type === 'auto') choice = 'auto';
+  }
+
+  return serializeTools(openaiTools, choice);
+}
+
+/**
+ * 从模型的文本响应中解析工具调用
+ * @param {string} text - 模型完整回复
+ * @returns {{ hasToolCalls: boolean, toolCalls: Array, textContent: string }}
+ *
+ * toolCalls: [{ name: string, arguments: object }]
+ * textContent: 工具调用之��的文本部分 (通常为空)
+ */
+export function parseToolCalls(text) {
+  if (!text) return { hasToolCalls: false, toolCalls: [], textContent: text || '' };
+
+  // 匹配 ```tool_calls ... ``` 代码块
+  const blockRegex = /```tool_calls\s*\n?([\s\S]*?)```/;
+  const match = text.match(blockRegex);
+
+  if (match) {
+    try {
+      let parsed = JSON.parse(match[1].trim());
+      // 支持单个对象或数组
+      if (!Array.isArray(parsed)) parsed = [parsed];
+
+      const toolCalls = parsed
+        .filter(tc => tc && tc.name)
+        .map(tc => ({
+          name: tc.name,
+          arguments: tc.arguments || {},
+        }));
+
+      if (toolCalls.length > 0) {
+        // 去掉 tool_calls 块后的剩余文本
+        const textContent = text.replace(blockRegex, '').trim();
+        return { hasToolCalls: true, toolCalls, textContent };
+      }
+    } catch {}
+  }
+
+  // 备用: 匹配不带 tool_calls 标签的 JSON 块 (有些模型不严格遵循格式)
+  const jsonBlockRegex = /```(?:json)?\s*\n?(\[\s*\{[\s\S]*?"name"[\s\S]*?\}\s*\])\s*```/;
+  const jsonMatch = text.match(jsonBlockRegex);
+
+  if (jsonMatch) {
+    const result = tryParseToolArray(jsonMatch[1], text, jsonBlockRegex);
+    if (result) return result;
+  }
+
+  // 备用2: 裸 JSON 对象 (无代码块包裹) — 一些小模型会直接输出 JSON
+  // 只在文本末尾检测，避免误匹配正文中的 JSON
+  const tailText = text.slice(-2000); // 只看最后 2000 字符
+  const nakedJsonRegex = /(\[\s*\{\s*"name"\s*:\s*"[^"]+"\s*,\s*"arguments"\s*:[\s\S]*?\}\s*\])\s*$/;
+  const nakedMatch = tailText.match(nakedJsonRegex);
+
+  if (nakedMatch) {
+    const result = tryParseToolArray(nakedMatch[1], text, new RegExp(nakedMatch[1].replace(/[.*+?^${}()|[\]\\]/g, '\\$&').slice(0, 100) + '[\\s\\S]*'));
+    if (result) return result;
+  }
+
+  return { hasToolCalls: false, toolCalls: [], textContent: text };
+}
+
+/**
+ * 尝试解析 JSON 数组为 tool calls
+ */
+function tryParseToolArray(jsonStr, fullText, removeRegex) {
+  try {
+    let parsed = JSON.parse(jsonStr.trim());
+    if (!Array.isArray(parsed)) parsed = [parsed];
+    const toolCalls = parsed
+      .filter(tc => tc && tc.name)
+      .map(tc => ({
+        name: tc.name,
+        arguments: tc.arguments || {},
+      }));
+    if (toolCalls.length > 0) {
+      const textContent = fullText.replace(removeRegex, '').trim();
+      return { hasToolCalls: true, toolCalls, textContent };
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * 将解析到的 toolCalls 转为 OpenAI 格式的 tool_calls 数组
+ */
+export function toOpenAIToolCalls(toolCalls) {
+  return toolCalls.map((tc, i) => ({
+    id: `call_${Date.now().toString(36)}_${i}`,
+    type: 'function',
+    function: {
+      name: tc.name,
+      arguments: typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments),
+    },
+  }));
+}
+
+/**
+ * 将解析到的 toolCalls 转为 Anthropic 格式的 tool_use content blocks
+ */
+export function toAnthropicToolUse(toolCalls) {
+  return toolCalls.map((tc, i) => ({
+    type: 'tool_use',
+    id: `toolu_${Date.now().toString(36)}_${i}`,
+    name: tc.name,
+    input: typeof tc.arguments === 'string' ? JSON.parse(tc.arguments) : tc.arguments,
+  }));
+}
+
+/**
+ * 检测流式文本中是否开始了 tool_calls 块
+ * 用于流式模式下判断何时需要缓冲而非直接输出
+ */
+export function detectToolCallStart(accumulatedText) {
+  // 检测是否出现了 ```tool_calls 的开头
+  return accumulatedText.includes('```tool_calls');
+}
+
+/**
+ * 检测 tool_calls 块是否完整 (闭合的 ``` 标记)
+ */
+export function detectToolCallEnd(accumulatedText) {
+  const start = accumulatedText.indexOf('```tool_calls');
+  if (start < 0) return false;
+  const afterStart = accumulatedText.substring(start + '```tool_calls'.length);
+  return afterStart.includes('```');
+}

ui.js

@@ -97,9 +97,12 @@ tr:hover td { background: #fafbfc; }
 .empty { text-align: center; padding: 40px; color: var(--text-sec); font-size: .9rem; }
 
 /* Register bar */
-.reg-bar { display: flex; align-items: center; gap: 10px; }
+.reg-bar { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
+.reg-label { font-size: .82rem; font-weight: 400; color: var(--text-sec); }
 .reg-input { width: 60px; padding: 5px 10px; border: 1px solid var(--border); border-radius: 6px; font-size: .85rem; text-align: center; outline: none; }
 .reg-input:focus { border-color: var(--c-inuse); }
+.reg-select { padding: 5px 10px; border: 1px solid var(--border); border-radius: 6px; font-size: .82rem; outline: none; background: var(--bg-card); color: var(--text); cursor: pointer; max-width: 140px; }
+.reg-select:focus { border-color: var(--c-inuse); }
 .btn { padding: 6px 16px; border: none; border-radius: 6px; font-size: .82rem; font-weight: 500; cursor: pointer; transition: background .15s, opacity .15s; }
 .btn-primary { background: var(--c-inuse); color: #fff; }
 .btn-primary:hover { background: #2563eb; }
@@ -163,8 +166,24 @@ tr:hover td { background: #fafbfc; }
     <div class="section-head">
       <span>\u8D26\u53F7\u7BA1\u7406</span>
       <div class="reg-bar">
-        <span style="font-size:.82rem;font-weight:400;color:var(--text-sec)">\u6CE8\u518C\u6570\u91CF</span>
+        <span class="reg-label">\u90AE\u7BB1</span>
+        <select class="reg-select" id="regProvider">
+          <option value="">auto (\u914D\u7F6E\u9ED8\u8BA4)</option>
+          <option value="mailtm">Mail.tm</option>
+          <option value="guerrilla">Guerrilla</option>
+          <option value="tempmail">TempMail</option>
+          <option value="tempmailio">TempMail.io</option>
+          <option value="dropmail">Dropmail</option>
+          <option value="linshiyou">linshiyou</option>
+          <option value="gptmail">GPTMail</option>
+          <option value="moemail">MoeMail</option>
+          <option value="duckmail">DuckMail</option>
+          <option value="catchall">CatchAll</option>
+        </select>
+        <span class="reg-label">\u6570\u91CF</span>
         <input type="number" class="reg-input" id="regCount" value="5" min="1" max="50">
+        <span class="reg-label">\u5E76\u53D1</span>
+        <input type="number" class="reg-input" id="regConcurrency" value="5" min="1" max="10">
         <button class="btn btn-primary" id="regBtn" onclick="doRegister()">\u624B\u52A8\u6CE8\u518C</button>
         <span class="reg-msg" id="regMsg"></span>
       </div>
@@ -372,15 +391,19 @@ async function doRegister() {
   var btn = document.getElementById("regBtn");
   var msg = document.getElementById("regMsg");
   var count = parseInt(document.getElementById("regCount").value) || 5;
+  var provider = document.getElementById("regProvider").value || undefined;
+  var concurrency = parseInt(document.getElementById("regConcurrency").value) || 5;
   btn.disabled = true;
   btn.textContent = "\u6CE8\u518C\u4E2D...";
   msg.className = "reg-msg";
   msg.textContent = "";
   try {
+    var payload = { count: count, concurrency: concurrency };
+    if (provider) payload.provider = provider;
     var r = await fetch("/pool/register", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ count: count })
+      body: JSON.stringify(payload)
     }).then(function(r){ return r.json() });
     msg.className = "reg-msg " + (r.ok ? "ok" : "err");
     msg.textContent = r.message;