Reapply "添加指纹请求器，使用useNativeFetch: false启用，并且添加回退机制"

config.json

@@ -19,5 +19,6 @@
     "maxRequestSize": "50mb",
     "apiKey": "sk-text"
   },
+  "useNativeFetch": false,
   "systemInstruction": "你是聊天机器人，名字叫萌萌，如同名字这般，你的性格是软软糯糯萌萌哒的，专门为用户提供聊天和情绪价值，协助进行小说创作或者角色扮演"
 }

src/AntigravityRequester.js

@@ -0,0 +1,282 @@
+import { spawn } from 'child_process';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+class antigravityRequester {
+    constructor(options = {}) {
+        this.binPath = options.binPath;
+        this.executablePath = options.executablePath || this._getExecutablePath();
+        this.proc = null;
+        this.requestId = 0;
+        this.pendingRequests = new Map();
+        this.buffer = '';
+        this.writeQueue = Promise.resolve();
+    }
+
+    _getExecutablePath() {
+        const platform = os.platform();
+        const arch = os.arch();
+        
+        let filename;
+        if (platform === 'win32' && arch === 'x64') {
+            filename = 'antigravity_requester_windows_amd64.exe';
+        } else if (platform === 'android' && arch === 'arm64') {
+            filename = 'antigravity_requester_android_arm64';
+        } else if (platform === 'linux' && arch === 'x64') {
+            filename = 'antigravity_requester_linux_amd64';
+        } else {
+            throw new Error(`Unsupported platform/architecture: ${platform}/${arch}. Only supports: windows/x64, android/arm64, linux/x64`);
+        }
+        
+        const binPath = this.binPath || path.join(__dirname, 'bin');
+        const requester_execPath = path.join(binPath, filename);
+        // 设置执行权限（非Windows平台）
+        if (platform !== 'win32') {
+            try {
+                fs.chmodSync(requester_execPath, 0o755);
+            } catch (error) {
+                console.warn(`Could not set executable permissions: ${error.message}`);
+            }
+        }
+        return requester_execPath;
+    }
+
+    _ensureProcess() {
+        if (this.proc) return;
+
+        this.proc = spawn(this.executablePath, [], {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        // 设置 stdin 为非阻塞模式
+        if (this.proc.stdin.setDefaultEncoding) {
+            this.proc.stdin.setDefaultEncoding('utf8');
+        }
+
+        this.proc.stdout.on('data', (data) => {
+            this.buffer += data.toString();
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop();
+
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                try {
+                    const response = JSON.parse(line);
+                    const pending = this.pendingRequests.get(response.id);
+                    if (!pending) continue;
+
+                    if (pending.streamResponse) {
+                        pending.streamResponse._handleChunk(response);
+                        if (response.type === 'end' || response.type === 'error') {
+                            this.pendingRequests.delete(response.id);
+                        }
+                    } else {
+                        this.pendingRequests.delete(response.id);
+                        if (response.ok) {
+                            pending.resolve(new antigravityResponse(response));
+                        } else {
+                            pending.reject(new Error(response.error || 'Request failed'));
+                        }
+                    }
+                } catch (e) {
+                    console.error('Failed to parse response:', e);
+                }
+            }
+        });
+
+        this.proc.stderr.on('data', (data) => {
+            console.error('antigravityRequester stderr:', data.toString());
+        });
+
+        this.proc.on('close', () => {
+            this.proc = null;
+            for (const [id, pending] of this.pendingRequests) {
+                if (pending.reject) {
+                    pending.reject(new Error('Process closed'));
+                } else if (pending.streamResponse && pending.streamResponse._onError) {
+                    pending.streamResponse._onError(new Error('Process closed'));
+                }
+            }
+            this.pendingRequests.clear();
+        });
+    }
+
+    async antigravity_fetch(url, options = {}) {
+        this._ensureProcess();
+
+        const id = `req-${++this.requestId}`;
+        const request = {
+            id,
+            url,
+            method: options.method || 'GET',
+            headers: options.headers,
+            body: options.body,
+            timeout_ms: options.timeout || 30000,
+            proxy: options.proxy,
+            response_format: 'text',
+            ...options
+        };
+
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve, reject });
+            this._writeRequest(request);
+        });
+    }
+
+    antigravity_fetchStream(url, options = {}) {
+        this._ensureProcess();
+
+        const id = `req-${++this.requestId}`;
+        const request = {
+            id,
+            url,
+            method: options.method || 'GET',
+            headers: options.headers,
+            body: options.body,
+            timeout_ms: options.timeout || 30000,
+            proxy: options.proxy,
+            stream: true,
+            ...options
+        };
+
+        const streamResponse = new StreamResponse(id);
+        this.pendingRequests.set(id, { streamResponse });
+        this._writeRequest(request);
+        
+        return streamResponse;
+    }
+
+    _writeRequest(request) {
+        this.writeQueue = this.writeQueue.then(() => {
+            return new Promise((resolve, reject) => {
+                const data = JSON.stringify(request) + '\n';
+                const canWrite = this.proc.stdin.write(data);
+                if (canWrite) {
+                    resolve();
+                } else {
+                    // 等待 drain 事件
+                    this.proc.stdin.once('drain', resolve);
+                    this.proc.stdin.once('error', reject);
+                }
+            });
+        }).catch(err => {
+            console.error('Write request failed:', err);
+        });
+    }
+
+    close() {
+        if (this.proc) {
+            this.proc.stdin.end();
+            this.proc = null;
+        }
+    }
+}
+
+class StreamResponse {
+    constructor(id) {
+        this.id = id;
+        this.status = null;
+        this.statusText = null;
+        this.headers = null;
+        this.chunks = [];
+        this._onStart = null;
+        this._onData = null;
+        this._onEnd = null;
+        this._onError = null;
+        this._ended = false;
+        this._error = null;
+        this._textPromiseResolve = null;
+        this._textPromiseReject = null;
+    }
+
+    _handleChunk(chunk) {
+        if (chunk.type === 'start') {
+            this.status = chunk.status;
+            this.headers = new Map(Object.entries(chunk.headers || {}));
+            if (this._onStart) this._onStart({ status: chunk.status, headers: this.headers });
+        } else if (chunk.type === 'data') {
+            const data = chunk.encoding === 'base64' 
+                ? Buffer.from(chunk.data, 'base64').toString('utf8')
+                : chunk.data;
+            this.chunks.push(data);
+            if (this._onData) this._onData(data);
+        } else if (chunk.type === 'end') {
+            this._ended = true;
+            if (this._textPromiseResolve) this._textPromiseResolve(this.chunks.join(''));
+            if (this._onEnd) this._onEnd();
+        } else if (chunk.type === 'error') {
+            this._ended = true;
+            this._error = new Error(chunk.error);
+            if (this._textPromiseReject) this._textPromiseReject(this._error);
+            if (this._onError) this._onError(this._error);
+        }
+    }
+
+    onStart(callback) {
+        this._onStart = callback;
+        return this;
+    }
+
+    onData(callback) {
+        this._onData = callback;
+        return this;
+    }
+
+    onEnd(callback) {
+        this._onEnd = callback;
+        return this;
+    }
+
+    onError(callback) {
+        this._onError = callback;
+        return this;
+    }
+
+    async text() {
+        if (this._ended) {
+            if (this._error) throw this._error;
+            return this.chunks.join('');
+        }
+        return new Promise((resolve, reject) => {
+            this._textPromiseResolve = resolve;
+            this._textPromiseReject = reject;
+        });
+    }
+}
+
+class antigravityResponse {
+    constructor(response) {
+        this._response = response;
+        this.ok = response.ok;
+        this.status = response.status;
+        this.statusText = response.status_text;
+        this.url = response.url;
+        this.headers = new Map(Object.entries(response.headers || {}));
+        this.redirected = response.redirected;
+    }
+
+    async text() {
+        if (this._response.body_encoding === 'base64') {
+            return Buffer.from(this._response.body, 'base64').toString('utf8');
+        }
+        return this._response.body;
+    }
+
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+
+    async buffer() {
+        if (this._response.body_encoding === 'base64') {
+            return Buffer.from(this._response.body, 'base64');
+        }
+        return Buffer.from(this._response.body, 'utf8');
+    }
+}
+
+export default antigravityRequester;

