feat: 思维链/工具签名缓存、适配更多工具调用格式

修改文件：
- src/api/client.js：流式/非流式响应透传 thoughtSignature，写入全局缓存供后续请求复用
- src/utils/utils.js：历史 assistant 消息补充思考块+签名块，支持 Claude/Gemini 不同签名，工具名 sanitize
- src/server/index.js：流式响应中透传 reasoning_content 和 thoughtSignature

新增文件：
- src/utils/thoughtSignatureCache.js：按 sessionId + model 维度缓存思维链签名和工具签名
- src/utils/toolNameCache.js：工具名映射缓存，sanitize 后可还原原始工具名

src/api/client.js

@@ -7,6 +7,8 @@ import { saveBase64Image } from '../utils/imageStorage.js';
 import logger from '../utils/logger.js';
 import memoryManager, { MemoryPressure, registerMemoryPoolCleanup } from '../utils/memoryManager.js';
 import { buildAxiosRequestConfig } from '../utils/httpClient.js';
+import { setReasoningSignature, setToolSignature } from '../utils/thoughtSignatureCache.js';
+import { getOriginalToolName } from '../utils/toolNameCache.js';
 
 // 请求客户端：优先使用 AntigravityRequester，失败则降级到 axios
 let requester = null;
@@ -234,16 +236,23 @@ async function handleApiError(error, token) {
 }
 
 // 转换 functionCall 为 OpenAI 格式（使用对象池）
