ai-protocol-adapters 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/index.mjs

@@ -397,523 +397,463 @@ function getGlobalLogger() {
   return globalLogger;
 }
 
-// src/core/streaming/streaming-protocol-adapter.ts
-var StreamingProtocolAdapter = class {
-  constructor(options = {}) {
-    this.config = {
-      debugMode: options.debugMode ?? false,
-      validateInput: options.validateInput ?? false,
-      validateOutput: options.validateOutput ?? false,
-      autoHeal: options.autoHeal ?? false,
-      timeout: options.timeout ?? 3e4,
-      retries: options.retries ?? 3,
-      bufferSize: options.bufferSize ?? 1024,
-      logger: options.logger ?? getGlobalLogger()
-    };
+// src/core/a2o-request-adapter/config.ts
+var DEFAULT_CONFIG = {
+  // 原有配置
+  debugMode: false,
+  maxDescriptionLength: 100,
+  enableToolNameValidation: true,
+  enableFormatValidation: true,
+  // 新增默认配置
+  validation: {
+    enabled: true,
+    strict: false,
+    // 默认开启自动修复
+    customSchemas: {}
+  },
+  healing: {
+    enabled: true,
+    maxAttempts: 3,
+    enableCustomRules: true
+  },
+  recovery: {
+    enabled: true,
+    maxRetries: 2,
+    backoffMs: 1e3
+  },
+  monitoring: {
+    enabled: false,
+    logLevel: "warn",
+    enableMetrics: false
+  },
+  imageProxy: {
+    enabled: true,
+    // 默认启用图片代理（解决GitHub Copilot等不支持外部URL的问题）
+    timeout: 1e4,
+    // 10秒超时
+    maxSize: 10 * 1024 * 1024
+    // 10MB最大文件大小
   }
+};
+var SUPPORTED_IMAGE_TYPES = [
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+];
+var TOOL_CONVERSION = {
   /**
-   * 转换Anthropic请求为OpenAI格式
+   * 终极泛化：完全移除工具名称映射
+   * 基于GitHub Copilot API测试结果，100%保持原始格式
    */
-  convertAnthropicToOpenAI(anthropicRequest) {
-    const logger = this.config.logger;
-    if (this.config.debugMode) {
-      logger.debug("Converting Anthropic request to OpenAI format", { model: anthropicRequest.model });
+  PRESERVE_ORIGINAL_NAMES: true,
+  /**
+   * 默认工具描述
+   */
+  DEFAULT_DESCRIPTION: "Tool description",
+  /**
+   * 未知工具回退名称
+   */
+  UNKNOWN_TOOL_FALLBACK: "unknown_tool"
+};
+
+// src/core/a2o-request-adapter/image-proxy.ts
+var SUPPORTED_IMAGE_MIME_TYPES = [
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+];
+async function downloadImageAsBase64(url, options = {}) {
+  const {
+    timeout = 1e4,
+    maxSize = 10 * 1024 * 1024,
+    // 10MB
+    userAgent = "ai-protocol-adapters/1.0"
+  } = options;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": userAgent
+      }
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const openaiRequest = {
-      model: this.mapAnthropicModelToOpenAI(anthropicRequest.model),
-      messages: this.convertMessages(anthropicRequest.messages),
-      stream: anthropicRequest.stream ?? true,
-      temperature: anthropicRequest.temperature,
-      max_tokens: anthropicRequest.max_tokens
-    };
-    if (anthropicRequest.tools) {
-      openaiRequest.tools = anthropicRequest.tools.map((tool) => ({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.input_schema
-        }
-      }));
+    const contentType = response.headers.get("content-type");
+    if (!contentType || !SUPPORTED_IMAGE_MIME_TYPES.some((type) => contentType.includes(type))) {
+      throw new Error(`Unsupported content type: ${contentType}`);
     }
-    const hasImages = this.hasImageContent(anthropicRequest);
-    return {
-      openaiRequest,
-      metadata: {
-        hasImages,
-        requiresVisionHeaders: hasImages
-      }
-    };
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && parseInt(contentLength) > maxSize) {
+      throw new Error(`Image too large: ${contentLength} bytes (max: ${maxSize} bytes)`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    if (arrayBuffer.byteLength > maxSize) {
+      throw new Error(`Image too large: ${arrayBuffer.byteLength} bytes (max: ${maxSize} bytes)`);
+    }
+    const base64 = Buffer.from(arrayBuffer).toString("base64");
+    return `data:${contentType};base64,${base64}`;
+  } catch (error) {
+    if (error.name === "AbortError") {
+      throw new Error(`Image download timeout after ${timeout}ms`);
+    }
+    throw new Error(`Failed to download image from ${url}: ${error.message}`);
   }
+}
+function isExternalUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+function isBase64DataUri(url) {
+  return url.startsWith("data:");
+}
+
+// src/core/a2o-request-adapter/message-converter.ts
+var MessageConverter = class {
   /**
-   * 转换OpenAI流式响应为Anthropic SSE格式
+   * 转换消息格式，正确处理工具调用和工具结果
+   * 修复关键问题：将tool_use转换为tool_calls，tool_result转换为role:"tool"消息
+   * 使用tool_use_id溯回工具名称解决unknown_tool问题
    */
-  convertOpenAIStreamToAnthropic(openaiStream, originalRequest) {
-    const logger = this.config.logger;
-    try {
-      if (this.config.debugMode) {
-        logger.debug("Converting OpenAI stream to Anthropic SSE", {
-          streamLength: openaiStream.length,
-          model: originalRequest.model
-        });
+  static convertMessages(messages, system) {
+    const debugEnabled = process.env.AI_PROTOCOL_DEBUG === "true";
+    if (debugEnabled) {
+      if (system !== void 0) {
+        console.debug("[MessageConverter] convertMessages called with system:", JSON.stringify(system, null, 2));
+      } else {
+        console.debug("[MessageConverter] convertMessages called WITHOUT system parameter");
       }
-      if (!openaiStream || openaiStream.trim() === "") {
-        return {
-          success: false,
-          error: "Empty stream response",
-          anthropicSSE: "",
-          anthropicStandardResponse: null
-        };
+    }
+    const context = this.createConversionContext(messages);
+    const convertedMessages = [];
+    for (const msg of messages) {
+      if (Array.isArray(msg.content)) {
+        const processedMessages = this.processComplexMessage(msg, context);
+        convertedMessages.push(...processedMessages);
+      } else {
+        const safeMsg = { ...msg };
+        if (safeMsg.content === null || safeMsg.content === void 0) {
+          safeMsg.content = "";
+        }
+        convertedMessages.push(safeMsg);
+      }
+    }
+    if (system) {
+      const systemMessage = this.processSystemMessage(system);
+      if (systemMessage) {
+        convertedMessages.unshift(systemMessage);
+        if (debugEnabled) {
+          console.debug("[MessageConverter] System message added to messages array at index 0");
+        }
       }
-      const anthropicSSE = this.convertToAnthropicSSE(openaiStream, originalRequest.model);
-      const anthropicStandardResponse = this.buildStandardResponse(openaiStream);
-      return {
-        success: true,
-        anthropicSSE,
-        anthropicStandardResponse
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown conversion error";
-      logger.error("Stream conversion failed", { error: errorMessage });
-      return {
-        success: false,
-        error: errorMessage,
-        anthropicSSE: "",
-        anthropicStandardResponse: null
-      };
     }
+    if (debugEnabled) {
+      console.debug("[MessageConverter] Final converted messages count:", convertedMessages.length);
+      console.debug("[MessageConverter] First message:", JSON.stringify(convertedMessages[0], null, 2));
+    }
+    return convertedMessages.map((msg) => {
+      if (Array.isArray(msg.tools)) {
+        msg.tools = msg.tools.map((tool) => {
+          if (tool?.type === "function" && tool.function) {
+            const description = tool.function.description?.trim() || "Converted tool with no description provided.";
+            return {
+              ...tool,
+              function: {
+                ...tool.function,
+                description
+              }
+            };
+          }
+          return tool;
+        });
+      }
+      return msg;
+    });
   }
   /**
-   * 将OpenAI流转换为Anthropic SSE格式
+   * 创建消息转换上下文
    */
-  convertToAnthropicSSE(openaiStream, modelName) {
-    const lines = openaiStream.split("\n");
-    const sseLines = [];
-    const state = this.createConversionState();
-    sseLines.push(
-      "event: message_start",
-      `data: {"type":"message_start","message":{"id":"msg_${Date.now()}","type":"message","role":"assistant","model":"${modelName}","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}}`,
-      ""
-    );
-    for (const line of lines) {
-      if (line.startsWith("data:")) {
-        const dataLine = line.substring(5);
-        if (dataLine.trim() === "[DONE]") {
-          this.addFinalEvents(state, sseLines);
-          break;
-        }
-        try {
-          const chunk = JSON.parse(dataLine);
-          this.processStreamChunk(chunk, state, sseLines);
-        } catch (error) {
-          if (this.config.debugMode) {
-            this.config.logger.warn("Failed to parse stream chunk", { line: dataLine.substring(0, 200) });
+  static createConversionContext(messages) {
+    const toolIdToNameMap = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (typeof item === "object" && item !== null && item.type === "tool_use") {
+            toolIdToNameMap.set(item.id, item.name);
           }
         }
       }
     }
-    return sseLines.join("\n");
+    return {
+      toolIdToNameMap,
+      hasSystemMessage: false
+    };
   }
   /**
-   * 处理单个流式数据块 - 支持thinking和content双模式
+   * 处理复杂消息（包含多种内容类型）
    */
-  processStreamChunk(chunk, state, sseLines) {
-    const choice = chunk.choices?.[0];
-    if (!choice) return;
-    const delta = choice.delta;
-    if (delta.reasoning_content) {
-      state.reasoningContent += delta.reasoning_content;
-      if (!state.thinkingBlockStarted) {
-        sseLines.push(
-          "event: content_block_start",
-          'data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":"<thinking>"}}',
-          ""
-        );
-        state.thinkingBlockStarted = true;
+  static processComplexMessage(msg, context) {
+    const { textContent, toolUses, toolResults } = this.categorizeContent(msg.content);
+    const resultMessages = [];
+    if (msg.role === "assistant" && toolUses.length > 0) {
+      const assistantMessage = this.createAssistantMessageWithToolCalls(textContent, toolUses);
+      resultMessages.push(assistantMessage);
+    } else if (toolResults.length > 0) {
+      const toolMessages = this.createToolResultMessages(toolResults, context.toolIdToNameMap);
+      resultMessages.push(...toolMessages);
+      const textMessage = this.createTextMessage(msg.role, textContent);
+      if (textMessage) {
+        resultMessages.push(textMessage);
       }
-      sseLines.push(
-        "event: content_block_delta",
-        `data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"${this.escapeJsonString(delta.reasoning_content)}"}}`,
-        ""
-      );
-    }
-    if (delta.content && delta.content !== "") {
-      if (state.thinkingBlockStarted && !state.contentBlockStarted) {
-        sseLines.push(
-          "event: content_block_delta",
-          'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"</thinking>\\n\\n"}}',
-          "",
-          "event: content_block_stop",
-          'data: {"type":"content_block_stop","index":0}',
-          "",
-          "event: content_block_start",
-          'data: {"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}}',
-          ""
-        );
-        state.contentBlockStarted = true;
-      } else if (!state.contentBlockStarted && !state.thinkingBlockStarted) {
-        sseLines.push(
-          "event: content_block_start",
-          'data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}',
-          ""
-        );
-        state.contentBlockStarted = true;
+    } else if (textContent.length > 0) {
+      const textMessage = this.createTextMessage(msg.role, textContent);
+      if (textMessage) {
+        resultMessages.push(textMessage);
       }
-      state.textContent += delta.content;
-      const blockIndex = state.thinkingBlockStarted ? 1 : 0;
-      sseLines.push(
-        "event: content_block_delta",
-        `data: {"type":"content_block_delta","index":${blockIndex},"delta":{"type":"text_delta","text":"${this.escapeJsonString(delta.content)}"}}`,
-        ""
-      );
-    }
-    if (delta.tool_calls) {
-      this.processToolCalls(delta.tool_calls, state, sseLines);
-    }
-    if (chunk.usage) {
-      state.usage.input_tokens = chunk.usage.prompt_tokens;
-      state.usage.output_tokens = chunk.usage.completion_tokens;
     }
+    return resultMessages;
   }
   /**
-   * 处理工具调用
+   * 分类内容块
    */
-  processToolCalls(toolCalls, state, sseLines) {
-    for (const toolCall of toolCalls) {
-      if (toolCall.id && toolCall.function?.name) {
-        const toolData = {
-          id: toolCall.id,
-          name: toolCall.function.name,
-          input: toolCall.function.arguments || ""
-        };
-        state.toolCallsMap.set(toolCall.id, toolData);
-        sseLines.push(
-          "event: content_block_start",
-          `data: {"type":"content_block_start","index":${state.completedToolCalls.length + 1},"content_block":{"type":"tool_use","id":"${toolCall.id}","name":"${toolCall.function.name}","input":{}}}`,
-          ""
-        );
+  static categorizeContent(content) {
+    const textContent = [];
+    const toolUses = [];
+    const toolResults = [];
+    for (const item of content) {
+      if (typeof item === "string") {
+        textContent.push({ type: "text", text: item });
+      } else if (typeof item === "object" && item !== null) {
+        switch (item.type) {
+          case "text":
+            textContent.push(item);
+            break;
+          case "tool_use":
+            toolUses.push(item);
+            break;
+          case "tool_result":
+            toolResults.push(item);
+            break;
+          case "image":
+            const imageContent = this.convertImageContent(item);
+            if (imageContent) {
+              textContent.push(imageContent);
+            }
+            break;
+        }
       }
     }
+    return { textContent, toolUses, toolResults };
   }
   /**
-   * 添加最终事件 - 支持thinking+content双模式
+   * 转换图片内容格式
+   * 支持两种格式：URL 和 base64
    */
-  addFinalEvents(state, sseLines) {
-    if (state.contentBlockStarted) {
-      const blockIndex = state.thinkingBlockStarted ? 1 : 0;
-      sseLines.push(
-        "event: content_block_stop",
-        `data: {"type":"content_block_stop","index":${blockIndex}}`,
-        ""
-      );
-    } else if (state.thinkingBlockStarted) {
-      sseLines.push(
-        "event: content_block_delta",
-        'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"</thinking>"}}',
-        "",
-        "event: content_block_stop",
-        'data: {"type":"content_block_stop","index":0}',
-        ""
-      );
+  static convertImageContent(item) {
+    if (!item.source) {
+      return null;
     }
-    sseLines.push(
-      "event: message_delta",
-      `data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":${state.usage.output_tokens}}}`,
-      "",
-      "event: message_stop",
-      'data: {"type":"message_stop"}',
-      ""
-    );
-  }
-  /**
-   * 构建标准响应格式
-   */
-  buildStandardResponse(openaiStream) {
-    const state = this.createConversionState();
-    const lines = openaiStream.split("\n");
-    for (const line of lines) {
-      if (line.startsWith("data: ")) {
-        const dataLine = line.substring(6);
-        if (dataLine.trim() === "[DONE]") break;
-        try {
-          const chunk = JSON.parse(dataLine);
-          const choice = chunk.choices?.[0];
-          if (!choice) continue;
-          const delta = choice.delta;
-          if (delta.content) {
-            state.textContent += delta.content;
-          }
-          if (chunk.usage) {
-            state.usage.input_tokens = chunk.usage.prompt_tokens;
-            state.usage.output_tokens = chunk.usage.completion_tokens;
-          }
-        } catch (error) {
+    if (item.source.type === "url" && item.source.url) {
+      return {
+        type: "image_url",
+        image_url: {
+          url: item.source.url,
+          detail: "auto"
+          // OpenAI 支持的可选参数
         }
-      }
+      };
     }
-    return {
-      id: `msg_${Date.now()}`,
-      type: "message",
-      role: "assistant",
-      content: [
-        {
-          type: "text",
-          text: state.textContent
+    if (item.source.type === "base64" && item.source.data && item.source.media_type) {
+      if (!SUPPORTED_IMAGE_TYPES.includes(item.source.media_type)) {
+        console.warn(`\u4E0D\u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F: ${item.source.media_type}`);
+        return null;
+      }
+      const dataUri = `data:${item.source.media_type};base64,${item.source.data}`;
+      return {
+        type: "image_url",
+        image_url: {
+          url: dataUri,
+          detail: "auto"
         }
-      ],
-      model: "claude-3-sonnet-20240229",
-      stop_reason: "end_turn",
-      stop_sequence: null,
-      usage: state.usage
-    };
+      };
+    }
+    return null;
   }
   /**
-   * 创建转换状态对象
+   * 创建包含工具调用的助手消息
    */
-  createConversionState() {
-    return {
-      processedLines: 0,
-      textContent: "",
-      reasoningContent: "",
-      toolCallsMap: /* @__PURE__ */ new Map(),
-      completedToolCalls: [],
-      allSSELines: [],
-      errors: [],
-      usage: {
-        input_tokens: 0,
-        output_tokens: 0
-      },
-      thinkingBlockStarted: false,
-      contentBlockStarted: false
+  static createAssistantMessageWithToolCalls(textContent, toolUses) {
+    const assistantMessage = {
+      role: "assistant",
+      content: ""
+      // 默认为空字符串，避免null值
     };
-  }
-  /**
-   * 转换消息格式
-   */
-  convertMessages(messages) {
-    return messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content
-    }));
-  }
-  /**
-   * 映射Anthropic模型到OpenAI模型
-   */
-  mapAnthropicModelToOpenAI(model) {
-    const supportedModels = [
-      "glm-4.5",
-      "kimi-k2",
-      "deepseek-v3.1",
-      "deepseek-r1",
-      "deepseek-v3",
-      "qwen3-32b",
-      "qwen3-coder",
-      "qwen3-235b",
-      "tstars2.0"
-    ];
-    if (supportedModels.includes(model)) {
-      return model;
+    if (textContent.length > 0) {
+      const textOnly = textContent.map((item) => item.text || "").join("");
+      if (textOnly.trim()) {
+        assistantMessage.content = textOnly.trim();
+      }
     }
-    const mapping = {
-      "claude-3-sonnet-20240229": "glm-4.5",
-      "claude-3-haiku-20240307": "kimi-k2",
-      "claude-3-opus-20240229": "deepseek-v3.1"
-    };
-    return mapping[model] || "glm-4.5";
+    assistantMessage.tool_calls = toolUses.map((toolUse) => ({
+      id: toolUse.id,
+      type: "function",
+      function: {
+        name: toolUse.name,
+        arguments: JSON.stringify(toolUse.input || {})
+      }
+    }));
+    return assistantMessage;
   }
   /**
-   * 检查请求是否包含图片内容
+   * 创建工具结果消息
    */
-  hasImageContent(request) {
-    return request.messages.some(
-      (msg) => Array.isArray(msg.content) && msg.content.some((content) => content?.type === "image")
-    );
+  static createToolResultMessages(toolResults, toolIdToNameMap) {
+    return toolResults.map((toolResult) => {
+      let resultContent = "No content";
+      if (toolResult.content) {
+        if (typeof toolResult.content === "string") {
+          resultContent = toolResult.content;
+        } else {
+          resultContent = JSON.stringify(toolResult.content, null, 2);
+        }
+      }
+      const toolName = toolIdToNameMap.get(toolResult.tool_use_id) || TOOL_CONVERSION.UNKNOWN_TOOL_FALLBACK;
+      return {
+        role: "tool",
+        tool_call_id: toolResult.tool_use_id,
+        name: toolName,
+        content: resultContent
+      };
+    });
   }
   /**
-   * 转义JSON字符串
+   * 创建文本消息
    */
-  escapeJsonString(str) {
-    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  static createTextMessage(role, textContent) {
+    if (textContent.length === 0) return null;
+    const hasNonTextContent = textContent.some((item) => item.type !== "text");
+    if (hasNonTextContent) {
+      return {
+        role,
+        content: textContent
+      };
+    } else {
+      const textOnly = textContent.map((item) => item.text || "").join("");
+      return {
+        role,
+        content: textOnly.trim() || ""
+        // 确保content为字符串，避免null
+      };
+    }
   }
   /**
-   * 获取初始SSE事件（message_start + ping）
+   * 处理系统消息
    */
-  getInitialSSEEvents(modelName = "claude-sonnet-4", messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`) {
-    return [
-      "event: message_start",
-      `data: {"type":"message_start","message":{"id":"${messageId}","type":"message","role":"assistant","model":"${modelName}","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}}`,
-      "",
-      "event: ping",
-      'data: {"type":"ping"}',
-      ""
-    ];
+  static processSystemMessage(system) {
+    let systemContent;
+    if (Array.isArray(system)) {
+      systemContent = system.map((s) => {
+        if (typeof s === "string") {
+          return s;
+        }
+        return s.text || "";
+      }).filter((text) => text.length > 0).join("\n").trim();
+    } else {
+      systemContent = system;
+    }
+    if (systemContent) {
+      return {
+        role: "system",
+        content: systemContent
+      };
+    }
+    return null;
   }
   /**
-   * 增量转换单个OpenAI数据块为Anthropic SSE事件
-   * 用于逐个处理流式数据片段
+   * 异步转换图片内容格式（支持URL自动下载转base64）
+   * @param item 图片内容项
+   * @param downloadUrls 是否下载URL并转换为base64（默认true）
    */
-  convertIncrementalChunk(openaiDataLine, state) {
-    const logger = this.config.logger;
-    const sseEvents = [];
-    if (openaiDataLine.trim() === "[DONE]") {
-      this.addFinalEvents(state, sseEvents);
-      return sseEvents;
+  static async convertImageContentAsync(item, downloadUrls = true) {
+    if (!item.source) {
+      return null;
     }
-    try {
-      const chunk = JSON.parse(openaiDataLine);
-      this.processStreamChunk(chunk, state, sseEvents);
-      return sseEvents;
-    } catch (error) {
-      if (this.config.debugMode) {
-        logger.warn("Failed to parse OpenAI stream chunk in convertIncrementalChunk", {
-          line: openaiDataLine.substring(0, 200),
-          error: error instanceof Error ? error.message : String(error)
-        });
+    if (item.source.type === "url" && item.source.url) {
+      const url = item.source.url;
+      if (isBase64DataUri(url)) {
+        return {
+          type: "image_url",
+          image_url: {
+            url,
+            detail: "auto"
+          }
+        };
       }
-      return [];
-    }
-  }
-};
-
-// src/core/a2o-request-adapter/config.ts
-var DEFAULT_CONFIG = {
-  // 原有配置
-  debugMode: false,
-  maxDescriptionLength: 100,
-  enableToolNameValidation: true,
-  enableFormatValidation: true,
-  // 新增默认配置
-  validation: {
-    enabled: true,
-    strict: false,
-    // 默认开启自动修复
-    customSchemas: {}
-  },
-  healing: {
-    enabled: true,
-    maxAttempts: 3,
-    enableCustomRules: true
-  },
-  recovery: {
-    enabled: true,
-    maxRetries: 2,
-    backoffMs: 1e3
-  },
-  monitoring: {
-    enabled: false,
-    logLevel: "warn",
-    enableMetrics: false
-  }
-};
-var SUPPORTED_IMAGE_TYPES = [
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp"
-];
-var TOOL_CONVERSION = {
-  /**
-   * 终极泛化：完全移除工具名称映射
-   * 基于GitHub Copilot API测试结果，100%保持原始格式
-   */
-  PRESERVE_ORIGINAL_NAMES: true,
-  /**
-   * 默认工具描述
-   */
-  DEFAULT_DESCRIPTION: "Tool description",
-  /**
-   * 未知工具回退名称
-   */
-  UNKNOWN_TOOL_FALLBACK: "unknown_tool"
-};
-
-// src/core/a2o-request-adapter/message-converter.ts
-var MessageConverter = class {
-  /**
-   * 转换消息格式，正确处理工具调用和工具结果
-   * 修复关键问题：将tool_use转换为tool_calls，tool_result转换为role:"tool"消息
-   * 使用tool_use_id溯回工具名称解决unknown_tool问题
-   */
-  static convertMessages(messages, system) {
-    const context = this.createConversionContext(messages);
-    const convertedMessages = [];
-    for (const msg of messages) {
-      if (Array.isArray(msg.content)) {
-        const processedMessages = this.processComplexMessage(msg, context);
-        convertedMessages.push(...processedMessages);
-      } else {
-        const safeMsg = { ...msg };
-        if (safeMsg.content === null || safeMsg.content === void 0) {
-          safeMsg.content = "";
+      if (downloadUrls && isExternalUrl(url)) {
+        try {
+          console.log(`[MessageConverter] Downloading image from URL: ${url}`);
+          const base64DataUri = await downloadImageAsBase64(url);
+          console.log(`[MessageConverter] Successfully converted image to base64`);
+          return {
+            type: "image_url",
+            image_url: {
+              url: base64DataUri,
+              detail: "auto"
+            }
+          };
+        } catch (error) {
+          console.error(`[MessageConverter] Failed to download image: ${error.message}`);
+          return {
+            type: "image_url",
+            image_url: {
+              url,
+              detail: "auto"
+            }
+          };
         }
-        convertedMessages.push(safeMsg);
-      }
-    }
-    if (system) {
-      const systemMessage = this.processSystemMessage(system);
-      if (systemMessage) {
-        convertedMessages.unshift(systemMessage);
       }
-    }
-    return convertedMessages;
-  }
-  /**
-   * 创建消息转换上下文
-   */
-  static createConversionContext(messages) {
-    const toolIdToNameMap = /* @__PURE__ */ new Map();
-    for (const msg of messages) {
-      if (Array.isArray(msg.content)) {
-        for (const item of msg.content) {
-          if (typeof item === "object" && item !== null && item.type === "tool_use") {
-            toolIdToNameMap.set(item.id, item.name);
-          }
+      return {
+        type: "image_url",
+        image_url: {
+          url,
+          detail: "auto"
         }
-      }
+      };
     }
-    return {
-      toolIdToNameMap,
-      hasSystemMessage: false
-    };
-  }
-  /**
-   * 处理复杂消息（包含多种内容类型）
-   */
-  static processComplexMessage(msg, context) {
-    const { textContent, toolUses, toolResults } = this.categorizeContent(msg.content);
-    const resultMessages = [];
-    if (msg.role === "assistant" && toolUses.length > 0) {
-      const assistantMessage = this.createAssistantMessageWithToolCalls(textContent, toolUses);
-      resultMessages.push(assistantMessage);
-    } else if (toolResults.length > 0) {
-      const toolMessages = this.createToolResultMessages(toolResults, context.toolIdToNameMap);
-      resultMessages.push(...toolMessages);
-      const textMessage = this.createTextMessage(msg.role, textContent);
-      if (textMessage) {
-        resultMessages.push(textMessage);
-      }
-    } else if (textContent.length > 0) {
-      const textMessage = this.createTextMessage(msg.role, textContent);
-      if (textMessage) {
-        resultMessages.push(textMessage);
+    if (item.source.type === "base64" && item.source.data && item.source.media_type) {
+      if (!SUPPORTED_IMAGE_TYPES.includes(item.source.media_type)) {
+        console.warn(`\u4E0D\u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F: ${item.source.media_type}`);
+        return null;
       }
+      const dataUri = `data:${item.source.media_type};base64,${item.source.data}`;
+      return {
+        type: "image_url",
+        image_url: {
+          url: dataUri,
+          detail: "auto"
+        }
+      };
     }
-    return resultMessages;
+    return null;
   }
   /**
-   * 分类内容块
+   * 异步处理消息内容（支持图片URL下载）
    */
-  static categorizeContent(content) {
+  static async processMessageContentAsync(content, downloadUrls = true) {
     const textContent = [];
     const toolUses = [];
     const toolResults = [];
     for (const item of content) {
-      if (typeof item === "string") {
-        textContent.push({ type: "text", text: item });
-      } else if (typeof item === "object" && item !== null) {
+      if (item.type) {
         switch (item.type) {
           case "text":
-            textContent.push(item);
+            if (item.text) {
+              textContent.push({ type: "text", text: item.text });
+            }
             break;
           case "tool_use":
             toolUses.push(item);
@@ -922,7 +862,7 @@ var MessageConverter = class {
             toolResults.push(item);
             break;
           case "image":
-            const imageContent = this.convertImageContent(item);
+            const imageContent = await this.convertImageContentAsync(item, downloadUrls);
             if (imageContent) {
               textContent.push(imageContent);
             }
@@ -933,146 +873,102 @@ var MessageConverter = class {
     return { textContent, toolUses, toolResults };
   }
   /**
-   * 转换图片内容格式
+   * 异步转换消息格式（支持图片URL自动下载）
+   * @param messages Claude格式的消息数组
+   * @param system 系统消息
+   * @param downloadImageUrls 是否下载图片URL并转换为base64（默认true，解决GitHub Copilot等API不支持外部URL的问题）
    */
-  static convertImageContent(item) {
-    if (item.source && item.source.type === "base64" && item.source.data && item.source.media_type) {
-      if (!SUPPORTED_IMAGE_TYPES.includes(item.source.media_type)) {
-        console.warn(`\u4E0D\u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F: ${item.source.media_type}`);
-        return null;
-      }
-      const dataUri = `data:${item.source.media_type};base64,${item.source.data}`;
-      return {
-        type: "image_url",
-        image_url: {
-          url: dataUri
+  static async convertMessagesAsync(messages, system, downloadImageUrls = true) {
+    const debugEnabled = process.env.AI_PROTOCOL_DEBUG === "true";
+    if (debugEnabled) {
+      console.debug(
+        `[MessageConverter] convertMessagesAsync called (downloadImageUrls: ${downloadImageUrls})`
+      );
+    }
+    const context = this.createConversionContext(messages);
+    const convertedMessages = [];
+    for (const msg of messages) {
+      if (Array.isArray(msg.content)) {
+        const processedMessages = await this.processComplexMessageAsync(msg, context, downloadImageUrls);
+        convertedMessages.push(...processedMessages);
+      } else {
+        const safeMsg = { ...msg };
+        if (safeMsg.content === null || safeMsg.content === void 0) {
+          safeMsg.content = "";
         }
-      };
+        convertedMessages.push(safeMsg);
+      }
     }
-    return null;
+    const systemMessage = this.processSystemMessage(system);
+    if (systemMessage) {
+      return [systemMessage, ...convertedMessages];
+    }
+    return convertedMessages;
   }
   /**
-   * 创建包含工具调用的助手消息
+   * 异步处理复杂消息（支持图片URL下载）
    */
-  static createAssistantMessageWithToolCalls(textContent, toolUses) {
-    const assistantMessage = {
-      role: "assistant",
-      content: ""
-      // 默认为空字符串，避免null值
-    };
-    if (textContent.length > 0) {
-      const textOnly = textContent.map((item) => item.text || "").join("");
-      if (textOnly.trim()) {
-        assistantMessage.content = textOnly.trim();
+  static async processComplexMessageAsync(msg, context, downloadUrls) {
+    const { textContent, toolUses, toolResults } = await this.processMessageContentAsync(
+      msg.content,
+      downloadUrls
+    );
+    const result = [];
+    if (msg.role === "user") {
+      const toolMessages = this.createToolResultMessages(toolResults, context.toolIdToNameMap);
+      result.push(...toolMessages);
+      const textMessage = this.createTextMessage("user", textContent);
+      if (textMessage) {
+        result.push(textMessage);
+      }
+    } else if (msg.role === "assistant") {
+      if (toolUses.length > 0) {
+        const assistantMessage = this.createAssistantMessageWithToolCalls(textContent, toolUses);
+        result.push(assistantMessage);
+        toolUses.forEach((toolUse) => {
+          context.toolIdToNameMap.set(toolUse.id, toolUse.name);
+        });
+      } else {
+        const textMessage = this.createTextMessage("assistant", textContent);
+        if (textMessage) {
+          result.push(textMessage);
+        }
       }
     }
-    assistantMessage.tool_calls = toolUses.map((toolUse) => ({
-      id: toolUse.id,
+    return result;
+  }
+};
+
+// src/core/a2o-request-adapter/tool-converter.ts
+var ToolConverter = class {
+  /**
+   * 将Anthropic工具定义转换为OpenAI格式
+   */
+  static convertAnthropicToolToOpenAI(anthropicTool) {
+    if (!anthropicTool || !anthropicTool.name) {
+      throw new Error("Invalid tool definition: missing name");
+    }
+    const openaiName = anthropicTool.name;
+    const description = this.simplifyDescription(anthropicTool.description || TOOL_CONVERSION.DEFAULT_DESCRIPTION);
+    if (!anthropicTool.input_schema) {
+      throw new Error(`Invalid tool definition for ${anthropicTool.name}: missing input_schema`);
+    }
+    const parameters = {
+      type: anthropicTool.input_schema.type || "object",
+      properties: anthropicTool.input_schema.properties || {},
+      ...anthropicTool.input_schema.required && { required: anthropicTool.input_schema.required }
+    };
+    return {
       type: "function",
       function: {
-        name: toolUse.name,
-        arguments: JSON.stringify(toolUse.input || {})
+        name: openaiName,
+        description,
+        parameters
       }
-    }));
-    return assistantMessage;
+    };
   }
   /**
-   * 创建工具结果消息
-   */
-  static createToolResultMessages(toolResults, toolIdToNameMap) {
-    return toolResults.map((toolResult) => {
-      let resultContent = "No content";
-      if (toolResult.content) {
-        if (typeof toolResult.content === "string") {
-          resultContent = toolResult.content;
-        } else {
-          resultContent = JSON.stringify(toolResult.content, null, 2);
-        }
-      }
-      const toolName = toolIdToNameMap.get(toolResult.tool_use_id) || TOOL_CONVERSION.UNKNOWN_TOOL_FALLBACK;
-      return {
-        role: "tool",
-        tool_call_id: toolResult.tool_use_id,
-        name: toolName,
-        content: resultContent
-      };
-    });
-  }
-  /**
-   * 创建文本消息
-   */
-  static createTextMessage(role, textContent) {
-    if (textContent.length === 0) return null;
-    const hasNonTextContent = textContent.some((item) => item.type !== "text");
-    if (hasNonTextContent) {
-      return {
-        role,
-        content: textContent
-      };
-    } else {
-      const textOnly = textContent.map((item) => item.text || "").join("");
-      return {
-        role,
-        content: textOnly.trim() || ""
-        // 确保content为字符串，避免null
-      };
-    }
-  }
-  /**
-   * 处理系统消息
-   */
-  static processSystemMessage(system) {
-    let systemContent;
-    if (Array.isArray(system)) {
-      systemContent = system.map((s) => {
-        if (typeof s === "string") {
-          return s;
-        }
-        return s.text || "";
-      }).filter((text) => text.length > 0).join("\n").trim();
-    } else {
-      systemContent = system;
-    }
-    if (systemContent) {
-      return {
-        role: "system",
-        content: systemContent
-      };
-    }
-    return null;
-  }
-};
-
-// src/core/a2o-request-adapter/tool-converter.ts
-var ToolConverter = class {
-  /**
-   * 将Anthropic工具定义转换为OpenAI格式
-   */
-  static convertAnthropicToolToOpenAI(anthropicTool) {
-    if (!anthropicTool || !anthropicTool.name) {
-      throw new Error("Invalid tool definition: missing name");
-    }
-    const openaiName = anthropicTool.name;
-    const description = this.simplifyDescription(anthropicTool.description || TOOL_CONVERSION.DEFAULT_DESCRIPTION);
-    if (!anthropicTool.input_schema) {
-      throw new Error(`Invalid tool definition for ${anthropicTool.name}: missing input_schema`);
-    }
-    const parameters = {
-      type: anthropicTool.input_schema.type || "object",
-      properties: anthropicTool.input_schema.properties || {},
-      ...anthropicTool.input_schema.required && { required: anthropicTool.input_schema.required }
-    };
-    return {
-      type: "function",
-      function: {
-        name: openaiName,
-        description,
-        parameters
-      }
-    };
-  }
-  /**
-   * 将OpenAI工具调用转换为Claude格式
+   * 将OpenAI工具调用转换为Claude格式
    */
   static convertOpenAIToolCallsToClaude(toolCalls) {
     return toolCalls.map((toolCall) => {
@@ -1097,6 +993,24 @@ var ToolConverter = class {
   static isOpenAIToolFormat(tool) {
     return tool && tool.type === "function" && tool.function && tool.function.name;
   }
+  /**
+   * 确保OpenAI格式工具有有效描述
+   * 处理空字符串、undefined、null等情况
+   */
+  static ensureOpenAIToolDescription(tool) {
+    if (!tool?.function) return tool;
+    const description = tool.function.description?.trim();
+    if (!description) {
+      return {
+        ...tool,
+        function: {
+          ...tool.function,
+          description: TOOL_CONVERSION.DEFAULT_DESCRIPTION
+        }
+      };
+    }
+    return tool;
+  }
   /**
    * 简化Claude的详细描述为OpenAI兼容的简短描述
    */
@@ -3673,344 +3587,1204 @@ var A2ORequestAdapter = class {
       } else {
         result.data = openaiRequest;
       }
-      if (this.config.monitoring.enabled) {
-        const processingTime = Date.now() - startTime;
-        if (this.config.monitoring.logLevel !== "none") {
-          console.log(`[A2O Adapter] Conversion completed in ${processingTime}ms`, {
-            healingApplied: result.healingApplied,
-            fixesCount: result.appliedFixes?.length || 0
-          });
-        }
+      if (this.config.monitoring.enabled) {
+        const processingTime = Date.now() - startTime;
+        if (this.config.monitoring.logLevel !== "none") {
+          console.log(`[A2O Adapter] Conversion completed in ${processingTime}ms`, {
+            healingApplied: result.healingApplied,
+            fixesCount: result.appliedFixes?.length || 0
+          });
+        }
+      }
+      result.success = true;
+      return result;
+    } catch (error) {
+      result.errors.push(`Conversion failed: ${error.message}`);
+      if (this.config.recovery.enabled) {
+        result.warnings.push("Error recovery attempted but not implemented yet");
+      }
+      return result;
+    }
+  }
+  /**
+   * 执行核心转换逻辑（支持图片代理）
+   */
+  async performCoreConversion(anthropicRequest) {
+    if (this.config.enableFormatValidation) {
+      FormatValidator.validateClaudeRequest(anthropicRequest);
+    }
+    const messages = this.config.imageProxy.enabled ? await MessageConverter.convertMessagesAsync(
+      anthropicRequest.messages,
+      anthropicRequest.system,
+      true
+      // 启用图片下载
+    ) : MessageConverter.convertMessages(anthropicRequest.messages, anthropicRequest.system);
+    const openaiRequest = {
+      model: anthropicRequest.model,
+      messages,
+      max_tokens: anthropicRequest.max_tokens,
+      temperature: anthropicRequest.temperature,
+      stream: anthropicRequest.stream
+    };
+    if (anthropicRequest.tools && anthropicRequest.tools.length > 0) {
+      openaiRequest.tools = this.convertToolDefinitions(anthropicRequest.tools);
+    }
+    const specialFields = ["_anthropic_protocol", "_rovo_tool_injected", "_routeResult"];
+    for (const field of specialFields) {
+      if (anthropicRequest[field] !== void 0) {
+        openaiRequest[field] = anthropicRequest[field];
+      }
+    }
+    return openaiRequest;
+  }
+  /**
+   * 转换Anthropic请求格式为OpenAI兼容格式 - 原有方法保持兼容
+   */
+  convertAnthropicRequestToOpenAI(anthropicRequest) {
+    if (this.config.enableFormatValidation) {
+      FormatValidator.validateClaudeRequest(anthropicRequest);
+    }
+    const openaiRequest = {
+      model: anthropicRequest.model,
+      messages: MessageConverter.convertMessages(anthropicRequest.messages, anthropicRequest.system),
+      max_tokens: anthropicRequest.max_tokens,
+      temperature: anthropicRequest.temperature,
+      stream: anthropicRequest.stream,
+      n: 1
+    };
+    if (anthropicRequest.tools && anthropicRequest.tools.length > 0) {
+      openaiRequest.tools = this.convertToolDefinitions(anthropicRequest.tools);
+    }
+    const specialFields = ["_anthropic_protocol", "_rovo_tool_injected", "_routeResult"];
+    for (const field of specialFields) {
+      if (anthropicRequest[field] !== void 0) {
+        openaiRequest[field] = anthropicRequest[field];
+      }
+    }
+    if (this.config.enableFormatValidation && !FormatValidator.validateOpenAIRequest(openaiRequest)) {
+      throw new Error("Generated OpenAI request format is invalid");
+    }
+    return openaiRequest;
+  }
+  /**
+   * 转换OpenAI响应格式为Claude兼容格式
+   */
+  convertOpenAIResponseToClaude(openaiResponse) {
+    const claudeContent = [];
+    const message = openaiResponse.choices?.[0]?.message;
+    if (message?.reasoning_content) {
+      claudeContent.push({
+        type: "thinking",
+        thinking: message.reasoning_content
+      });
+    }
+    if (message?.content) {
+      claudeContent.push({
+        type: "text",
+        text: message.content
+      });
+    }
+    if (message?.tool_calls) {
+      const toolUseContents = ToolConverter.convertOpenAIToolCallsToClaude(message.tool_calls);
+      claudeContent.push(...toolUseContents);
+    }
+    const claudeResponse = {
+      role: "assistant",
+      content: claudeContent
+    };
+    return claudeResponse;
+  }
+  /**
+   * 转换工具定义列表
+   * 确保所有工具都有有效描述，无论是Anthropic还是OpenAI格式
+   */
+  convertToolDefinitions(tools) {
+    return tools.map((tool) => {
+      let openaiTool;
+      if (ToolConverter.isOpenAIToolFormat(tool)) {
+        openaiTool = tool;
+      } else {
+        openaiTool = ToolConverter.convertAnthropicToolToOpenAI(tool);
+      }
+      return ToolConverter.ensureOpenAIToolDescription(openaiTool);
+    });
+  }
+  /**
+   * 验证Claude请求格式
+   */
+  validateClaudeRequest(request) {
+    return FormatValidator.validateClaudeRequest(request);
+  }
+  /**
+   * 验证OpenAI请求格式
+   */
+  validateOpenAIRequest(request) {
+    return FormatValidator.validateOpenAIRequest(request);
+  }
+  /**
+   * 获取支持的工具列表
+   */
+  getSupportedTools() {
+    return [];
+  }
+  /**
+   * 检查工具是否支持
+   */
+  isToolSupported(_toolName) {
+    return true;
+  }
+  /**
+   * 获取工具映射（已弃用，保持兼容性）
+   */
+  getToolMapping(claudeToolName) {
+    return claudeToolName;
+  }
+  /**
+   * 更新配置
+   */
+  updateConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+  }
+  /**
+   * 获取当前配置
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * 执行带验证的核心转换（同步版本）
+   * 为静态方法提供增强功能，但保持同步特性
+   */
+  performCoreConversionWithValidation(anthropicRequest) {
+    if (this.config.validation.enabled) {
+      try {
+        validateAnthropicRequest(anthropicRequest);
+      } catch (error) {
+        if (this.config.validation.strict) {
+          throw error;
+        } else {
+          const errorSummary = this.getValidationErrorSummary(error);
+          console.warn(`[A2ORequestAdapter] Input validation warning: ${errorSummary}. Details saved to logs.`);
+        }
+      }
+    }
+    let processedRequest = anthropicRequest;
+    if (this.config.healing.enabled) {
+      try {
+        processedRequest = this.applySyncHealing(anthropicRequest);
+      } catch (healingError) {
+        console.warn("[A2ORequestAdapter] Healing failed:", healingError);
+      }
+    }
+    const result = this.performBasicConversion(processedRequest, true);
+    if (this.config.validation.enabled) {
+      try {
+        validateOpenAIRequest(result);
+      } catch (error) {
+        if (this.config.validation.strict) {
+          throw error;
+        } else {
+          console.warn("[A2ORequestAdapter] Output validation warning:", error);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 执行基础转换逻辑（原有逻辑的提取）
+   */
+  performBasicConversion(anthropicRequest, skipValidation = false) {
+    if (!skipValidation && this.config.enableFormatValidation) {
+      FormatValidator.validateClaudeRequest(anthropicRequest);
+    }
+    const openaiRequest = {
+      model: anthropicRequest.model,
+      messages: MessageConverter.convertMessages(anthropicRequest.messages, anthropicRequest.system),
+      max_tokens: anthropicRequest.max_tokens,
+      temperature: anthropicRequest.temperature,
+      stream: anthropicRequest.stream,
+      n: 1
+    };
+    if (anthropicRequest.tools && anthropicRequest.tools.length > 0) {
+      openaiRequest.tools = this.convertToolDefinitions(anthropicRequest.tools);
+    }
+    const specialFields = ["_anthropic_protocol", "_rovo_tool_injected", "_routeResult"];
+    for (const field of specialFields) {
+      if (anthropicRequest[field] !== void 0) {
+        openaiRequest[field] = anthropicRequest[field];
+      }
+    }
+    if (this.config.enableFormatValidation && !FormatValidator.validateOpenAIRequest(openaiRequest)) {
+      throw new Error("Generated OpenAI request format is invalid");
+    }
+    return openaiRequest;
+  }
+  /**
+   * 应用同步修复逻辑
+   * 简化版的修复，不依赖异步操作
+   */
+  applySyncHealing(request) {
+    const healedRequest = { ...request };
+    if (!healedRequest.max_tokens || healedRequest.max_tokens <= 0) {
+      healedRequest.max_tokens = 4096;
+    }
+    if (!healedRequest.messages || !Array.isArray(healedRequest.messages)) {
+      throw new Error("Invalid messages array");
+    }
+    if (!healedRequest.model) {
+      healedRequest.model = "claude-sonnet-4";
+    }
+    for (const message of healedRequest.messages) {
+      if (!message.role) {
+        message.role = "user";
+      }
+      if (!message.content) {
+        message.content = "";
+      }
+    }
+    return healedRequest;
+  }
+  /**
+   * 获取验证错误详情
+   */
+  getValidationErrors(request, type) {
+    return FormatValidator.getValidationErrors(request, type);
+  }
+  /**
+   * 生成简洁的验证错误摘要
+   */
+  getValidationErrorSummary(error) {
+    if (error?.issues?.length > 0) {
+      const invalidEnums = error.issues.filter((i) => i.code === "invalid_enum_value");
+      const missingFields = error.issues.filter((i) => i.code === "invalid_type");
+      const summary = [];
+      if (invalidEnums.length > 0) {
+        const first = invalidEnums[0];
+        summary.push(`invalid_${first.path?.join(".")}: '${first.received}'`);
+      }
+      if (missingFields.length > 0) {
+        summary.push(`${missingFields.length} missing fields`);
+      }
+      return summary.slice(0, 2).join(", ") + (error.issues.length > 5 ? ` (+${error.issues.length - 5} more)` : "");
+    }
+    return error.message || "Validation failed";
+  }
+};
+var A2ORequestAdapterStatic = {
+  /**
+   * 转换Anthropic请求格式为OpenAI兼容格式（静态方法）
+   * 内部使用增强转换器，所有调用点自动获得增强功能
+   */
+  convertAnthropicRequestToOpenAI: (anthropicRequest) => {
+    const adapter = new A2ORequestAdapter({
+      debugMode: false,
+      maxDescriptionLength: 100,
+      enableToolNameValidation: true,
+      enableFormatValidation: true,
+      validation: { enabled: true, strict: false },
+      healing: { enabled: true, maxAttempts: 2, enableCustomRules: true },
+      recovery: { enabled: false, maxRetries: 0, backoffMs: 1e3 },
+      monitoring: { enabled: false, logLevel: "none", enableMetrics: false }
+    });
+    try {
+      const result = adapter.performCoreConversionWithValidation(anthropicRequest);
+      return result;
+    } catch (error) {
+      console.warn(`[A2ORequestAdapterStatic] Enhanced conversion failed, using basic conversion: ${error?.message || error}`);
+      return adapter.performBasicConversion(anthropicRequest, true);
+    }
+  },
+  /**
+   * 转换OpenAI响应格式为Claude兼容格式（静态方法）
+   * 内部使用增强转换器
+   */
+  convertOpenAIResponseToClaude: (openaiResponse) => {
+    const adapter = new A2ORequestAdapter({
+      debugMode: false,
+      maxDescriptionLength: 100,
+      enableToolNameValidation: true,
+      enableFormatValidation: true,
+      validation: { enabled: true, strict: false },
+      healing: { enabled: true, maxAttempts: 2, enableCustomRules: true },
+      recovery: { enabled: false, maxRetries: 0, backoffMs: 1e3 },
+      monitoring: { enabled: false, logLevel: "none", enableMetrics: false }
+    });
+    return adapter.convertOpenAIResponseToClaude(openaiResponse);
+  },
+  /**
+   * 验证Claude请求格式（静态方法）
+   */
+  validateClaudeRequest: (request) => {
+    return FormatValidator.validateClaudeRequest(request);
+  },
+  /**
+   * 验证OpenAI请求格式（静态方法）
+   */
+  validateOpenAIRequest: (request) => {
+    return FormatValidator.validateOpenAIRequest(request);
+  },
+  /**
+   * 获取支持的工具列表（静态方法）
+   */
+  getSupportedTools: () => {
+    return [];
+  },
+  /**
+   * 检查工具是否支持（静态方法）
+   */
+  isToolSupported: (_toolName) => {
+    return true;
+  },
+  /**
+   * 获取工具映射（静态方法，已弃用）
+   */
+  getToolMapping: (claudeToolName) => {
+    return claudeToolName;
+  },
+  /**
+   * 转换Anthropic请求格式为OpenAI兼容格式（异步版本，支持图片URL自动下载）
+   * 解决GitHub Copilot等API不支持外部图片URL的问题
+   * @param anthropicRequest Claude格式的请求
+   * @param downloadImageUrls 是否下载图片URL并转换为base64（默认true）
+   */
+  convertAnthropicRequestToOpenAIAsync: async (anthropicRequest, downloadImageUrls = true) => {
+    const adapter = new A2ORequestAdapter({
+      debugMode: false,
+      maxDescriptionLength: 100,
+      enableToolNameValidation: true,
+      enableFormatValidation: true,
+      validation: { enabled: true, strict: false },
+      healing: { enabled: true, maxAttempts: 2, enableCustomRules: true },
+      recovery: { enabled: false, maxRetries: 0, backoffMs: 1e3 },
+      monitoring: { enabled: false, logLevel: "none", enableMetrics: false },
+      imageProxy: {
+        enabled: downloadImageUrls,
+        timeout: 1e4,
+        maxSize: 10 * 1024 * 1024
+      }
+    });
+    try {
+      const result = await adapter.performCoreConversion(anthropicRequest);
+      return result;
+    } catch (error) {
+      console.warn(`[A2ORequestAdapterStatic] Async conversion failed: ${error?.message || error}`);
+      return adapter.performBasicConversion(anthropicRequest, true);
+    }
+  }
+};
+
+// src/core/streaming/streaming-protocol-adapter.ts
+var StreamingProtocolAdapter = class {
+  constructor(options = {}) {
+    this.config = {
+      debugMode: options.debugMode ?? false,
+      validateInput: options.validateInput ?? false,
+      validateOutput: options.validateOutput ?? false,
+      autoHeal: options.autoHeal ?? false,
+      timeout: options.timeout ?? 3e4,
+      retries: options.retries ?? 3,
+      bufferSize: options.bufferSize ?? 1024,
+      logger: options.logger ?? getGlobalLogger()
+    };
+  }
+  logDebug(message, meta) {
+    if (this.config.debugMode) {
+      this.config.logger.debug(message, meta);
+    }
+  }
+  /**
+   * 转换Anthropic请求为OpenAI格式
+   */
+  convertAnthropicToOpenAI(anthropicRequest) {
+    const logger = this.config.logger;
+    if (this.config.debugMode) {
+      logger.debug("Converting Anthropic request to OpenAI format", { model: anthropicRequest.model });
+    }
+    const openaiRequest = A2ORequestAdapterStatic.convertAnthropicRequestToOpenAI(anthropicRequest);
+    openaiRequest.stream = true;
+    const hasImages = this.hasImageContent(anthropicRequest);
+    return {
+      openaiRequest,
+      metadata: {
+        hasImages,
+        requiresVisionHeaders: hasImages
+      }
+    };
+  }
+  /**
+   * 与StandardProtocolAdapter保持一致的API，用于集成测试和向后兼容。
+   */
+  convertRequest(anthropicRequest) {
+    return this.convertAnthropicToOpenAI(anthropicRequest);
+  }
+  /**
+   * 转换OpenAI流式响应为Anthropic SSE格式
+   */
+  convertOpenAIStreamToAnthropic(openaiStream, originalRequest) {
+    const logger = this.config.logger;
+    try {
+      if (this.config.debugMode) {
+        logger.debug("Converting OpenAI stream to Anthropic SSE", {
+          streamLength: openaiStream.length,
+          model: originalRequest.model
+        });
+      }
+      if (!openaiStream || openaiStream.trim() === "") {
+        return {
+          success: false,
+          error: "Empty stream response",
+          anthropicSSE: "",
+          anthropicStandardResponse: null
+        };
       }
-      result.success = true;
-      return result;
+      const anthropicSSE = this.convertToAnthropicSSE(openaiStream, originalRequest.model);
+      const anthropicStandardResponse = this.buildStandardResponse(openaiStream);
+      return {
+        success: true,
+        anthropicSSE,
+        anthropicStandardResponse
+      };
     } catch (error) {
-      result.errors.push(`Conversion failed: ${error.message}`);
-      if (this.config.recovery.enabled) {
-        result.warnings.push("Error recovery attempted but not implemented yet");
-      }
-      return result;
+      const errorMessage = error instanceof Error ? error.message : "Unknown conversion error";
+      logger.error("Stream conversion failed", { error: errorMessage });
+      return {
+        success: false,
+        error: errorMessage,
+        anthropicSSE: "",
+        anthropicStandardResponse: null
+      };
     }
   }
   /**
-   * 执行核心转换逻辑（原有逻辑保持不变）
+   * 增量解析Anthropic SSE，转换为OpenAI流式chunk
+   * 供 OpenAI Chat Completions 端点直接复用
    */
-  async performCoreConversion(anthropicRequest) {
-    if (this.config.enableFormatValidation) {
-      FormatValidator.validateClaudeRequest(anthropicRequest);
-    }
-    const openaiRequest = {
-      model: anthropicRequest.model,
-      messages: MessageConverter.convertMessages(anthropicRequest.messages, anthropicRequest.system),
-      max_tokens: anthropicRequest.max_tokens,
-      temperature: anthropicRequest.temperature,
-      stream: anthropicRequest.stream
+  convertAnthropicSSEChunkToOpenAI(params) {
+    const { buffer, chunk, model, flush = false } = params;
+    let localBuffer = buffer + (chunk || "");
+    const emittedChunks = [];
+    let finishReason;
+    let streamStopped = false;
+    const processEvent = (eventText) => {
+      const { eventType, data } = this.parseAnthropicSSEEvent(eventText);
+      if (!eventType || !data) {
+        return;
+      }
+      if (eventType === "content_block_delta") {
+        const text = this.extractTextFromAnthropicDelta(data);
+        if (text) {
+          emittedChunks.push(this.buildOpenAIStreamChunk(model, text));
+        }
+      } else if (eventType === "message_stop") {
+        finishReason = this.mapAnthropicStopReasonToOpenAI(data?.stop_reason);
+        streamStopped = true;
+      }
     };
-    if (anthropicRequest.tools && anthropicRequest.tools.length > 0) {
-      openaiRequest.tools = this.convertToolDefinitions(anthropicRequest.tools);
-    }
-    const specialFields = ["_anthropic_protocol", "_rovo_tool_injected", "_routeResult"];
-    for (const field of specialFields) {
-      if (anthropicRequest[field] !== void 0) {
-        openaiRequest[field] = anthropicRequest[field];
+    while (true) {
+      const separatorIndex = localBuffer.indexOf("\n\n");
+      if (separatorIndex === -1) {
+        break;
+      }
+      const rawEvent = localBuffer.slice(0, separatorIndex);
+      localBuffer = localBuffer.slice(separatorIndex + 2);
+      if (!rawEvent.trim()) {
+        continue;
+      }
+      processEvent(rawEvent);
+      if (streamStopped) {
+        break;
       }
     }
-    return openaiRequest;
+    if (flush && localBuffer.trim()) {
+      processEvent(localBuffer);
+      localBuffer = "";
+    }
+    return {
+      buffer: localBuffer,
+      chunks: emittedChunks,
+      finishReason,
+      streamStopped
+    };
   }
   /**
-   * 转换Anthropic请求格式为OpenAI兼容格式 - 原有方法保持兼容
+   * 将OpenAI流转换为Anthropic SSE格式
    */
-  convertAnthropicRequestToOpenAI(anthropicRequest) {
-    if (this.config.enableFormatValidation) {
-      FormatValidator.validateClaudeRequest(anthropicRequest);
-    }
-    const openaiRequest = {
-      model: anthropicRequest.model,
-      messages: MessageConverter.convertMessages(anthropicRequest.messages, anthropicRequest.system),
-      max_tokens: anthropicRequest.max_tokens,
-      temperature: anthropicRequest.temperature,
-      stream: anthropicRequest.stream,
-      n: 1
-    };
-    if (anthropicRequest.tools && anthropicRequest.tools.length > 0) {
-      openaiRequest.tools = this.convertToolDefinitions(anthropicRequest.tools);
-    }
-    const specialFields = ["_anthropic_protocol", "_rovo_tool_injected", "_routeResult"];
-    for (const field of specialFields) {
-      if (anthropicRequest[field] !== void 0) {
-        openaiRequest[field] = anthropicRequest[field];
+  convertToAnthropicSSE(openaiStream, modelName) {
+    const lines = openaiStream.split("\n");
+    const sseLines = [];
+    const state = this.createConversionState();
+    sseLines.push(
+      "event: message_start",
+      `data: {"type":"message_start","message":{"id":"msg_${Date.now()}","type":"message","role":"assistant","model":"${modelName}","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}}`,
+      ""
+    );
+    for (const line of lines) {
+      if (line.startsWith("data:")) {
+        const dataLine = line.substring(5);
+        if (dataLine.trim() === "[DONE]") {
+          this.addFinalEvents(state, sseLines);
+          break;
+        }
+        try {
+          const chunk = JSON.parse(dataLine);
+          this.processStreamChunk(chunk, state, sseLines);
+        } catch (error) {
+          if (this.config.debugMode) {
+            this.config.logger.warn("Failed to parse stream chunk", { line: dataLine.substring(0, 200) });
+          }
+        }
       }
     }
-    if (this.config.enableFormatValidation && !FormatValidator.validateOpenAIRequest(openaiRequest)) {
-      throw new Error("Generated OpenAI request format is invalid");
-    }
-    return openaiRequest;
+    return sseLines.join("\n");
   }
   /**
-   * 转换OpenAI响应格式为Claude兼容格式
+   * 处理单个流式数据块 - 支持thinking和content双模式
    */
-  convertOpenAIResponseToClaude(openaiResponse) {
-    const claudeContent = [];
-    const message = openaiResponse.choices?.[0]?.message;
-    if (message?.content) {
-      claudeContent.push({
-        type: "text",
-        text: message.content
-      });
+  processStreamChunk(chunk, state, sseLines) {
+    if (this.isResponsesEvent(chunk)) {
+      this.processResponsesEvent(chunk, state, sseLines);
+      return;
     }
-    if (message?.tool_calls) {
-      const toolUseContents = ToolConverter.convertOpenAIToolCallsToClaude(message.tool_calls);
-      claudeContent.push(...toolUseContents);
+    const choice = chunk.choices?.[0];
+    if (choice) {
+      const hasToolCalls = choice.delta?.tool_calls;
+      const hasFinishReason = choice.finish_reason;
+      const isNonText = !choice.delta?.content;
+      if (this.config.debugMode && (hasToolCalls || hasFinishReason || isNonText && choice.delta)) {
+        this.logDebug("Streaming chunk processed", { chunk });
+      }
     }
-    const claudeResponse = {
-      role: "assistant",
-      content: claudeContent
-    };
-    return claudeResponse;
+    if (!choice) {
+      this.updateUsageFromChunk(chunk, state);
+      return;
+    }
+    const delta = choice.delta ?? {};
+    this.appendThinkingContent(this.coalesceContent(delta.reasoning_content), state, sseLines);
+    this.appendTextContent(this.coalesceContent(delta.content), state, sseLines);
+    if (delta.tool_calls) {
+      this.processToolCalls(delta.tool_calls, state, sseLines);
+    }
+    this.updateUsageFromChunk(chunk, state);
   }
   /**
-   * 转换工具定义列表
+   * 处理工具调用 - 支持OpenAI流式分块累积
+   * OpenAI流式API会将tool_calls分多个chunk发送:
+   * - Chunk 1: {index:0, id:"call_xxx", type:"function", function:{name:"web_search"}}
+   * - Chunk 2: {index:0, function:{arguments:"{\"query\":\"xxx\"}"}}
+   * - Chunk N: 继续累积arguments
    */
-  convertToolDefinitions(tools) {
-    return tools.map((tool) => {
-      if (ToolConverter.isOpenAIToolFormat(tool)) {
-        return tool;
-      } else {
-        return ToolConverter.convertAnthropicToolToOpenAI(tool);
+  processToolCalls(toolCalls, state, sseLines) {
+    this.logDebug("processToolCalls called", { toolCalls });
+    for (const toolCall of toolCalls) {
+      const index = toolCall.index ?? 0;
+      const toolId = toolCall.id;
+      const toolName = toolCall.function?.name;
+      const toolArgs = toolCall.function?.arguments;
+      this.logDebug(`Processing tool chunk for index ${index}`, {
+        hasId: !!toolId,
+        hasName: !!toolName,
+        hasArgs: !!toolArgs,
+        argsLength: toolArgs?.length
+      });
+      const stateKey = `openai_tool_${index}`;
+      const toolData = this.getOrCreateToolCallState(state, stateKey);
+      if (toolId && !toolData.id) {
+        toolData.id = toolId;
       }
-    });
-  }
-  /**
-   * 验证Claude请求格式
-   */
-  validateClaudeRequest(request) {
-    return FormatValidator.validateClaudeRequest(request);
+      if (toolName) {
+        toolData.name = toolName;
+      }
+      this.registerToolCallAlias(state, toolId ? `openai_tool_id_${toolId}` : void 0, toolData);
+      this.registerToolCallAlias(state, `openai_tool_index_${index}`, toolData);
+      if (toolArgs) {
+        toolData.pendingChunks.push(toolArgs);
+        this.logDebug(`Accumulated tool arguments for index ${index}`, {
+          currentLength: toolData.pendingChunks.reduce((acc, chunk) => acc + chunk.length, 0)
+        });
+      }
+      const started = this.maybeStartToolBlock(toolData, state, sseLines);
+      if (started || toolData.blockStartSent) {
+        this.flushPendingToolChunks(toolData, sseLines);
+      }
+    }
   }
-  /**
-   * 验证OpenAI请求格式
-   */
-  validateOpenAIRequest(request) {
-    return FormatValidator.validateOpenAIRequest(request);
+  getOrCreateToolCallState(state, key) {
+    let existing = state.toolCallsMap.get(key);
+    if (!existing) {
+      existing = {
+        id: "",
+        name: "",
+        input: "",
+        blockStartSent: false,
+        blockStopSent: false,
+        pendingChunks: []
+      };
+      state.toolCallsMap.set(key, existing);
+    }
+    return existing;
   }
-  /**
-   * 获取支持的工具列表
-   */
-  getSupportedTools() {
-    return [];
+  registerToolCallAlias(state, alias, toolData) {
+    if (!alias) return;
+    const current = state.toolCallsMap.get(alias);
+    if (!current || current !== toolData) {
+      state.toolCallsMap.set(alias, toolData);
+    }
   }
-  /**
-   * 检查工具是否支持
-   */
-  isToolSupported(_toolName) {
+  maybeStartToolBlock(toolData, state, sseLines) {
+    if (toolData.blockStartSent) return false;
+    if (!toolData.name) {
+      return false;
+    }
+    if (!toolData.id) {
+      toolData.id = `call_${++state.toolCallCounter}`;
+    }
+    const blockIndex = toolData.blockIndex ?? state.nextToolBlockIndex++;
+    toolData.blockIndex = blockIndex;
+    sseLines.push(
+      "event: content_block_start",
+      `data: {"type":"content_block_start","index":${blockIndex},"content_block":{"type":"tool_use","id":"${this.escapeJsonString(toolData.id)}","name":"${this.escapeJsonString(toolData.name)}","input":{}}}`,
+      ""
+    );
+    toolData.blockStartSent = true;
+    this.logDebug("Sent content_block_start", { toolName: toolData.name, blockIndex });
     return true;
   }
-  /**
-   * 获取工具映射（已弃用，保持兼容性）
-   */
-  getToolMapping(claudeToolName) {
-    return claudeToolName;
+  flushPendingToolChunks(toolData, sseLines) {
+    if (!toolData.blockStartSent || toolData.blockIndex === void 0) {
+      return;
+    }
+    while (toolData.pendingChunks.length > 0) {
+      const chunk = toolData.pendingChunks.shift();
+      if (chunk === void 0) continue;
+      toolData.input += chunk;
+      sseLines.push(
+        "event: content_block_delta",
+        `data: {"type":"content_block_delta","index":${toolData.blockIndex},"delta":{"type":"input_json_delta","partial_json":${JSON.stringify(chunk)}}}`,
+        ""
+      );
+      this.logDebug("Sent input_json_delta", { blockIndex: toolData.blockIndex });
+    }
+  }
+  coalesceContent(content) {
+    if (!content) return void 0;
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content.map((item) => {
+        if (typeof item === "string") return item;
+        if (typeof item?.text === "string") return item.text;
+        if (typeof item?.content === "string") return item.content;
+        return "";
+      }).join("");
+    }
+    if (typeof content === "object" && typeof content.text === "string") {
+      return content.text;
+    }
+    return void 0;
+  }
+  appendThinkingContent(content, state, sseLines) {
+    if (!content) return;
+    state.reasoningContent += content;
+    if (!state.thinkingBlockStarted) {
+      if (state.contentBlockStarted) {
+        sseLines.push(
+          "event: content_block_stop",
+          'data: {"type":"content_block_stop","index":0}',
+          ""
+        );
+        state.contentBlockStarted = false;
+      }
+      sseLines.push(
+        "event: content_block_start",
+        'data: {"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":""}}',
+        ""
+      );
+      state.thinkingBlockStarted = true;
+    }
+    sseLines.push(
+      "event: content_block_delta",
+      `data: {"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"${this.escapeJsonString(content)}"}}`,
+      ""
+    );
   }
-  /**
-   * 更新配置
-   */
-  updateConfig(newConfig) {
-    this.config = { ...this.config, ...newConfig };
+  appendTextContent(content, state, sseLines) {
+    if (!content || content === "") return;
+    if (!state.thinkingBlockStarted && !state.contentBlockStarted && content.trim() === "") {
+      state.textContent += content;
+      return;
+    }
+    if (state.thinkingBlockStarted && !state.contentBlockStarted) {
+      sseLines.push(
+        "event: content_block_stop",
+        'data: {"type":"content_block_stop","index":0}',
+        "",
+        "event: content_block_start",
+        'data: {"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}}',
+        ""
+      );
+      state.contentBlockStarted = true;
+    } else if (!state.contentBlockStarted && !state.thinkingBlockStarted) {
+      sseLines.push(
+        "event: content_block_start",
+        'data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}',
+        ""
+      );
+      state.contentBlockStarted = true;
+    }
+    state.textContent += content;
+    const blockIndex = state.thinkingBlockStarted ? 1 : 0;
+    sseLines.push(
+      "event: content_block_delta",
+      `data: {"type":"content_block_delta","index":${blockIndex},"delta":{"type":"text_delta","text":"${this.escapeJsonString(content)}"}}`,
+      ""
+    );
   }
-  /**
-   * 获取当前配置
-   */
-  getConfig() {
-    return { ...this.config };
+  updateUsageFromChunk(chunk, state) {
+    const usage = chunk?.usage || chunk?.response?.usage;
+    if (!usage) return;
+    if (typeof usage.prompt_tokens === "number") {
+      state.usage.input_tokens = usage.prompt_tokens;
+    }
+    if (typeof usage.completion_tokens === "number") {
+      state.usage.output_tokens = usage.completion_tokens;
+    }
+    if (typeof usage.input_tokens === "number") {
+      state.usage.input_tokens = usage.input_tokens;
+    }
+    if (typeof usage.output_tokens === "number") {
+      state.usage.output_tokens = usage.output_tokens;
+    }
+  }
+  isResponsesEvent(chunk) {
+    return typeof chunk?.type === "string" && chunk.type.startsWith("response.");
+  }
+  processResponsesEvent(event, state, sseLines) {
+    this.updateUsageFromChunk(event, state);
+    switch (event.type) {
+      case "response.output_item.added":
+        this.handleResponsesOutputItemAdded(event, state, sseLines);
+        break;
+      case "response.function_call_arguments.delta":
+        this.handleResponsesFunctionArgumentsDelta(event, state, sseLines);
+        break;
+      case "response.function_call_arguments.done":
+      case "response.output_item.done":
+        this.handleResponsesFunctionArgumentsDone(event, state, sseLines);
+        break;
+      case "response.output_text.delta":
+      case "response.text.delta":
+        this.appendTextContent(this.extractResponsesTextDelta(event), state, sseLines);
+        break;
+      case "response.output_text.done":
+      case "response.text.done":
+        break;
+      case "response.thinking.delta":
+        this.appendThinkingContent(this.extractResponsesThinkingDelta(event), state, sseLines);
+        break;
+      default:
+        break;
+    }
   }
-  /**
-   * 执行带验证的核心转换（同步版本）
-   * 为静态方法提供增强功能，但保持同步特性
-   */
-  performCoreConversionWithValidation(anthropicRequest) {
-    if (this.config.validation.enabled) {
-      try {
-        validateAnthropicRequest(anthropicRequest);
-      } catch (error) {
-        if (this.config.validation.strict) {
-          throw error;
-        } else {
-          const errorSummary = this.getValidationErrorSummary(error);
-          console.warn(`[A2ORequestAdapter] Input validation warning: ${errorSummary}. Details saved to logs.`);
-        }
+  resolveResponsesToolData(identifiers, state) {
+    const aliases = [];
+    if (identifiers.call_id) aliases.push(`responses_call_${identifiers.call_id}`);
+    if (identifiers.item_id) aliases.push(`responses_item_${identifiers.item_id}`);
+    if (typeof identifiers.output_index === "number") aliases.push(`responses_index_${identifiers.output_index}`);
+    let toolData;
+    for (const alias of aliases) {
+      const existing = state.toolCallsMap.get(alias);
+      if (existing) {
+        toolData = existing;
+        break;
       }
     }
-    let processedRequest = anthropicRequest;
-    if (this.config.healing.enabled) {
-      try {
-        processedRequest = this.applySyncHealing(anthropicRequest);
-      } catch (healingError) {
-        console.warn("[A2ORequestAdapter] Healing failed:", healingError);
+    if (!toolData) {
+      const baseAlias = aliases[0] ?? `responses_auto_${++state.toolCallCounter}`;
+      toolData = this.getOrCreateToolCallState(state, baseAlias);
+      if (!aliases.length) {
+        aliases.push(baseAlias);
       }
     }
-    const result = this.performBasicConversion(processedRequest, true);
-    if (this.config.validation.enabled) {
-      try {
-        validateOpenAIRequest(result);
-      } catch (error) {
-        if (this.config.validation.strict) {
-          throw error;
-        } else {
-          console.warn("[A2ORequestAdapter] Output validation warning:", error);
-        }
-      }
+    for (const alias of aliases) {
+      this.registerToolCallAlias(state, alias, toolData);
     }
-    return result;
+    return toolData;
   }
-  /**
-   * 执行基础转换逻辑（原有逻辑的提取）
-   */
-  performBasicConversion(anthropicRequest, skipValidation = false) {
-    if (!skipValidation && this.config.enableFormatValidation) {
-      FormatValidator.validateClaudeRequest(anthropicRequest);
+  handleResponsesOutputItemAdded(event, state, sseLines) {
+    const item = event?.item;
+    if (!item) return;
+    const itemType = item.type;
+    if (itemType !== "function_call" && itemType !== "tool_call") {
+      return;
     }
-    const openaiRequest = {
-      model: anthropicRequest.model,
-      messages: MessageConverter.convertMessages(anthropicRequest.messages, anthropicRequest.system),
-      max_tokens: anthropicRequest.max_tokens,
-      temperature: anthropicRequest.temperature,
-      stream: anthropicRequest.stream,
-      n: 1
-    };
-    if (anthropicRequest.tools && anthropicRequest.tools.length > 0) {
-      openaiRequest.tools = this.convertToolDefinitions(anthropicRequest.tools);
+    const toolData = this.resolveResponsesToolData(
+      { call_id: item.call_id ?? item.id, item_id: item.id, output_index: event.output_index },
+      state
+    );
+    if (!toolData.id) {
+      toolData.id = item.call_id || item.id || `call_${++state.toolCallCounter}`;
     }
-    const specialFields = ["_anthropic_protocol", "_rovo_tool_injected", "_routeResult"];
-    for (const field of specialFields) {
-      if (anthropicRequest[field] !== void 0) {
-        openaiRequest[field] = anthropicRequest[field];
-      }
+    const name = item.name ?? item.function?.name ?? item.function_call?.name;
+    if (name) {
+      toolData.name = name;
     }
-    if (this.config.enableFormatValidation && !FormatValidator.validateOpenAIRequest(openaiRequest)) {
-      throw new Error("Generated OpenAI request format is invalid");
+    if (typeof item.arguments === "string" && item.arguments.length > 0) {
+      toolData.pendingChunks.push(item.arguments);
+    }
+    const started = this.maybeStartToolBlock(toolData, state, sseLines);
+    if (started || toolData.blockStartSent) {
+      this.flushPendingToolChunks(toolData, sseLines);
     }
-    return openaiRequest;
   }
-  /**
-   * 应用同步修复逻辑
-   * 简化版的修复，不依赖异步操作
-   */
-  applySyncHealing(request) {
-    const healedRequest = { ...request };
-    if (!healedRequest.max_tokens || healedRequest.max_tokens <= 0) {
-      healedRequest.max_tokens = 4096;
+  handleResponsesFunctionArgumentsDelta(event, state, sseLines) {
+    const toolData = this.resolveResponsesToolData(
+      { call_id: event.call_id, item_id: event.item_id, output_index: event.output_index },
+      state
+    );
+    if (!toolData.id && event.call_id) {
+      toolData.id = event.call_id;
     }
-    if (!healedRequest.messages || !Array.isArray(healedRequest.messages)) {
-      throw new Error("Invalid messages array");
+    const name = event.name ?? event.function_name ?? event.function?.name;
+    if (name) {
+      toolData.name = name;
     }
-    if (!healedRequest.model) {
-      healedRequest.model = "claude-sonnet-4";
+    const argsChunk = this.extractArgumentsDelta(event);
+    if (argsChunk) {
+      toolData.pendingChunks.push(argsChunk);
     }
-    for (const message of healedRequest.messages) {
-      if (!message.role) {
-        message.role = "user";
+    const started = this.maybeStartToolBlock(toolData, state, sseLines);
+    if (started || toolData.blockStartSent) {
+      this.flushPendingToolChunks(toolData, sseLines);
+    }
+  }
+  handleResponsesFunctionArgumentsDone(event, state, sseLines) {
+    const toolData = this.resolveResponsesToolData(
+      { call_id: event.call_id, item_id: event.item_id, output_index: event.output_index },
+      state
+    );
+    if (typeof event.arguments === "string" && event.arguments.length > 0) {
+      toolData.pendingChunks.push(event.arguments);
+    }
+    const started = this.maybeStartToolBlock(toolData, state, sseLines);
+    if (started || toolData.blockStartSent) {
+      this.flushPendingToolChunks(toolData, sseLines);
+    }
+    if (toolData.blockStartSent && !toolData.blockStopSent && toolData.blockIndex !== void 0) {
+      sseLines.push(
+        "event: content_block_stop",
+        `data: {"type":"content_block_stop","index":${toolData.blockIndex}}`,
+        ""
+      );
+      toolData.blockStopSent = true;
+      if (toolData.id && !state.completedToolCalls.includes(toolData.id)) {
+        state.completedToolCalls.push(toolData.id);
+      }
+      this.logDebug("Sent content_block_stop", { toolName: toolData.name, blockIndex: toolData.blockIndex });
+    }
+  }
+  extractResponsesTextDelta(event) {
+    if (!event) return void 0;
+    if (typeof event.delta === "string") return event.delta;
+    if (event.delta && typeof event.delta.text === "string") return event.delta.text;
+    if (typeof event.text === "string") return event.text;
+    if (Array.isArray(event.output_text)) {
+      return event.output_text.map((item) => item?.text ?? "").join("");
+    }
+    return void 0;
+  }
+  extractResponsesThinkingDelta(event) {
+    if (!event) return void 0;
+    if (typeof event.delta === "string") return event.delta;
+    if (event.delta && typeof event.delta.thinking === "string") return event.delta.thinking;
+    if (typeof event.text === "string") return event.text;
+    return void 0;
+  }
+  extractArgumentsDelta(event) {
+    if (!event) return void 0;
+    if (typeof event.delta === "string") return event.delta;
+    if (event.delta && typeof event.delta.arguments === "string") return event.delta.arguments;
+    if (typeof event.arguments_delta === "string") return event.arguments_delta;
+    if (typeof event.arguments === "string") return event.arguments;
+    if (typeof event.partial_json === "string") return event.partial_json;
+    return void 0;
+  }
+  /**
+   * 在流结束时关闭所有未关闭的工具调用块
+   */
+  closeAllToolCallBlocks(state, sseLines) {
+    const processed = /* @__PURE__ */ new Set();
+    for (const toolData of state.toolCallsMap.values()) {
+      if (processed.has(toolData)) continue;
+      processed.add(toolData);
+      if (!toolData.blockStartSent && toolData.pendingChunks.length > 0) {
+        if (!toolData.name) {
+          toolData.name = "unknown_tool";
+        }
+        const started = this.maybeStartToolBlock(toolData, state, sseLines);
+        if (started) {
+          this.flushPendingToolChunks(toolData, sseLines);
+        }
       }
-      if (!message.content) {
-        message.content = "";
+      if (toolData.blockStartSent && !toolData.blockStopSent && toolData.blockIndex !== void 0) {
+        this.flushPendingToolChunks(toolData, sseLines);
+        sseLines.push(
+          "event: content_block_stop",
+          `data: {"type":"content_block_stop","index":${toolData.blockIndex}}`,
+          ""
+        );
+        toolData.blockStopSent = true;
+        if (toolData.id && !state.completedToolCalls.includes(toolData.id)) {
+          state.completedToolCalls.push(toolData.id);
+        }
+        this.logDebug("Sent content_block_stop", { toolName: toolData.name, blockIndex: toolData.blockIndex });
       }
     }
-    return healedRequest;
   }
   /**
-   * 获取验证错误详情
+   * 添加最终事件 - 支持thinking+content双模式
    */
-  getValidationErrors(request, type) {
-    return FormatValidator.getValidationErrors(request, type);
+  addFinalEvents(state, sseLines) {
+    this.closeAllToolCallBlocks(state, sseLines);
+    if (state.contentBlockStarted) {
+      const blockIndex = state.thinkingBlockStarted ? 1 : 0;
+      sseLines.push(
+        "event: content_block_stop",
+        `data: {"type":"content_block_stop","index":${blockIndex}}`,
+        ""
+      );
+    } else if (state.thinkingBlockStarted) {
+      sseLines.push(
+        "event: content_block_stop",
+        'data: {"type":"content_block_stop","index":0}',
+        ""
+      );
+    }
+    const stopReason = state.completedToolCalls.length > 0 ? "tool_use" : "end_turn";
+    const usagePayload = state.usage.input_tokens > 0 ? `{"input_tokens":${state.usage.input_tokens},"output_tokens":${state.usage.output_tokens}}` : `{"output_tokens":${state.usage.output_tokens}}`;
+    sseLines.push(
+      "event: message_delta",
+      `data: {"type":"message_delta","delta":{"stop_reason":"${stopReason}","stop_sequence":null},"usage":${usagePayload}}`,
+      "",
+      "event: message_stop",
+      'data: {"type":"message_stop"}',
+      ""
+    );
   }
   /**
-   * 生成简洁的验证错误摘要
+   * 构建标准响应格式
    */
-  getValidationErrorSummary(error) {
-    if (error?.issues?.length > 0) {
-      const invalidEnums = error.issues.filter((i) => i.code === "invalid_enum_value");
-      const missingFields = error.issues.filter((i) => i.code === "invalid_type");
-      const summary = [];
-      if (invalidEnums.length > 0) {
-        const first = invalidEnums[0];
-        summary.push(`invalid_${first.path?.join(".")}: '${first.received}'`);
-      }
-      if (missingFields.length > 0) {
-        summary.push(`${missingFields.length} missing fields`);
+  buildStandardResponse(openaiStream) {
+    const state = this.createConversionState();
+    const lines = openaiStream.split("\n");
+    const noopSseLines = [];
+    for (const line of lines) {
+      if (line.startsWith("data:")) {
+        const dataLine = line.startsWith("data: ") ? line.substring(6) : line.substring(5);
+        if (dataLine.trim() === "[DONE]") break;
+        try {
+          const chunk = JSON.parse(dataLine);
+          noopSseLines.length = 0;
+          this.processStreamChunk(chunk, state, noopSseLines);
+        } catch (error) {
+        }
       }
-      return summary.slice(0, 2).join(", ") + (error.issues.length > 5 ? ` (+${error.issues.length - 5} more)` : "");
     }
-    return error.message || "Validation failed";
+    const stopReason = state.completedToolCalls.length > 0 ? "tool_use" : "end_turn";
+    return {
+      id: `msg_${Date.now()}`,
+      type: "message",
+      role: "assistant",
+      content: state.textContent ? [
+        {
+          type: "text",
+          text: state.textContent
+        }
+      ] : [],
+      model: "claude-3-sonnet-20240229",
+      stop_reason: stopReason,
+      stop_sequence: null,
+      usage: state.usage
+    };
   }
-};
-var A2ORequestAdapterStatic = {
   /**
-   * 转换Anthropic请求格式为OpenAI兼容格式（静态方法）
-   * 内部使用增强转换器，所有调用点自动获得增强功能
+   * 创建转换状态对象
    */
-  convertAnthropicRequestToOpenAI: (anthropicRequest) => {
-    const adapter = new A2ORequestAdapter({
-      debugMode: false,
-      maxDescriptionLength: 100,
-      enableToolNameValidation: true,
-      enableFormatValidation: true,
-      validation: { enabled: true, strict: false },
-      healing: { enabled: true, maxAttempts: 2, enableCustomRules: true },
-      recovery: { enabled: false, maxRetries: 0, backoffMs: 1e3 },
-      monitoring: { enabled: false, logLevel: "none", enableMetrics: false }
-    });
-    try {
-      const result = adapter.performCoreConversionWithValidation(anthropicRequest);
-      return result;
-    } catch (error) {
-      console.warn(`[A2ORequestAdapterStatic] Enhanced conversion failed, using basic conversion: ${error?.message || error}`);
-      return adapter.performBasicConversion(anthropicRequest, true);
+  createConversionState() {
+    return {
+      processedLines: 0,
+      textContent: "",
+      reasoningContent: "",
+      toolCallsMap: /* @__PURE__ */ new Map(),
+      completedToolCalls: [],
+      allSSELines: [],
+      errors: [],
+      usage: {
+        input_tokens: 0,
+        output_tokens: 0
+      },
+      thinkingBlockStarted: false,
+      contentBlockStarted: false,
+      toolCallCounter: 0,
+      nextToolBlockIndex: 1
+    };
+  }
+  parseAnthropicSSEEvent(rawEvent) {
+    const lines = rawEvent.split("\n");
+    let eventType = null;
+    const dataLines = [];
+    for (const line of lines) {
+      if (line.startsWith("event:")) {
+        eventType = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        dataLines.push(line.slice(5).trim());
+      }
     }
-  },
+    const dataString = dataLines.join("\n");
+    let data = null;
+    if (dataString) {
+      try {
+        data = JSON.parse(dataString);
+      } catch (error) {
+        this.logDebug("Failed to parse Anthropic SSE JSON", { error });
+      }
+    }
+    return { eventType, data };
+  }
+  extractTextFromAnthropicDelta(data) {
+    const delta = data?.delta;
+    if (!delta) return null;
+    if (typeof delta.text === "string") {
+      return delta.text;
+    }
+    if (delta.type === "text_delta" && typeof delta.text === "string") {
+      return delta.text;
+    }
+    return null;
+  }
+  mapAnthropicStopReasonToOpenAI(reason) {
+    switch (reason) {
+      case "max_tokens":
+        return "length";
+      case "tool_use":
+        return "tool_calls";
+      case "stop_sequence":
+      case "end_turn":
+      default:
+        return "stop";
+    }
+  }
+  buildOpenAIStreamChunk(model, content, finishReason = null) {
+    return {
+      id: `chatcmpl-${Date.now()}`,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1e3),
+      model,
+      choices: [{
+        index: 0,
+        delta: content ? { content } : {},
+        finish_reason: finishReason
+      }]
+    };
+  }
   /**
-   * 转换OpenAI响应格式为Claude兼容格式（静态方法）
-   * 内部使用增强转换器
+   * 转换消息格式
    */
-  convertOpenAIResponseToClaude: (openaiResponse) => {
-    const adapter = new A2ORequestAdapter({
-      debugMode: false,
-      maxDescriptionLength: 100,
-      enableToolNameValidation: true,
-      enableFormatValidation: true,
-      validation: { enabled: true, strict: false },
-      healing: { enabled: true, maxAttempts: 2, enableCustomRules: true },
-      recovery: { enabled: false, maxRetries: 0, backoffMs: 1e3 },
-      monitoring: { enabled: false, logLevel: "none", enableMetrics: false }
-    });
-    return adapter.convertOpenAIResponseToClaude(openaiResponse);
-  },
+  convertMessages(messages) {
+    return messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content
+    }));
+  }
+  /**
+   * 映射Anthropic模型到OpenAI模型
+   */
+  mapAnthropicModelToOpenAI(model) {
+    const supportedModels = [
+      "glm-4.5",
+      "kimi-k2",
+      "deepseek-v3.1",
+      "deepseek-r1",
+      "deepseek-v3",
+      "qwen3-32b",
+      "qwen3-coder",
+      "qwen3-235b",
+      "tstars2.0"
+    ];
+    if (supportedModels.includes(model)) {
+      return model;
+    }
+    const mapping = {
+      "claude-3-sonnet-20240229": "glm-4.5",
+      "claude-3-haiku-20240307": "kimi-k2",
+      "claude-3-opus-20240229": "deepseek-v3.1"
+    };
+    return mapping[model] || "glm-4.5";
+  }
   /**
-   * 验证Claude请求格式（静态方法）
+   * 检查请求是否包含图片内容
    */
-  validateClaudeRequest: (request) => {
-    return FormatValidator.validateClaudeRequest(request);
-  },
+  hasImageContent(request) {
+    return request.messages.some(
+      (msg) => Array.isArray(msg.content) && msg.content.some((content) => content?.type === "image")
+    );
+  }
   /**
-   * 验证OpenAI请求格式（静态方法）
+   * 转义JSON字符串
    */
-  validateOpenAIRequest: (request) => {
-    return FormatValidator.validateOpenAIRequest(request);
-  },
+  escapeJsonString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  }
   /**
-   * 获取支持的工具列表（静态方法）
+   * 获取初始SSE事件（message_start + ping）
    */
-  getSupportedTools: () => {
-    return [];
-  },
+  getInitialSSEEvents(modelName = "claude-sonnet-4", messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`) {
+    return [
+      "event: message_start",
+      `data: {"type":"message_start","message":{"id":"${messageId}","type":"message","role":"assistant","model":"${modelName}","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}}`,
+      "",
+      "event: ping",
+      'data: {"type":"ping"}',
+      ""
+    ];
+  }
   /**
-   * 检查工具是否支持（静态方法）
+   * 增量转换单个OpenAI数据块为Anthropic SSE事件
+   * 用于逐个处理流式数据片段
    */
-  isToolSupported: (_toolName) => {
-    return true;
-  },
+  convertIncrementalChunk(openaiDataLine, state) {
+    const logger = this.config.logger;
+    const sseEvents = [];
+    state.processedLines += 1;
+    if (openaiDataLine.trim() === "[DONE]") {
+      this.addFinalEvents(state, sseEvents);
+      state.allSSELines.push(...sseEvents);
+      return sseEvents;
+    }
+    try {
+      const chunk = JSON.parse(openaiDataLine);
+      this.processStreamChunk(chunk, state, sseEvents);
+      if (sseEvents.length > 0) {
+        state.allSSELines.push(...sseEvents);
+      }
+      return sseEvents;
+    } catch (error) {
+      if (this.config.debugMode) {
+        logger.warn("Failed to parse OpenAI stream chunk in convertIncrementalChunk", {
+          line: openaiDataLine.substring(0, 200),
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      state.errors.push({
+        error: error instanceof Error ? error.message : String(error),
+        raw: openaiDataLine
+      });
+      return [];
+    }
+  }
   /**
-   * 获取工具映射（静态方法，已弃用）
+   * 暴露内部状态创建方法，供外部增量处理流程使用。
    */
-  getToolMapping: (claudeToolName) => {
-    return claudeToolName;
+  createIncrementalState() {
+    return this.createConversionState();
   }
 };
 
@@ -4151,15 +4925,36 @@ var ToolCallProcessor = class _ToolCallProcessor {
    * 处理增量工具调用
    */
   static processIncrementalToolCalls(toolCalls, state, sseLines) {
+    const debugEnabled = process.env.AI_PROTOCOL_DEBUG === "true";
+    if (debugEnabled) {
+      console.debug("[ToolProcessor] processIncrementalToolCalls called with:", JSON.stringify(toolCalls, null, 2));
+    }
     for (const toolCall of toolCalls) {
       const toolId = toolCall.id;
       const toolName = toolCall.function?.name;
       const toolArgs = toolCall.function?.arguments;
+      if (debugEnabled) {
+        console.debug("[ToolProcessor] Processing tool call:", {
+          toolId,
+          toolName,
+          hasArgs: !!toolArgs
+        });
+      }
       if (toolName && toolId && !state.toolCallsMap.has(toolId)) {
+        if (debugEnabled) {
+          console.debug("[ToolProcessor] Starting new tool call:", toolName);
+        }
         _ToolCallProcessor.processToolCallStart(toolId, toolName, state, sseLines);
       }
       if (toolArgs) {
+        if (debugEnabled) {
+          console.debug("[ToolProcessor] Processing tool args, calling processToolArgs");
+        }
         _ToolCallProcessor.processToolArgs(toolId, toolArgs, state, sseLines);
+      } else if (toolName && toolId) {
+        _ToolCallProcessor.processToolArgs(toolId, "", state, sseLines);
+      } else {
+        console.warn("\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F [ToolProcessor] No tool args to process! This will result in empty input!");
       }
     }
   }
@@ -4167,15 +4962,36 @@ var ToolCallProcessor = class _ToolCallProcessor {
    * 处理工具调用
    */
   static processBatchToolCalls(toolCalls, state, sseLines) {
+    const debugEnabled = process.env.AI_PROTOCOL_DEBUG === "true";
+    if (debugEnabled) {
+      console.debug("[ToolProcessor] processBatchToolCalls called with:", JSON.stringify(toolCalls, null, 2));
+    }
     for (const toolCall of toolCalls) {
       const toolId = toolCall.id;
       const toolName = toolCall.function?.name;
       const toolArgs = toolCall.function?.arguments;
+      if (debugEnabled) {
+        console.debug("[ToolProcessor] Processing batch tool call:", {
+          toolId,
+          toolName,
+          hasArgs: !!toolArgs
+        });
+      }
       if (toolName && toolId && !state.toolCallsMap.has(toolId)) {
+        if (debugEnabled) {
+          console.debug("[ToolProcessor] Starting new batch tool call:", toolName);
+        }
         _ToolCallProcessor.processToolCallStart(toolId, toolName, state, sseLines);
       }
       if (toolArgs) {
+        if (debugEnabled) {
+          console.debug("[ToolProcessor] Processing batch tool args, calling processToolArgs");
+        }
         _ToolCallProcessor.processToolArgs(toolId, toolArgs, state, sseLines);
+      } else if (toolName && toolId) {
+        _ToolCallProcessor.processToolArgs(toolId, "", state, sseLines);
+      } else {
+        console.warn("\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F [ToolProcessor] No batch tool args to process! This will result in empty input!");
       }
     }
   }
@@ -4262,9 +5078,10 @@ var StreamingStateManager = class {
     return {
       hasContent: false,
       hasThinking: false,
-      contentBlockIndex: 0,
-      thinkingBlockIndex: 1,
-      // thinking block在content block之后
+      contentBlockIndex: 1,
+      // 🔧 修复：text block 在 thinking 之后 (index 1)
+      thinkingBlockIndex: 0,
+      // 🔧 修复：thinking block 先发送 (index 0)
       toolCallsMap: /* @__PURE__ */ new Map(),
       completedToolCalls: /* @__PURE__ */ new Set(),
       accumulatedUsage: {
@@ -4280,6 +5097,9 @@ var StreamingStateManager = class {
    * 处理文本内容
    */
   static processTextContent(content, state, sseLines) {
+    if (!state.hasThinking && !state.hasContent && content.trim() === "") {
+      return;
+    }
     if (!state.hasContent) {
       sseLines.push(...SSEEventGenerator.generateTextBlockStart(state.contentBlockIndex));
       state.hasContent = true;
@@ -4373,6 +5193,247 @@ function generateMessageId() {
   return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
 }
 
+// src/core/o2a-sse-adapter/stream-converter.ts
+var StreamConverter = class {
+  constructor(adapter, options = {}) {
+    this.buffer = "";
+    this.adapter = adapter;
+    this.options = {
+      bufferTimeout: 5e3,
+      errorRecovery: true,
+      maxRetries: 3,
+      debug: false,
+      ...options
+    };
+    this.state = this.adapter.createIncrementalState();
+    this.stats = {
+      chunksProcessed: 0,
+      eventsGenerated: 0,
+      errors: 0,
+      retries: 0,
+      startTime: Date.now(),
+      lastUpdateTime: Date.now(),
+      bufferSize: 0
+    };
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u5DF2\u521D\u59CB\u5316\uFF0C\u914D\u7F6E:", this.options);
+    }
+  }
+  /**
+   * 获取初始事件
+   */
+  getInitialEvents() {
+    const events = this.adapter.getInitialSSEEvents(
+      this.options.modelName,
+      this.options.messageId
+    );
+    this.stats.eventsGenerated += events.length;
+    this.stats.lastUpdateTime = Date.now();
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u751F\u6210\u521D\u59CB\u4E8B\u4EF6:", events.length, "\u4E2A");
+    }
+    return events;
+  }
+  /**
+   * 处理单个数据块
+   */
+  processChunk(chunk) {
+    this.stats.chunksProcessed++;
+    this.stats.lastUpdateTime = Date.now();
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u5904\u7406\u6570\u636E\u5757:", chunk.substring(0, 100) + "...");
+    }
+    try {
+      const events = this.processBufferedData(chunk);
+      this.stats.eventsGenerated += events.length;
+      if (this.options.onChunkProcessed) {
+        this.options.onChunkProcessed(chunk, events);
+      }
+      return events;
+    } catch (error) {
+      return this.handleChunkError(error, chunk);
+    }
+  }
+  /**
+   * 结束流处理
+   */
+  finalize() {
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u7ED3\u675F\u6D41\u5904\u7406\uFF0C\u7F13\u51B2\u533A\u5927\u5C0F:", this.buffer.length);
+    }
+    let events = [];
+    if (this.buffer.trim()) {
+      console.warn("[StreamConverter] \u7F13\u51B2\u533A\u4E2D\u6709\u672A\u5904\u7406\u6570\u636E\uFF0C\u5F3A\u5236\u5904\u7406:", this.buffer);
+      events = this.processIncompleteBuffer();
+    }
+    try {
+      const finalEvents = this.adapter.convertIncrementalChunk("[DONE]", this.state);
+      events.push(...finalEvents);
+      this.stats.eventsGenerated += finalEvents.length;
+    } catch (error) {
+      console.error("[StreamConverter] \u5904\u7406\u7ED3\u675F\u4E8B\u4EF6\u5931\u8D25:", error);
+    }
+    this.clearBufferTimeout();
+    this.stats.lastUpdateTime = Date.now();
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u6D41\u5904\u7406\u5B8C\u6210\uFF0C\u7EDF\u8BA1\u4FE1\u606F:", this.stats);
+    }
+    return events;
+  }
+  /**
+   * 获取当前状态
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * 重置状态
+   */
+  reset() {
+    this.state = this.adapter.createIncrementalState();
+    this.buffer = "";
+    this.clearBufferTimeout();
+    this.stats = {
+      chunksProcessed: 0,
+      eventsGenerated: 0,
+      errors: 0,
+      retries: 0,
+      startTime: Date.now(),
+      lastUpdateTime: Date.now(),
+      bufferSize: 0
+    };
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u72B6\u6001\u5DF2\u91CD\u7F6E");
+    }
+  }
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      bufferSize: this.buffer.length
+    };
+  }
+  /**
+   * 处理缓冲的数据
+   */
+  processBufferedData(newChunk) {
+    this.buffer += newChunk;
+    this.stats.bufferSize = this.buffer.length;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || "";
+    const events = [];
+    for (const line of lines) {
+      if (line.startsWith("data:")) {
+        const jsonStr = line.slice(5).trim();
+        if (jsonStr && jsonStr !== "[DONE]") {
+          const lineEvents = this.processDataLine(jsonStr);
+          events.push(...lineEvents);
+        } else if (jsonStr === "[DONE]") {
+          const finalEvents = this.adapter.convertIncrementalChunk("[DONE]", this.state);
+          events.push(...finalEvents);
+        }
+      }
+    }
+    this.resetBufferTimeout();
+    return events;
+  }
+  /**
+   * 处理单行数据
+   */
+  processDataLine(jsonStr, attempt = 0) {
+    try {
+      const chunkEvents = this.adapter.convertIncrementalChunk(jsonStr, this.state);
+      if (this.options.debug && chunkEvents.length > 0) {
+        console.log("[StreamConverter] \u751F\u6210\u4E8B\u4EF6:", chunkEvents.length, "\u4E2A");
+      }
+      return chunkEvents;
+    } catch (error) {
+      if (this.options.errorRecovery && attempt < (this.options.maxRetries || 3)) {
+        console.warn(`[StreamConverter] \u5904\u7406\u6570\u636E\u884C\u5931\u8D25\uFF0C\u91CD\u8BD5 ${attempt + 1}/${this.options.maxRetries}:`, error);
+        this.stats.retries++;
+        return this.processDataLine(jsonStr, attempt + 1);
+      }
+      this.stats.errors++;
+      console.error("[StreamConverter] \u5904\u7406\u6570\u636E\u884C\u6700\u7EC8\u5931\u8D25:", error, "Data:", jsonStr);
+      if (this.options.onError) {
+        this.options.onError(error, {
+          chunk: jsonStr,
+          state: this.state,
+          attempt,
+          totalRetries: this.stats.retries
+        });
+      }
+      return [];
+    }
+  }
+  /**
+   * 处理块错误
+   */
+  handleChunkError(error, chunk) {
+    this.stats.errors++;
+    if (this.options.debug) {
+      console.error("[StreamConverter] \u5757\u5904\u7406\u9519\u8BEF:", error.message);
+    }
+    if (!this.options.errorRecovery) {
+      throw error;
+    }
+    this.state.errors.push(`Chunk processing error: ${error.message}`);
+    if (this.options.onError) {
+      this.options.onError(error, {
+        chunk,
+        state: this.state,
+        totalRetries: this.stats.retries
+      });
+    }
+    return [];
+  }
+  /**
+   * 处理不完整的缓冲区数据
+   */
+  processIncompleteBuffer() {
+    if (!this.buffer.trim()) {
+      return [];
+    }
+    console.warn("[StreamConverter] \u5904\u7406\u4E0D\u5B8C\u6574\u7F13\u51B2\u533A\u6570\u636E:", this.buffer);
+    if (this.buffer.startsWith("data:")) {
+      const jsonStr = this.buffer.slice(5).trim();
+      if (jsonStr) {
+        return this.processDataLine(jsonStr);
+      }
+    }
+    return [];
+  }
+  /**
+   * 重置缓冲区超时
+   */
+  resetBufferTimeout() {
+    this.clearBufferTimeout();
+    if (this.options.bufferTimeout && this.options.bufferTimeout > 0) {
+      this.bufferTimeout = setTimeout(() => {
+        if (this.buffer.trim()) {
+          console.warn("[StreamConverter] \u7F13\u51B2\u533A\u8D85\u65F6\uFF0C\u5F3A\u5236\u5904\u7406\u6570\u636E:", this.buffer);
+          const events = this.processIncompleteBuffer();
+          this.buffer = "";
+          if (events.length > 0 && this.options.onChunkProcessed) {
+            this.options.onChunkProcessed("TIMEOUT_FLUSH", events);
+          }
+        }
+      }, this.options.bufferTimeout);
+    }
+  }
+  /**
+   * 清理缓冲区超时
+   */
+  clearBufferTimeout() {
+    if (this.bufferTimeout) {
+      clearTimeout(this.bufferTimeout);
+      this.bufferTimeout = void 0;
+    }
+  }
+};
+
 // src/core/o2a-sse-adapter/adapter.ts
 var O2ASSEAdapter = class {
   constructor(debugMode = false, config = {}) {
@@ -4544,6 +5605,17 @@ var O2ASSEAdapter = class {
       }
       try {
         const data = JSON.parse(dataContent);
+        if ((data.choices?.length === 0 || !data.choices) && data.prompt_filter_results) {
+          if (this.debugMode) {
+            console.warn("\u26A0\uFE0F [O2ASSEAdapter] \u68C0\u6D4B\u5230Azure\u5185\u5BB9\u8FC7\u6EE4\u5668\u54CD\u5E94:", data.prompt_filter_results);
+          }
+          StreamingStateManager.processTextContent(
+            `\u9519\u8BEF\uFF1A\u5185\u5BB9\u8FC7\u6EE4\u5668\u62E6\u622A\u4E86\u8BF7\u6C42\u3002\u8BF7\u68C0\u67E5\u8F93\u5165\u5185\u5BB9\u662F\u5426\u7B26\u5408\u4F7F\u7528\u653F\u7B56\u3002`,
+            state,
+            sseLines
+          );
+          break;
+        }
         const choice = data.choices?.[0];
         const delta = choice?.delta;
         if (!delta) {
@@ -4558,6 +5630,11 @@ var O2ASSEAdapter = class {
         if (delta.content) {
           StreamingStateManager.processTextContent(delta.content, state, sseLines);
         }
+        if (delta.reasoning_content) {
+          if (typeof delta.reasoning_content === "string") {
+            StreamingStateManager.processReasoningContent(delta.reasoning_content, state, sseLines);
+          }
+        }
         if (delta.tool_calls) {
           ToolCallProcessor.processBatchToolCalls(delta.tool_calls, state, sseLines);
         }
@@ -4587,6 +5664,19 @@ var O2ASSEAdapter = class {
   processNonStreamingResponse(data, state, sseLines) {
     const choice = data.choices?.[0];
     if (!choice) {
+      if (data.prompt_filter_results || data.choices?.length === 0) {
+        const errorMsg = "Azure\u5185\u5BB9\u8FC7\u6EE4\u5668\u62E6\u622A\u4E86\u8BF7\u6C42";
+        const filterDetails = data.prompt_filter_results ? JSON.stringify(data.prompt_filter_results).substring(0, 500) : "choices\u4E3A\u7A7A";
+        if (this.debugMode) {
+          console.warn(`\u26A0\uFE0F [O2ASSEAdapter] ${errorMsg}:`, filterDetails);
+        }
+        StreamingStateManager.processTextContent(
+          `\u9519\u8BEF\uFF1A\u5185\u5BB9\u8FC7\u6EE4\u5668\u62E6\u622A\u4E86\u8BF7\u6C42\u3002\u8BF7\u68C0\u67E5\u8F93\u5165\u5185\u5BB9\u662F\u5426\u7B26\u5408\u4F7F\u7528\u653F\u7B56\u3002`,
+          state,
+          sseLines
+        );
+        return;
+      }
       if (this.debugMode) {
         console.warn("\u26A0\uFE0F [O2ASSEAdapter] \u975E\u6D41\u5F0F\u54CD\u5E94\u6CA1\u6709choices\u6570\u636E");
       }
@@ -4627,6 +5717,101 @@ var O2ASSEAdapter = class {
   validateClaudeSSE(sseContent) {
     return FormatValidator2.validateClaudeSSE(sseContent);
   }
+  /**
+   * 将 OpenAI Response 流直接转换为 Anthropic SSE 流
+   * 这是新增的核心流式处理方法，支持实时转换
+   */
+  convertResponseStream(openaiResponse, options = {}) {
+    if (!openaiResponse.body) {
+      throw new Error("Response body is null or undefined");
+    }
+    return this.convertReadableStream(openaiResponse.body, options);
+  }
+  /**
+   * 将 ReadableStream 转换为 Anthropic SSE 流
+   */
+  convertReadableStream(openaiStream, options = {}) {
+    const converter = this.createStreamConverter(options);
+    const decoder = new TextDecoder();
+    return new ReadableStream({
+      async start(controller) {
+        if (options.debug) {
+          console.log("[O2ASSEAdapter] \u5F00\u59CB\u6D41\u5F0F\u8F6C\u6362\uFF0C\u914D\u7F6E:", options);
+        }
+        try {
+          const initialEvents = converter.getInitialEvents();
+          for (const event of initialEvents) {
+            controller.enqueue(event);
+          }
+        } catch (error) {
+          console.error("[O2ASSEAdapter] \u521D\u59CB\u5316\u5931\u8D25:", error);
+          controller.error(error);
+          return;
+        }
+        const reader = openaiStream.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              try {
+                const finalEvents = converter.finalize();
+                for (const event of finalEvents) {
+                  controller.enqueue(event);
+                }
+                if (options.debug) {
+                  console.log("[O2ASSEAdapter] \u6D41\u5F0F\u8F6C\u6362\u5B8C\u6210\uFF0C\u7EDF\u8BA1:", converter.getStats());
+                }
+              } catch (error) {
+                console.error("[O2ASSEAdapter] \u7ED3\u675F\u5904\u7406\u5931\u8D25:", error);
+              }
+              break;
+            }
+            const chunk = decoder.decode(value, { stream: true });
+            try {
+              const events = converter.processChunk(chunk);
+              for (const event of events) {
+                controller.enqueue(event);
+              }
+            } catch (error) {
+              console.error("[O2ASSEAdapter] \u5757\u5904\u7406\u5931\u8D25:", error);
+              if (options.errorRecovery === false) {
+                controller.error(error);
+                return;
+              }
+              if (options.onError) {
+                options.onError(error, {
+                  chunk,
+                  state: converter.getState()
+                });
+              }
+            }
+          }
+        } catch (error) {
+          console.error("[O2ASSEAdapter] \u6D41\u5904\u7406\u5931\u8D25:", error);
+          if (options.onError) {
+            options.onError(error, {
+              chunk: "",
+              state: converter.getState()
+            });
+          }
+          controller.error(error);
+        } finally {
+          controller.close();
+        }
+      }
+    });
+  }
+  /**
+   * 创建流式转换器实例
+   * 提供更精细的流处理控制
+   */
+  createStreamConverter(options = {}) {
+    return new StreamConverter(this, {
+      modelName: options.modelName || this.config.defaultModel,
+      debug: options.debug || this.debugMode,
+      ...options
+    });
+  }
   /**
    * 应用增强功能到SSE转换
    * 包括输入验证、输出修复等
@@ -4698,15 +5883,56 @@ var O2ASSEAdapterStatic = {
   validateClaudeSSE: (sseContent) => {
     const adapter = new O2ASSEAdapter(false);
     return adapter.validateClaudeSSE(sseContent);
+  },
+  /**
+   * 转换 Response 流为 Anthropic SSE（静态方法）
+   * 新增：直接处理 Response 对象的流式转换
+   */
+  convertResponseStream: (openaiResponse, options = {}) => {
+    const adapter = new O2ASSEAdapter(options.debug || false, {
+      defaultModel: options.modelName || "claude-sonnet-4",
+      generateUniqueMessageId: !options.messageId,
+      errorDataMaxLength: 500
+    });
+    return adapter.convertResponseStream(openaiResponse, options);
+  },
+  /**
+   * 转换 ReadableStream 为 Anthropic SSE（静态方法）
+   * 新增：处理任意 ReadableStream<Uint8Array> 的流式转换
+   */
+  convertReadableStream: (openaiStream, options = {}) => {
+    const adapter = new O2ASSEAdapter(options.debug || false, {
+      defaultModel: options.modelName || "claude-sonnet-4",
+      generateUniqueMessageId: !options.messageId,
+      errorDataMaxLength: 500
+    });
+    return adapter.convertReadableStream(openaiStream, options);
+  },
+  /**
+   * 创建流式转换器（静态方法）
+   * 新增：提供更精细的流处理控制
+   */
+  createStreamConverter: (options = {}) => {
+    const adapter = new O2ASSEAdapter(options.debug || false, {
+      defaultModel: options.modelName || "claude-sonnet-4",
+      generateUniqueMessageId: !options.messageId,
+      errorDataMaxLength: 500
+    });
+    return adapter.createStreamConverter(options);
   }
 };
 
 // src/core/standard/standard-protocol-adapter.ts
 var StandardProtocolAdapter = class {
   constructor(options = {}) {
-    this.debugMode = options.debugMode || false;
+    this.debugMode = options.debugMode ?? process.env.AI_PROTOCOL_DEBUG === "true";
     this.sseAdapter = new O2ASSEAdapter(this.debugMode);
   }
+  logDebug(message, meta) {
+    if (this.debugMode) {
+      console.debug(message, meta ?? "");
+    }
+  }
   /**
    * 转换Anthropic请求为OpenAI请求格式
    * @param anthropicRequest - Anthropic格式的请求
@@ -4730,7 +5956,7 @@ var StandardProtocolAdapter = class {
    */
   convertFromStreamToStandard(openaiRawStream, modelName, messageId) {
     if (this.debugMode) {
-      console.log("\u{1F504} [StandardProtocolAdapter] convertFromStreamToStandard \u5F00\u59CB\u5904\u7406:", {
+      this.logDebug("\u{1F504} [StandardProtocolAdapter] convertFromStreamToStandard \u5F00\u59CB\u5904\u7406:", {
         rawStreamLength: openaiRawStream.length,
         modelName,
         messageId,
@@ -4739,14 +5965,14 @@ var StandardProtocolAdapter = class {
     }
     const sseResult = this.sseAdapter.convertToClaudeSSE(openaiRawStream, modelName, messageId);
     if (this.debugMode) {
-      console.log("\u{1F504} [StandardProtocolAdapter] SSE\u8F6C\u6362\u5B8C\u6210:", {
+      this.logDebug("\u{1F504} [StandardProtocolAdapter] SSE\u8F6C\u6362\u5B8C\u6210:", {
         sseResultLength: sseResult.length,
         ssePreview: sseResult.substring(0, 500)
       });
     }
     const standardResponse = this.extractStandardResponseFromSSE(sseResult, modelName, messageId);
     if (this.debugMode) {
-      console.log("\u{1F504} [StandardProtocolAdapter] \u6807\u51C6\u54CD\u5E94\u63D0\u53D6\u5B8C\u6210:", {
+      this.logDebug("\u{1F504} [StandardProtocolAdapter] \u6807\u51C6\u54CD\u5E94\u63D0\u53D6\u5B8C\u6210:", {
         contentLength: standardResponse.content.length,
         usage: standardResponse.usage,
         stopReason: standardResponse.stop_reason
@@ -4761,7 +5987,7 @@ var StandardProtocolAdapter = class {
     const lines = sseContent.split("\n");
     const finalMessageId = messageId || generateMessageId();
     if (this.debugMode) {
-      console.log("\u{1F50D} [StandardProtocolAdapter] extractStandardResponseFromSSE \u5F00\u59CB\u89E3\u6790:", {
+      this.logDebug("\u{1F50D} [StandardProtocolAdapter] extractStandardResponseFromSSE \u5F00\u59CB\u89E3\u6790:", {
         totalLines: lines.length,
         messageId: finalMessageId
       });
@@ -4780,7 +6006,10 @@ var StandardProtocolAdapter = class {
       }
     };
     let currentTextContent = "";
+    let currentThinkingContent = "";
     const toolCalls = /* @__PURE__ */ new Map();
+    const toolInputBuffers = /* @__PURE__ */ new Map();
+    const indexToToolId = /* @__PURE__ */ new Map();
     let processedDataLines = 0;
     for (const line of lines) {
       if (line.startsWith("data: ")) {
@@ -4793,24 +6022,80 @@ var StandardProtocolAdapter = class {
           if (data.type === "content_block_start") {
             const contentBlock = data.content_block;
             if (contentBlock.type === "tool_use") {
+              const toolIndex = data.index;
               toolCalls.set(contentBlock.id, {
                 type: "tool_use",
                 id: contentBlock.id,
                 name: contentBlock.name,
                 input: contentBlock.input || {}
+                // 初始为空对象，稍后会被更新
+              });
+              toolInputBuffers.set(toolIndex, "");
+              indexToToolId.set(toolIndex, contentBlock.id);
+              console.log("\u{1F527}\u{1F527}\u{1F527} [StandardProtocolAdapter] \u6DFB\u52A0\u5DE5\u5177\u8C03\u7528:", {
+                index: toolIndex,
+                toolId: contentBlock.id,
+                name: contentBlock.name,
+                indexToToolIdSize: indexToToolId.size
               });
-              if (this.debugMode) {
-                console.log("\u{1F527} [StandardProtocolAdapter] \u6DFB\u52A0\u5DE5\u5177\u8C03\u7528:", contentBlock);
-              }
             }
           }
           if (data.type === "content_block_delta" && data.delta?.type === "text_delta") {
             currentTextContent += data.delta.text;
             if (this.debugMode && currentTextContent.length % 50 === 0) {
-              console.log(`\u{1F4DD} [StandardProtocolAdapter] \u7D2F\u79EF\u6587\u672C\u5185\u5BB9 (${currentTextContent.length}\u5B57\u7B26):`, currentTextContent.substring(currentTextContent.length - 20));
+              this.logDebug(`\u{1F4DD} [StandardProtocolAdapter] \u7D2F\u79EF\u6587\u672C\u5185\u5BB9 (${currentTextContent.length}\u5B57\u7B26)`, currentTextContent.substring(currentTextContent.length - 20));
+            }
+          }
+          if (data.type === "content_block_delta" && data.delta?.type === "thinking_delta") {
+            currentThinkingContent += data.delta.thinking;
+            if (this.debugMode && currentThinkingContent.length % 100 === 0) {
+              this.logDebug(`\u{1F9E0} [StandardProtocolAdapter] \u7D2F\u79EFthinking\u5185\u5BB9 (${currentThinkingContent.length}\u5B57\u7B26)`);
             }
           }
           if (data.type === "content_block_delta" && data.delta?.type === "input_json_delta") {
+            const toolIndex = data.index;
+            const toolId = indexToToolId.get(toolIndex);
+            if (this.debugMode) {
+              this.logDebug(`\u{1F527}\u{1F527}\u{1F527} [StandardProtocolAdapter] \u68C0\u6D4B\u5230input_json_delta\u4E8B\u4EF6\uFF01`, {
+                toolIndex,
+                toolId: toolId || "NOT_FOUND",
+                delta: data.delta.partial_json
+              });
+            }
+            if (toolId) {
+              const currentBuffer = toolInputBuffers.get(toolIndex) || "";
+              const newBuffer = currentBuffer + data.delta.partial_json;
+              toolInputBuffers.set(toolIndex, newBuffer);
+              if (this.debugMode) {
+                this.logDebug(`\u{1F527} [StandardProtocolAdapter] \u7D2F\u79EF\u5DE5\u5177\u53C2\u6570 (index=${toolIndex}, id=${toolId})`, {
+                  bufferLength: newBuffer.length
+                });
+              }
+            } else {
+              console.warn(`\u26A0\uFE0F [StandardProtocolAdapter] \u627E\u4E0D\u5230toolId for index=${toolIndex}`);
+            }
+          }
+          if (data.type === "content_block_stop") {
+            const toolIndex = data.index;
+            const toolId = indexToToolId.get(toolIndex);
+            if (toolId) {
+              const jsonBuffer = toolInputBuffers.get(toolIndex);
+              const tool = toolCalls.get(toolId);
+              if (jsonBuffer && tool) {
+                try {
+                  const parsedInput = JSON.parse(jsonBuffer);
+                  tool.input = parsedInput;
+                  if (this.debugMode) {
+                    this.logDebug(`\u2705 [StandardProtocolAdapter] \u5DE5\u5177\u53C2\u6570\u89E3\u6790\u5B8C\u6210 (index=${toolIndex}, id=${toolId})`, parsedInput);
+                  }
+                } catch (parseError) {
+                  console.warn(`\u26A0\uFE0F [StandardProtocolAdapter] \u5DE5\u5177\u53C2\u6570JSON\u89E3\u6790\u5931\u8D25 (index=${toolIndex}, id=${toolId}):`, {
+                    buffer: jsonBuffer,
+                    error: parseError
+                  });
+                }
+              }
+            }
           }
           if (data.type === "message_delta") {
             if (data.delta?.stop_reason) {
@@ -4819,7 +6104,7 @@ var StandardProtocolAdapter = class {
             if (data.usage) {
               response.usage = data.usage;
               if (this.debugMode) {
-                console.log("\u{1F4CA} [StandardProtocolAdapter] \u66F4\u65B0usage\u4FE1\u606F:", data.usage);
+                this.logDebug("\u{1F4CA} [StandardProtocolAdapter] \u66F4\u65B0usage\u4FE1\u606F:", data.usage);
               }
             }
           }
@@ -4831,6 +6116,12 @@ var StandardProtocolAdapter = class {
         }
       }
     }
+    if (currentThinkingContent.trim()) {
+      response.content.push({
+        type: "thinking",
+        thinking: currentThinkingContent.trim()
+      });
+    }
     if (currentTextContent.trim()) {
       response.content.push({
         type: "text",
@@ -4839,8 +6130,9 @@ var StandardProtocolAdapter = class {
     }
     response.content.push(...Array.from(toolCalls.values()));
     if (this.debugMode) {
-      console.log("\u2705 [StandardProtocolAdapter] \u6807\u51C6\u54CD\u5E94\u6784\u5EFA\u5B8C\u6210:", {
+      this.logDebug("\u2705 [StandardProtocolAdapter] \u6807\u51C6\u54CD\u5E94\u6784\u5EFA\u5B8C\u6210:", {
         contentCount: response.content.length,
+        thinkingLength: currentThinkingContent.length,
         textLength: currentTextContent.length,
         toolCallsCount: toolCalls.size,
         finalUsage: response.usage,
@@ -5699,6 +6991,7 @@ export {
   createAnthropicSDK,
   createOpenAISDK,
   createValidator,
+  downloadImageAsBase64,
   errorRecovery,
   getAllHealingStrategies,
   getGlobalLogger,
@@ -5708,6 +7001,8 @@ export {
   healO2ARequest,
   healO2AResponse,
   healingValidate,
+  isBase64DataUri,
+  isExternalUrl,
   isRecoverable,
   protocolHealer,
   safeValidate,