src/api/client.js

@@ -1,6 +1,21 @@
 import tokenManager from '../auth/token_manager.js';
 import config from '../config/config.js';
 import { generateToolCallId } from '../utils/idGenerator.js';
+import AntigravityRequester from '../AntigravityRequester.js';
+
+let requester = null;
+let useNativeFetch = false;
+
+if (config.useNativeFetch !== true) {
+  try {
+    requester = new AntigravityRequester();
+  } catch (error) {
+    console.warn('AntigravityRequester initialization failed, falling back to native fetch:', error.message);
+    useNativeFetch = true;
+  }
+} else {
+  useNativeFetch = true;
+}
 
 export async function generateAssistantResponse(requestBody, callback) {
   const token = await tokenManager.getToken();
@@ -10,8 +25,114 @@ export async function generateAssistantResponse(requestBody, callback) {
   }
   
   const url = config.api.url;
+  const headers = {
+    'Host': config.api.host,
+    'User-Agent': config.api.userAgent,
+    'Authorization': `Bearer ${token.access_token}`,
+    'Content-Type': 'application/json',
+    'Accept-Encoding': 'gzip'
+  };
   
-  const response = await fetch(url, {
+  if (useNativeFetch) {
+    return await generateWithNativeFetch(url, headers, requestBody, callback, token);
+  }
+  
+  const streamResponse = requester.antigravity_fetchStream(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(requestBody)
+  });
+
+  let thinkingStarted = false;
+  let toolCalls = [];
+  let buffer = '';
+  let errorBody = '';
+  let statusCode = null;
+
+  await new Promise((resolve, reject) => {
+    streamResponse
+      .onStart(({ status }) => {
+        statusCode = status;
+        if (status === 403) {
+          tokenManager.disableCurrentToken(token);
+        }
+      })
+      .onData((chunk) => {
+        if (statusCode !== 200) {
+          errorBody += chunk;
+          return;
+        }
+        
+        buffer += chunk;
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+        
+        for (const line of lines.filter(l => l.startsWith('data: '))) {
+          const jsonStr = line.slice(6);
+          try {
+            const data = JSON.parse(jsonStr);
+            const parts = data.response?.candidates?.[0]?.content?.parts;
+            if (parts) {
+              for (const part of parts) {
+                if (part.thought === true) {
+                  if (!thinkingStarted) {
+                    callback({ type: 'thinking', content: '<think>\n' });
+                    thinkingStarted = true;
+                  }
+                  callback({ type: 'thinking', content: part.text || '' });
+                } else if (part.text !== undefined) {
+                  if (thinkingStarted) {
+                    callback({ type: 'thinking', content: '\n</think>\n' });
+                    thinkingStarted = false;
+                  }
+                  callback({ type: 'text', content: part.text });
+                } else if (part.functionCall) {
+                  toolCalls.push({
+                    id: part.functionCall.id || generateToolCallId(),
+                    type: 'function',
+                    function: {
+                      name: part.functionCall.name,
+                      arguments: JSON.stringify(part.functionCall.args)
+                    }
+                  });
+                }
+              }
+            }
+            
+            if (data.response?.candidates?.[0]?.finishReason && toolCalls.length > 0) {
+              if (thinkingStarted) {
+                callback({ type: 'thinking', content: '\n</think>\n' });
+                thinkingStarted = false;
+              }
+              callback({ type: 'tool_calls', tool_calls: toolCalls });
+              toolCalls = [];
+            }
+          } catch (e) {
+            // 忽略解析错误
+          }
+        }
+      })
+      .onEnd(() => {
+        if (statusCode === 403) {
+          reject(new Error(`该账号没有使用权限，已自动禁用。错误详情: ${errorBody}`));
+        } else if (statusCode !== 200) {
+          reject(new Error(`API请求失败 (${statusCode}): ${errorBody}`));
+        } else {
+          resolve();
+        }
+      })
+      .onError(reject);
+  });
+}
+
+export async function getAvailableModels() {
+  const token = await tokenManager.getToken();
+  
+  if (!token) {
+    throw new Error('没有可用的token，请运行 npm run login 获取token');
+  }
+  
+  const response = await fetch(config.api.modelsUrl, {
     method: 'POST',
     headers: {
       'Host': config.api.host,
@@ -20,31 +141,53 @@ export async function generateAssistantResponse(requestBody, callback) {
       'Content-Type': 'application/json',
       'Accept-Encoding': 'gzip'
     },
+    body: JSON.stringify({})
+  });
+
+  const data = await response.json();
+  
+  return {
+    object: 'list',
+    data: Object.keys(data.models).map(id => ({
+      id,
+      object: 'model',
+      created: Math.floor(Date.now() / 1000),
+      owned_by: 'google'
+    }))
+  };
+}
+
+async function generateWithNativeFetch(url, headers, requestBody, callback, token) {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers,
     body: JSON.stringify(requestBody)
   });
 
+  if (response.status === 403) {
+    tokenManager.disableCurrentToken(token);
+    throw new Error('该账号没有使用权限，已自动禁用');
+  }
+
   if (!response.ok) {
-    const errorText = await response.text();
-    if (response.status === 403) {
-      tokenManager.disableCurrentToken(token);
-      throw new Error(`该账号没有使用权限，已自动禁用。错误详情: ${errorText}`);
-    }
-    throw new Error(`API请求失败 (${response.status}): ${errorText}`);
+    throw new Error(`API请求失败 (${response.status})`);
   }
 
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
   let thinkingStarted = false;
   let toolCalls = [];
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
 
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
-    
-    const chunk = decoder.decode(value);
-    const lines = chunk.split('\n').filter(line => line.startsWith('data: '));
-    
-    for (const line of lines) {
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop();
+
+    for (const line of lines.filter(l => l.startsWith('data: '))) {
       const jsonStr = line.slice(6);
       try {
         const data = JSON.parse(jsonStr);
@@ -75,8 +218,7 @@ export async function generateAssistantResponse(requestBody, callback) {
             }
           }
         }
-        
-        // 当遇到 finishReason 时，发送所有收集的工具调用
+
         if (data.response?.candidates?.[0]?.finishReason && toolCalls.length > 0) {
           if (thinkingStarted) {
             callback({ type: 'thinking', content: '\n</think>\n' });
@@ -92,34 +234,8 @@ export async function generateAssistantResponse(requestBody, callback) {
   }
 }
 
-export async function getAvailableModels() {
-  const token = await tokenManager.getToken();
-  
-  if (!token) {
-    throw new Error('没有可用的token，请运行 npm run login 获取token');
+export function closeRequester() {
+  if (requester) {
+    requester.close();
   }
-  
-  const response = await fetch(config.api.modelsUrl, {
-    method: 'POST',
-    headers: {
-      'Host': config.api.host,
-      'User-Agent': config.api.userAgent,
-      'Authorization': `Bearer ${token.access_token}`,
-      'Content-Type': 'application/json',
-      'Accept-Encoding': 'gzip'
-    },
-    body: JSON.stringify({})
-  });
-
-  const data = await response.json();
-  
-  return {
-    object: 'list',
-    data: Object.keys(data.models).map(id => ({
-      id,
-      object: 'model',
-      created: Math.floor(Date.now() / 1000),
-      owned_by: 'google'
-    }))
-  };
 }

src/bin/antigravity_requester_android_arm64

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39d953841d55d4673f77fb2a225d76bc202569a3726ed476a7daaa218e3d4bd6
+size 8192353

src/bin/antigravity_requester_linux_amd64

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f362ec3859dc5d189f67de7d7426ab88e9c84819697dca2e3e7ac3d6b1a0846
+size 7930040

src/bin/antigravity_requester_windows_amd64.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a755b4a7cb2bdadd278c5701c13e3d9bcd03d0051df66f6b5a4745e81f229a77
+size 8096768

src/config/config.js

@@ -11,6 +11,7 @@ const defaultConfig = {
   },
   defaults: { temperature: 1, top_p: 0.85, top_k: 50, max_tokens: 8096 },
   security: { maxRequestSize: '50mb', apiKey: null },
+  useNativeFetch: false,
   systemInstruction: '你是聊天机器人，专门为用户提供聊天和情绪价值，协助进行小说创作或者角色扮演，也可以提供数学或者代码上的建议'
 };
 

src/server/index.js

@@ -1,5 +1,5 @@
 import express from 'express';
-import { generateAssistantResponse, getAvailableModels } from '../api/client.js';
+import { generateAssistantResponse, getAvailableModels, closeRequester } from '../api/client.js';
 import { generateRequestBody } from '../utils/utils.js';
 import logger from '../utils/logger.js';
 import config from '../config/config.js';
@@ -177,6 +177,7 @@ server.on('error', (error) => {
 
 const shutdown = () => {
   logger.info('正在关闭服务器...');
+  closeRequester();
   server.close(() => {
     logger.info('服务器已关闭');
     process.exit(0);