-function convertToToolCall(functionCall) {
+// 会尝试将安全工具名还原为原始工具名
+function convertToToolCall(functionCall, sessionId, model) {
   const toolCall = getToolCallObject();
   toolCall.id = functionCall.id || generateToolCallId();
-  toolCall.function.name = functionCall.name;
+  let name = functionCall.name;
+  if (sessionId && model) {
+    const original = getOriginalToolName(sessionId, model, functionCall.name);
+    if (original) name = original;
+  }
+  toolCall.function.name = name;
   toolCall.function.arguments = JSON.stringify(functionCall.args);
   return toolCall;
 }
 
 // 解析并发送流式响应片段（会修改 state 并触发 callback）
 // 支持 DeepSeek 格式：思维链内容通过 reasoning_content 字段输出
+// 同时透传 thoughtSignature，方便客户端后续复用
 function parseAndEmitStreamChunk(line, state, callback) {
   if (!line.startsWith(DATA_PREFIX)) return;
   
@@ -256,13 +265,31 @@ function parseAndEmitStreamChunk(line, state, callback) {
       for (const part of parts) {
         if (part.thought === true) {
           // 思维链内容 - 使用 DeepSeek 格式的 reasoning_content
-          callback({ type: 'reasoning', reasoning_content: part.text || '' });
+          // 缓存最新的签名，方便后续片段缺省时复用，并写入全局缓存
+          if (part.thoughtSignature) {
+            state.reasoningSignature = part.thoughtSignature;
+            if (state.sessionId && state.model) {
+              setReasoningSignature(state.sessionId, state.model, part.thoughtSignature);
+            }
+          }
+          callback({
+            type: 'reasoning',
+            reasoning_content: part.text || '',
+            thoughtSignature: part.thoughtSignature || state.reasoningSignature || null
+          });
         } else if (part.text !== undefined) {
           // 普通文本内容
           callback({ type: 'text', content: part.text });
         } else if (part.functionCall) {
-          // 工具调用
-          state.toolCalls.push(convertToToolCall(part.functionCall));
+          // 工具调用，透传工具签名，并写入全局缓存
+          const toolCall = convertToToolCall(part.functionCall, state.sessionId, state.model);
+          if (part.thoughtSignature) {
+            toolCall.thoughtSignature = part.thoughtSignature;
+            if (state.sessionId && state.model) {
+              setToolSignature(state.sessionId, state.model, part.thoughtSignature);
+            }
+          }
+          state.toolCalls.push(toolCall);
         }
       }
     }
@@ -296,7 +323,13 @@ function parseAndEmitStreamChunk(line, state, callback) {
 export async function generateAssistantResponse(requestBody, token, callback) {
   
   const headers = buildHeaders(token);
-  const state = { toolCalls: [] };
+  // 在 state 中临时缓存思维链签名，供流式多片段复用，并携带 session 与 model 信息以写入全局缓存
+  const state = {
+    toolCalls: [],
+    reasoningSignature: null,
+    sessionId: requestBody.request?.sessionId,
+    model: requestBody.model
+  };
   const lineBuffer = getLineBuffer(); // 从对象池获取
   
   const processChunk = (chunk) => {
@@ -479,6 +512,7 @@ export async function generateAssistantResponseNoStream(requestBody, token) {
   const parts = data.response?.candidates?.[0]?.content?.parts || [];
   let content = '';
   let reasoningContent = '';
+  let reasoningSignature = null;
   const toolCalls = [];
   const imageUrls = [];
   
@@ -486,10 +520,17 @@ export async function generateAssistantResponseNoStream(requestBody, token) {
     if (part.thought === true) {
       // 思维链内容 - 使用 DeepSeek 格式的 reasoning_content
       reasoningContent += part.text || '';
+      if (part.thoughtSignature && !reasoningSignature) {
+        reasoningSignature = part.thoughtSignature;
+      }
     } else if (part.text !== undefined) {
       content += part.text;
     } else if (part.functionCall) {
-      toolCalls.push(convertToToolCall(part.functionCall));
+      const toolCall = convertToToolCall(part.functionCall, requestBody.request?.sessionId, requestBody.model);
+      if (part.thoughtSignature) {
+        toolCall.thoughtSignature = part.thoughtSignature;
+      }
+      toolCalls.push(toolCall);
     } else if (part.inlineData) {
       // 保存图片到本地并获取 URL
       const imageUrl = saveBase64Image(part.inlineData.data, part.inlineData.mimeType);
@@ -505,14 +546,28 @@ export async function generateAssistantResponseNoStream(requestBody, token) {
     total_tokens: usage.totalTokenCount || 0
   } : null;
   
+  // 将新的签名写入全局缓存（按 sessionId + model），供后续请求兜底使用
+  const sessionId = requestBody.request?.sessionId;
+  const model = requestBody.model;
+  if (sessionId && model) {
+    if (reasoningSignature) {
+      setReasoningSignature(sessionId, model, reasoningSignature);
+    }
+    // 工具签名：取第一个带 thoughtSignature 的工具作为缓存源
+    const toolSig = toolCalls.find(tc => tc.thoughtSignature)?.thoughtSignature;
+    if (toolSig) {
+      setToolSignature(sessionId, model, toolSig);
+    }
+  }
+
   // 生图模型：转换为 markdown 格式
   if (imageUrls.length > 0) {
     let markdown = content ? content + '\n\n' : '';
     markdown += imageUrls.map(url => `![image](${url})`).join('\n\n');
-    return { content: markdown, reasoningContent: reasoningContent || null, toolCalls, usage: usageData };
+    return { content: markdown, reasoningContent: reasoningContent || null, reasoningSignature, toolCalls, usage: usageData };
   }
   
-  return { content, reasoningContent: reasoningContent || null, toolCalls, usage: usageData };
+  return { content, reasoningContent: reasoningContent || null, reasoningSignature, toolCalls, usage: usageData };
 }
 
 export async function generateImageForSD(requestBody, token) {

src/server/index.js

@@ -107,7 +107,10 @@ const createStreamChunk = (id, created, model, delta, finish_reason = null) => {
 const writeStreamData = (res, data) => {
   const json = JSON.stringify(data);
   // 释放对象回池
-  if (data.choices) releaseChunkObject(data);
+                const delta = { reasoning_content: data.reasoning_content };
+                if (data.thoughtSignature) {
+                  delta.thoughtSignature = data.thoughtSignature;
+                }
   res.write(SSE_PREFIX);
   res.write(json);
   res.write(SSE_SUFFIX);
@@ -275,6 +278,9 @@ app.post('/v1/chat/completions', async (req, res) => {
                 usageData = data.usage;
               } else if (data.type === 'reasoning') {
                 const delta = { reasoning_content: data.reasoning_content };
+                if (data.thoughtSignature) {
+                  delta.thoughtSignature = data.thoughtSignature;
+                }
                 writeStreamData(res, createStreamChunk(id, created, model, delta));
               } else if (data.type === 'tool_calls') {
                 hasToolCall = true;
@@ -304,7 +310,7 @@ app.post('/v1/chat/completions', async (req, res) => {
       req.setTimeout(0); // 禁用请求超时
       res.setTimeout(0); // 禁用响应超时
       
-      const { content, reasoningContent, toolCalls, usage } = await with429Retry(
+      const { content, reasoningContent, reasoningSignature, toolCalls, usage } = await with429Retry(
         () => generateAssistantResponseNoStream(requestBody, token),
         safeRetries,
         'chat.no_stream '
@@ -312,6 +318,7 @@ app.post('/v1/chat/completions', async (req, res) => {
       // DeepSeek 格式：reasoning_content 在 content 之前
       const message = { role: 'assistant' };
       if (reasoningContent) message.reasoning_content = reasoningContent;
+      if (reasoningSignature) message.thoughtSignature = reasoningSignature;
       message.content = content;
       if (toolCalls.length > 0) message.tool_calls = toolCalls;
       

src/utils/thoughtSignatureCache.js

@@ -0,0 +1,108 @@
+// 简单内存缓存：按 sessionId + model 维度缓存思维链签名和工具签名
+// 同时集成内存管理器，在压力较高时自动收缩/清空缓存
+
+import memoryManager, { MemoryPressure } from './memoryManager.js';
+
+const reasoningSignatureCache = new Map();
+const toolSignatureCache = new Map();
+
+// 正常情况下允许的最大条目数（低压力时）
+const MAX_REASONING_ENTRIES = 256;
+const MAX_TOOL_ENTRIES = 256;
+
+// 过期时间与定时清理间隔（毫秒）
+const ENTRY_TTL_MS = 30 * 60 * 1000;      // 30 分钟
+const CLEAN_INTERVAL_MS = 10 * 60 * 1000; // 每 10 分钟扫一遍
+
+function makeKey(sessionId, model) {
+  return `${sessionId || ''}::${model || ''}`;
+}
+
+function pruneMap(map, targetSize) {
+  if (map.size <= targetSize) return;
+  const removeCount = map.size - targetSize;
+  let removed = 0;
+  for (const key of map.keys()) {
+    map.delete(key);
+    removed++;
+    if (removed >= removeCount) break;
+  }
+}
+
+function pruneExpired(map, now) {
+  for (const [key, entry] of map.entries()) {
+    if (!entry || typeof entry.ts !== 'number') continue;
+    if (now - entry.ts > ENTRY_TTL_MS) {
+      map.delete(key);
+    }
+  }
+}
+
+// 注册到内存管理器，在不同压力级别下自动清理缓存
+memoryManager.registerCleanup((pressure) => {
+  if (pressure === MemoryPressure.MEDIUM) {
+    // 中等压力：收缩到一半容量
+    pruneMap(reasoningSignatureCache, Math.floor(MAX_REASONING_ENTRIES / 2));
+    pruneMap(toolSignatureCache, Math.floor(MAX_TOOL_ENTRIES / 2));
+  } else if (pressure === MemoryPressure.HIGH) {
+    // 高压力：大幅收缩
+    pruneMap(reasoningSignatureCache, Math.floor(MAX_REASONING_ENTRIES / 4));
+    pruneMap(toolSignatureCache, Math.floor(MAX_TOOL_ENTRIES / 4));
+  } else if (pressure === MemoryPressure.CRITICAL) {
+    // 紧急压力：直接清空，优先保活
+    reasoningSignatureCache.clear();
+    toolSignatureCache.clear();
+  }
+});
+
+// 定时清理：不依赖压力等级，按 TTL 移除过期签名
+setInterval(() => {
+  const now = Date.now();
+  pruneExpired(reasoningSignatureCache, now);
+  pruneExpired(toolSignatureCache, now);
+}, CLEAN_INTERVAL_MS).unref?.();
+
+export function setReasoningSignature(sessionId, model, signature) {
+  if (!signature) return;
+  const key = makeKey(sessionId, model);
+  reasoningSignatureCache.set(key, { signature, ts: Date.now() });
+  // 防止在低压力下无限增长
+  pruneMap(reasoningSignatureCache, MAX_REASONING_ENTRIES);
+}
+
+export function getReasoningSignature(sessionId, model) {
+  const key = makeKey(sessionId, model);
+  const entry = reasoningSignatureCache.get(key);
+  if (!entry) return null;
+  const now = Date.now();
+  if (typeof entry.ts === 'number' && now - entry.ts > ENTRY_TTL_MS) {
+    reasoningSignatureCache.delete(key);
+    return null;
+  }
+  return entry.signature || null;
+}
+
+export function setToolSignature(sessionId, model, signature) {
+  if (!signature) return;
+  const key = makeKey(sessionId, model);
+  toolSignatureCache.set(key, { signature, ts: Date.now() });
+  pruneMap(toolSignatureCache, MAX_TOOL_ENTRIES);
+}
+
+export function getToolSignature(sessionId, model) {
+  const key = makeKey(sessionId, model);
+  const entry = toolSignatureCache.get(key);
+  if (!entry) return null;
+  const now = Date.now();
+  if (typeof entry.ts === 'number' && now - entry.ts > ENTRY_TTL_MS) {
+    toolSignatureCache.delete(key);
+    return null;
+  }
+  return entry.signature || null;
+}
+
+// 预留：手动清理接口（目前未在外部使用，但方便将来扩展）
+export function clearThoughtSignatureCaches() {
+  reasoningSignatureCache.clear();
+  toolSignatureCache.clear();
+}

src/utils/toolNameCache.js

@@ -0,0 +1,76 @@
+// 工具名称映射缓存：按 sessionId + model + safeName 维度
+// 解决：发送到上游时工具名必须 sanitize，返回时需要还原为原始工具名
+
+import memoryManager, { MemoryPressure } from './memoryManager.js';
+
+// safeKey: `${sessionId}::${model}::${safeName}` -> { originalName, ts }
+const toolNameMap = new Map();
+
+const MAX_ENTRIES = 512;
+const ENTRY_TTL_MS = 30 * 60 * 1000;      // 30 分钟
+const CLEAN_INTERVAL_MS = 10 * 60 * 1000; // 每 10 分钟扫一遍
+
+function makeKey(sessionId, model, safeName) {
+  return `${sessionId || ''}::${model || ''}::${safeName || ''}`;
+}
+
+function pruneSize(targetSize) {
+  if (toolNameMap.size <= targetSize) return;
+  const removeCount = toolNameMap.size - targetSize;
+  let removed = 0;
+  for (const key of toolNameMap.keys()) {
+    toolNameMap.delete(key);
+    removed++;
+    if (removed >= removeCount) break;
+  }
+}
+
+function pruneExpired(now) {
+  for (const [key, entry] of toolNameMap.entries()) {
+    if (!entry || typeof entry.ts !== 'number') continue;
+    if (now - entry.ts > ENTRY_TTL_MS) {
+      toolNameMap.delete(key);
+    }
+  }
+}
+
+// 按内存压力收缩缓存
+memoryManager.registerCleanup((pressure) => {
+  if (pressure === MemoryPressure.MEDIUM) {
+    pruneSize(Math.floor(MAX_ENTRIES / 2));
+  } else if (pressure === MemoryPressure.HIGH) {
+    pruneSize(Math.floor(MAX_ENTRIES / 4));
+  } else if (pressure === MemoryPressure.CRITICAL) {
+    toolNameMap.clear();
+  }
+});
+
+// 定时按 TTL 清理
+setInterval(() => {
+  const now = Date.now();
+  pruneExpired(now);
+}).unref?.();
+
+export function setToolNameMapping(sessionId, model, safeName, originalName) {
+  if (!safeName || !originalName || safeName === originalName) return;
+  const key = makeKey(sessionId, model, safeName);
+  toolNameMap.set(key, { originalName, ts: Date.now() });
+  pruneSize(MAX_ENTRIES);
+}
+
+export function getOriginalToolName(sessionId, model, safeName) {
+  if (!safeName) return null;
+  const key = makeKey(sessionId, model, safeName);
+  const entry = toolNameMap.get(key);
+  if (!entry) return null;
+  const now = Date.now();
+  if (typeof entry.ts === 'number' && now - entry.ts > ENTRY_TTL_MS) {
+    toolNameMap.delete(key);
+    return null;
+  }
+  return entry.originalName || null;
+}
+
+export function clearToolNameMappings() {
+  toolNameMap.clear();
+}

src/utils/utils.js

@@ -1,10 +1,27 @@
 import config from '../config/config.js';
 import tokenManager from '../auth/token_manager.js';
 import { generateRequestId } from './idGenerator.js';
-import os from 'os';
+import { saveBase64Image } from './imageStorage.js';
+import { getReasoningSignature, getToolSignature } from './thoughtSignatureCache.js';
+import { setToolNameMapping } from './toolNameCache.js';
 
-// 思维链签名占位（用于启用思考模型但没有真实签名时）
-const DEFAULT_THOUGHT_SIGNATURE = 'RXFRRENrZ0lDaEFDR0FJcVFKV1Bvcy9GV20wSmtMV2FmWkFEbGF1ZTZzQTdRcFlTc1NvbklmemtSNFo4c1dqeitIRHBOYW9hS2NYTE1TeTF3bjh2T1RHdE1KVjVuYUNQclZ5cm9DMFNETHk4M0hOSWsrTG1aRUhNZ3hvTTl0ZEpXUDl6UUMzOExxc2ZJakI0UkkxWE1mdWJ1VDQrZnY0Znp0VEoyTlhtMjZKL2daYi9HL1gwcmR4b2x0VE54empLemtLcEp0ZXRia2plb3NBcWlRSWlXUHloMGhVVTk1dHNha1dyNDVWNUo3MTJjZDNxdHQ5Z0dkbjdFaFk4dUllUC9CcThVY2VZZC9YbFpYbDc2bHpEbmdzL2lDZXlNY3NuZXdQMjZBTDRaQzJReXdibVQzbXlSZmpld3ZSaUxxOWR1TVNidHIxYXRtYTJ0U1JIRjI0Z0JwUnpadE1RTmoyMjR4bTZVNUdRNXlOSWVzUXNFNmJzRGNSV0RTMGFVOEZERExybmhVQWZQT2JYMG5lTGR1QnU1VGZOWW9NZGlRbTgyUHVqVE1xaTlmN0t2QmJEUUdCeXdyVXR2eUNnTEFHNHNqeWluZDRCOEg3N2ZJamt5blI3Q3ZpQzlIOTVxSENVTCt3K3JzMmsvV0sxNlVsbGlTK0pET3UxWXpPMWRPOUp3V3hEMHd5ZVU0a0Y5MjIxaUE5Z2lUd2djZXhSU2c4TWJVMm1NSjJlaGdlY3g0YjJ3QloxR0FFPQ==';
+// 思维链签名常量
+// Claude 模型签名
+const CLAUDE_THOUGHT_SIGNATURE = 'RXFRRENrZ0lDaEFDR0FJcVFKV1Bvcy9GV20wSmtMV2FmWkFEbGF1ZTZzQTdRcFlTc1NvbklmemtSNFo4c1dqeitIRHBOYW9hS2NYTE1TeTF3bjh2T1RHdE1KVjVuYUNQclZ5cm9DMFNETHk4M0hOSWsrTG1aRUhNZ3hvTTl0ZEpXUDl6UUMzOExxc2ZJakI0UkkxWE1mdWJ1VDQrZnY0Znp0VEoyTlhtMjZKL2daYi9HL1gwcmR4b2x0VE54empLemtLcEp0ZXRia2plb3NBcWlRSWlXUHloMGhVVTk1dHNha1dyNDVWNUo3MTJjZDNxdHQ5Z0dkbjdFaFk4dUllUC9CcThVY2VZZC9YbFpYbDc2bHpEbmdzL2lDZXlNY3NuZXdQMjZBTDRaQzJReXdibVQzbXlSZmpld3ZSaUxxOWR1TVNidHIxYXRtYTJ0U1JIRjI0Z0JwUnpadE1RTmoyMjR4bTZVNUdRNXlOSWVzUXNFNmJzRGNSV0RTMGFVOEZERExybmhVQWZQT2JYMG5lTGR1QnU1VGZOWW9NZGlRbTgyUHVqVE1xaTlmN0t2QmJEUUdCeXdyVXR2eUNnTEFHNHNqeWluZDRCOEg3N2ZJamt5blI3Q3ZpQzlIOTVxSENVTCt3K3JzMmsvV0sxNlVsbGlTK0pET3UxWXpPMWRPOUp3V3hEMHd5ZVU0a0Y5MjIxaUE5Z2lUd2djZXhSU2c4TWJVMm1NSjJlaGdlY3g0YjJ3QloxR0FFPQ==';
+// Gemini 思维链签名
+const GEMINI_THOUGHT_SIGNATURE = 'EqAHCp0HAXLI2nygRbdzD4Vgzxxi7tbM87zIRkNgPLqTj+Jxv9mY8Q0G87DzbTtvsIFhWB0RZMoEK6ntm5GmUe6ADtxHk4zgHUs/FKqTu8tzUdPRDrKn3KCAtFW4LJqijZoFxNKMyQRmlgPUX4tGYE7pllD77UK6SjCwKhKZoSVZLMiPXP9YFktbida1Q5upXMrzG1t8abPmpFo983T/rgWlNqJp+Fb+bsoH0zuSpmU4cPKO3LIGsxBhvRhM/xydahZD+VpEX7TEJAN58z1RomFyx9u0IR7ukwZr2UyoNA+uj8OChUDFupQsVwbm3XE1UAt22BGvfYIyyZ42fxgOgsFFY+AZ72AOufcmZb/8vIw3uEUgxHczdl+NGLuS4Hsy/AAntdcH9sojSMF3qTf+ZK1FMav23SPxUBtU5T9HCEkKqQWRnMsVGYV1pupFisWo85hRLDTUipxVy9ug1hN8JBYBNmGLf8KtWLhVp7Z11PIAZj3C6HzoVyiVeuiorwNrn0ZaaXNe+y5LHuDF0DNZhrIfnXByq6grLLSAv4fTLeCJvfGzTWWyZDMbVXNx1HgumKq8calP9wv33t0hfEaOlcmfGIyh1J/N+rOGR0WXcuZZP5/VsFR44S2ncpwTPT+MmR0PsjocDenRY5m/X4EXbGGkZ+cfPnWoA64bn3eLeJTwxl9W1ZbmYS6kjpRGUMxExgRNOzWoGISddHCLcQvN7o50K8SF5k97rxiS5q4rqDmqgRPXzQTQnZyoL3dCxScX9cvLSjNCZDcotonDBAWHfkXZ0/EmFiONQcLJdANtAjwoA44Mbn50gubrTsNd7d0Rm/hbNEh/ZceUalV5MMcl6tJtahCJoybQMsnjWuBXl7cXiKmqAvxTDxIaBgQBYAo4FrbV4zQv35zlol+O3YiyjJn/U0oBeO5pEcH1d0vnLgYP71jZVY2FjWRKnDR9aw4JhiuqAa+i0tupkBy+H4/SVwHADFQq6wcsL8qvXlwktJL9MIAoaXDkIssw6gKE9EuGd7bSO9f+sA8CZ0I8LfJ3jcHUsE/3qd4pFrn5RaET56+1p8ZHZDDUQ0p1okApUCCYsC2WuL6O9P4fcg3yitAA/AfUUNjHKANE+ANneQ0efMG7fx9bvI+iLbXgPupApoov24JRkmhHsrJiu9bp+G/pImd2PNv7ArunJ6upl0VAUWtRyLWyGfdl6etGuY8vVJ7JdWEQ8aWzRK3g6e+8YmDtP5DAfw==';
+// 工具调用思维链签名
+const TOOL_THOUGHT_SIGNATURE = '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';
+// 兜底签名（非 Claude/Gemini 时）
+const DEFAULT_THOUGHT_SIGNATURE = CLAUDE_THOUGHT_SIGNATURE;
+
+function getThoughtSignatureForModel(actualModelName) {
+  if (!actualModelName) return DEFAULT_THOUGHT_SIGNATURE;
+  const lower = actualModelName.toLowerCase();
+  if (lower.includes('claude')) return CLAUDE_THOUGHT_SIGNATURE;
+  if (lower.includes('gemini')) return GEMINI_THOUGHT_SIGNATURE;
+  return DEFAULT_THOUGHT_SIGNATURE;
+}
 
 function extractImagesFromContent(content) {
   const result = { text: '', images: [] };
@@ -42,6 +59,64 @@ function extractImagesFromContent(content) {
 
   return result;
 }
+
+// 尝试从工具调用返回的 JSON 字符串中提取图片，
+// 保存到本地图床并将 data 替换为 URL，同时附带 markdown 字段。
+function transformToolOutputForImages(rawContent) {
+  if (!rawContent) return rawContent;
+
+  let obj = rawContent;
+  let isString = false;
+
+  if (typeof rawContent === 'string') {
+    isString = true;
+    try {
+      obj = JSON.parse(rawContent);
+    } catch {
+      // 不是 JSON，直接返回原始内容
+      return rawContent;
+    }
+  }
+
+  if (!obj || typeof obj !== 'object') {
+    return rawContent;
+  }
+
+  const response = obj.response;
+  const contents = response?.content;
+  if (!Array.isArray(contents)) {
+    return rawContent;
+  }
+
+  const markdownBlocks = [];
+
+  for (const item of contents) {
+    if (item && item.type === 'image' && item.data && item.mimeType) {
+      try {
+        const url = saveBase64Image(item.data, item.mimeType);
+        // 去掉大体积的 base64，改为 URL
+        delete item.data;
+        item.url = url;
+
+        const alt = item.alt || 'image';
+        markdownBlocks.push(`![${alt}](${url})`);
+      } catch {
+        // 单张图片保存失败时忽略，继续处理其它内容
+      }
+    }
+  }
+
+  if (markdownBlocks.length > 0) {
+    const markdown = markdownBlocks.join('\n\n');
+    if (typeof obj.markdown === 'string' && obj.markdown.trim()) {
+      obj.markdown += `\n\n${markdown}`;
+    } else {
+      obj.markdown = markdown;
+    }
+  }
+
+  return isString ? JSON.stringify(obj) : obj;
+}
 function handleUserMessage(extracted, antigravityMessages){
   antigravityMessages.push({
     role: "user",
@@ -71,20 +146,38 @@ function sanitizeToolName(name) {
   }
   return cleaned;
 }
-function handleAssistantMessage(message, antigravityMessages, enableThinking){
+function handleAssistantMessage(message, antigravityMessages, enableThinking, actualModelName, sessionId){
   const lastMessage = antigravityMessages[antigravityMessages.length - 1];
   const hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
   const hasContent = message.content && message.content.trim() !== '';
   
-  const antigravityTools = hasToolCalls ? message.tool_calls.map(toolCall => ({
-    functionCall: {
-      id: toolCall.id,
-      name: sanitizeToolName(toolCall.function.name),
-      args: {
-        query: toolCall.function.arguments
+  const antigravityTools = hasToolCalls ? message.tool_calls.map(toolCall => {
+    const originalName = toolCall.function.name;
+    const safeName = sanitizeToolName(originalName);
+
+    const part = {
+      functionCall: {
+        id: toolCall.id,
+        name: safeName,
+        args: {
+          query: toolCall.function.arguments
+        }
       }
+    };
+
+    // 记录原始工具名到安全名的映射（仅当确实发生了变化时）
+    if (sessionId && actualModelName && safeName !== originalName) {
+      setToolNameMapping(sessionId, actualModelName, safeName, originalName);
+    }
+
+    // 启用思考模型时，工具调用优先使用实时签名（如果上游带了），否则兜底用常量
+    if (enableThinking) {
+      const cachedToolSig = getToolSignature(sessionId, actualModelName);
+      part.thoughtSignature = toolCall.thoughtSignature || cachedToolSig || TOOL_THOUGHT_SIGNATURE;
     }
-  })) : [];
+
+    return part;
+  }) : [];
 
   if (lastMessage?.role === "model" && hasToolCalls && !hasContent){
     lastMessage.parts.push(...antigravityTools)
@@ -102,6 +195,12 @@ function handleAssistantMessage(message, antigravityMessages, enableThinking){
     //   ]
     // }
     if (enableThinking) {
+      // 普通思维链签名：
+      // 1. 优先使用消息自身携带的 thoughtSignature
+      // 2. 其次使用缓存中的最新签名（同 session + model）
+      // 3. 最后按模型类型选择内置兜底签名
+      const cachedSig = getReasoningSignature(sessionId, actualModelName);
+      const thoughtSignature = message.thoughtSignature || cachedSig || getThoughtSignatureForModel(actualModelName);
       // 默认思考内容不能是完全空字符串，否则上游会要求 thinking 字段
       // 这里用一个不可见的退格符作为占位，实际展示时等价于“空思考块”
       let reasoningText = '';
@@ -112,7 +211,7 @@ function handleAssistantMessage(message, antigravityMessages, enableThinking){
       }
       parts.push({ text: reasoningText, thought: true });
       // 思维链签名占位，避免上游校验缺少签名字段
-      parts.push({ text: ' ', thoughtSignature: DEFAULT_THOUGHT_SIGNATURE });
+      parts.push({ text: ' ', thoughtSignature });
     }
 
     if (hasContent) parts.push({ text: message.content.trimEnd() });
@@ -141,12 +240,17 @@ function handleToolCall(message, antigravityMessages){
   }
   
   const lastMessage = antigravityMessages[antigravityMessages.length - 1];
+
+  // 尝试从工具输出中提取并持久化图片，返回值仍保持为字符串/原始格式，
+  // 但内部的图片 data 会被替换为图床 URL，并附带 markdown 字段。
+  const transformedContent = transformToolOutputForImages(message.content);
+
   const functionResponse = {
     functionResponse: {
       id: message.tool_call_id,
       name: functionName,
       response: {
-        output: message.content
+        output: transformedContent
       }
     }
   };
@@ -161,7 +265,7 @@ function handleToolCall(message, antigravityMessages){
     });
   }
 }
-function openaiMessageToAntigravity(openaiMessages, enableThinking){
+function openaiMessageToAntigravity(openaiMessages, enableThinking, actualModelName, sessionId){
   const antigravityMessages = [];
   for (const message of openaiMessages) {
     if (message.role === "user") {
@@ -172,7 +276,7 @@ function openaiMessageToAntigravity(openaiMessages, enableThinking){
       const extracted = extractImagesFromContent(message.content);
       handleUserMessage(extracted, antigravityMessages);
     } else if (message.role === "assistant") {
-      handleAssistantMessage(message, antigravityMessages, enableThinking);
+      handleAssistantMessage(message, antigravityMessages, enableThinking, actualModelName, sessionId);
     } else if (message.role === "tool") {
       handleToolCall(message, antigravityMessages);
     }
@@ -308,7 +412,7 @@ function cleanParameters(obj) {
   return cleaned;
 }
 
-function convertOpenAIToolsToAntigravity(openaiTools){
+function convertOpenAIToolsToAntigravity(openaiTools, sessionId, actualModelName){
   if (!openaiTools || openaiTools.length === 0) return [];
   return openaiTools.map((tool)=>{
     // 先清洗一遍参数，过滤/规范化不兼容字段
@@ -325,7 +429,13 @@ function convertOpenAIToolsToAntigravity(openaiTools){
       cleanedParams.properties = {};
     }
 
-    const safeName = sanitizeToolName(tool.function?.name);
+    const originalName = tool.function?.name;
+    const safeName = sanitizeToolName(originalName);
+
+    // 仅当发生转换时才缓存映射
+    if (sessionId && actualModelName && safeName !== originalName) {
+      setToolNameMapping(sessionId, actualModelName, safeName, originalName);
+    }
 
     return {
       functionDeclarations: [
@@ -382,8 +492,8 @@ function generateRequestBody(openaiMessages,modelName,parameters,openaiTools,tok
     project: token.projectId,
     requestId: generateRequestId(),
     request: {
-      contents: openaiMessageToAntigravity(filteredMessages, enableThinking),
-      tools: convertOpenAIToolsToAntigravity(openaiTools),
+      contents: openaiMessageToAntigravity(filteredMessages, enableThinking, actualModelName, token.sessionId),
+      tools: convertOpenAIToolsToAntigravity(openaiTools, token.sessionId, actualModelName),
       toolConfig: {
         functionCallingConfig: {
           mode: "VALIDATED"
@@ -423,21 +533,8 @@ function prepareImageRequest(requestBody) {
 
   return requestBody;
 }
-
-function getDefaultIp(){
-  const interfaces = os.networkInterfaces();
-  for (const iface of Object.values(interfaces)){
-    for (const inter of iface){
-      if (inter.family === 'IPv4' && !inter.internal){
-        return inter.address;
-      }
-    }
-  }
-  return '127.0.0.1';
-}
 export{
   generateRequestId,
   generateRequestBody,
-  prepareImageRequest,
-  getDefaultIp
+  prepareImageRequest
 }