ai-protocol-adapters 1.0.0-alpha.8 → 1.0.0-alpha.9

package/dist/index.js

@@ -504,1380 +504,928 @@ 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()
-    };
-  }
-  logDebug(message, meta) {
-    if (this.config.debugMode) {
-      this.config.logger.debug(message, meta);
-    }
+// 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 = {
   /**
-   * 转换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/message-converter.ts
+var MessageConverter = class {
+  /**
+   * 转换消息格式，正确处理工具调用和工具结果
+   * 修复关键问题：将tool_use转换为tool_calls，tool_result转换为role:"tool"消息
+   * 使用tool_use_id溯回工具名称解决unknown_tool问题
+   */
+  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");
+      }
     }
-    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 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);
+      }
     }
-    const hasImages = this.hasImageContent(anthropicRequest);
-    return {
-      openaiRequest,
-      metadata: {
-        hasImages,
-        requiresVisionHeaders: hasImages
+    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");
+        }
       }
-    };
-  }
-  /**
-   * 转换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 (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;
         });
       }
-      if (!openaiStream || openaiStream.trim() === "") {
-        return {
-          success: false,
-          error: "Empty stream response",
-          anthropicSSE: "",
-          anthropicStandardResponse: null
-        };
-      }
-      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
-      };
-    }
+      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) {
-      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 });
+  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);
       }
-    }
-    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;
+    } else if (textContent.length > 0) {
+      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;
-      }
-      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;
   }
   /**
-   * 处理工具调用 - 支持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
+   * 分类内容块
    */
-  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 = `tool_${index}`;
-      let toolData = state.toolCallsMap.get(stateKey);
-      if (!toolData) {
-        toolData = {
-          id: toolId || "",
-          name: toolName || "",
-          input: "",
-          blockStartSent: false,
-          blockStopSent: false
-        };
-        state.toolCallsMap.set(stateKey, toolData);
-      } else {
-        if (toolId) toolData.id = toolId;
-        if (toolName) toolData.name = toolName;
-      }
-      if (toolArgs) {
-        toolData.input += toolArgs;
-        this.logDebug(`Accumulated tool arguments for index ${index}`, {
-          currentLength: toolData.input.length
-        });
-      }
-      if (toolData.id && toolData.name && !toolData.blockStartSent) {
-        const blockIndex = state.completedToolCalls.length + 1;
-        toolData.blockIndex = blockIndex;
-        sseLines.push(
-          "event: content_block_start",
-          `data: {"type":"content_block_start","index":${blockIndex},"content_block":{"type":"tool_use","id":"${toolData.id}","name":"${toolData.name}","input":{}}}`,
-          ""
-        );
-        toolData.blockStartSent = true;
-        this.logDebug("Sent content_block_start", { toolName: toolData.name, blockIndex });
-      }
-      if (toolArgs && toolData.blockStartSent && toolData.blockIndex !== void 0) {
-        sseLines.push(
-          "event: content_block_delta",
-          `data: {"type":"content_block_delta","index":${toolData.blockIndex},"delta":{"type":"input_json_delta","partial_json":${JSON.stringify(toolArgs)}}}`,
-          ""
-        );
-        this.logDebug("Sent input_json_delta", { blockIndex: toolData.blockIndex });
+  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 };
   }
   /**
-   * 在流结束时关闭所有未关闭的工具调用块
+   * 转换图片内容格式
    */
-  closeAllToolCallBlocks(state, sseLines) {
-    for (const [key, toolData] of state.toolCallsMap.entries()) {
-      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;
-        state.completedToolCalls.push(toolData.id);
-        this.logDebug("Sent content_block_stop", { toolName: toolData.name, blockIndex: toolData.blockIndex });
+  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
+        }
+      };
     }
+    return null;
   }
   /**
-   * 添加最终事件 - 支持thinking+content双模式
+   * 创建包含工具调用的助手消息
    */
-  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_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 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();
+      }
     }
-    const stopReason = state.completedToolCalls.length > 0 ? "tool_use" : "end_turn";
-    sseLines.push(
-      "event: message_delta",
-      `data: {"type":"message_delta","delta":{"stop_reason":"${stopReason}","stop_sequence":null},"usage":{"output_tokens":${state.usage.output_tokens}}}`,
-      "",
-      "event: message_stop",
-      'data: {"type":"message_stop"}',
-      ""
-    );
+    assistantMessage.tool_calls = toolUses.map((toolUse) => ({
+      id: toolUse.id,
+      type: "function",
+      function: {
+        name: toolUse.name,
+        arguments: JSON.stringify(toolUse.input || {})
+      }
+    }));
+    return assistantMessage;
   }
   /**
-   * 构建标准响应格式
+   * 创建工具结果消息
    */
-  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) {
+  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);
         }
       }
-    }
-    return {
-      id: `msg_${Date.now()}`,
-      type: "message",
-      role: "assistant",
-      content: [
-        {
-          type: "text",
-          text: state.textContent
-        }
-      ],
-      model: "claude-3-sonnet-20240229",
-      stop_reason: "end_turn",
-      stop_sequence: null,
-      usage: state.usage
-    };
+      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
+      };
+    });
   }
   /**
-   * 创建转换状态对象
+   * 创建文本消息
    */
-  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 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
+      };
+    }
   }
   /**
-   * 转换消息格式
+   * 处理系统消息
    */
-  convertMessages(messages) {
-    return messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content
-    }));
+  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模型
+   * 将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;
+  static convertAnthropicToolToOpenAI(anthropicTool) {
+    if (!anthropicTool || !anthropicTool.name) {
+      throw new Error("Invalid tool definition: missing name");
     }
-    const mapping = {
-      "claude-3-sonnet-20240229": "glm-4.5",
-      "claude-3-haiku-20240307": "kimi-k2",
-      "claude-3-opus-20240229": "deepseek-v3.1"
+    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
+      }
     };
-    return mapping[model] || "glm-4.5";
   }
   /**
-   * 检查请求是否包含图片内容
+   * 将OpenAI工具调用转换为Claude格式
    */
-  hasImageContent(request) {
-    return request.messages.some(
-      (msg) => Array.isArray(msg.content) && msg.content.some((content) => content?.type === "image")
-    );
+  static convertOpenAIToolCallsToClaude(toolCalls) {
+    return toolCalls.map((toolCall) => {
+      const claudeToolName = toolCall.function.name;
+      let parsedInput = {};
+      try {
+        parsedInput = JSON.parse(toolCall.function.arguments);
+      } catch (error) {
+        parsedInput = { raw_arguments: toolCall.function.arguments };
+      }
+      return {
+        type: "tool_use",
+        id: toolCall.id,
+        name: claudeToolName,
+        input: parsedInput
+      };
+    });
   }
   /**
-   * 转义JSON字符串
+   * 检查是否为OpenAI工具格式
    */
-  escapeJsonString(str) {
-    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  static isOpenAIToolFormat(tool) {
+    return tool && tool.type === "function" && tool.function && tool.function.name;
   }
   /**
-   * 获取初始SSE事件（message_start + ping）
+   * 简化Claude的详细描述为OpenAI兼容的简短描述
    */
-  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 simplifyDescription(claudeDescription) {
+    const firstLine = claudeDescription.split("\n")[0].trim();
+    const maxLength = 100;
+    if (firstLine.length > maxLength) {
+      return firstLine.substring(0, maxLength - 3) + "...";
+    }
+    return firstLine;
   }
   /**
-   * 增量转换单个OpenAI数据块为Anthropic SSE事件
-   * 用于逐个处理流式数据片段
+   * 验证工具定义的有效性
    */
-  convertIncrementalChunk(openaiDataLine, state) {
-    const logger = this.config.logger;
-    const sseEvents = [];
-    if (openaiDataLine.trim() === "[DONE]") {
-      this.addFinalEvents(state, sseEvents);
-      return sseEvents;
+  static validateToolDefinition(tool) {
+    if (!tool) return false;
+    if ("input_schema" in tool) {
+      return !!(tool.name && tool.input_schema && tool.input_schema.type);
     }
-    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)
-        });
-      }
-      return [];
+    if ("function" in tool) {
+      return !!(tool.type === "function" && tool.function?.name && tool.function?.parameters);
+    }
+    return false;
+  }
+  /**
+   * 获取工具名称（通用方法）
+   */
+  static getToolName(tool) {
+    if ("name" in tool) {
+      return tool.name;
+    }
+    if ("function" in tool) {
+      return tool.function.name;
     }
+    return TOOL_CONVERSION.UNKNOWN_TOOL_FALLBACK;
   }
 };
 
-// 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
+// src/utils/validation-logger.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var ValidationLogger = class {
+  constructor(logsDir = "/app/logs/request-validation-errors") {
+    this.logsDir = logsDir;
+    this.ensureLogsDir();
   }
-};
-var SUPPORTED_IMAGE_TYPES = [
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp"
-];
-var TOOL_CONVERSION = {
   /**
-   * 终极泛化：完全移除工具名称映射
-   * 基于GitHub Copilot API测试结果，100%保持原始格式
+   * 确保日志目录存在
    */
-  PRESERVE_ORIGINAL_NAMES: true,
+  ensureLogsDir() {
+    try {
+      (0, import_fs.mkdirSync)(this.logsDir, { recursive: true });
+    } catch (error) {
+    }
+  }
   /**
-   * 默认工具描述
+   * 记录验证错误
    */
-  DEFAULT_DESCRIPTION: "Tool description",
+  logValidationError(type, validationData, context = {}) {
+    const timestamp = context.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    const requestId = context.requestId || `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const logEntry = {
+      timestamp,
+      requestId,
+      type,
+      model: context.model,
+      validationData,
+      errorDetails: this.extractErrorDetails(validationData, type)
+    };
+    const filename = `${type}-${requestId}.json`;
+    const filepath = (0, import_path.join)(this.logsDir, filename);
+    try {
+      (0, import_fs.writeFileSync)(filepath, JSON.stringify(logEntry, null, 2));
+      return filepath;
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F  [ValidationLogger] Failed to write log file: ${filepath} (${error.code})`);
+      return "";
+    }
+  }
   /**
-   * 未知工具回退名称
+   * 提取错误详情
    */
-  UNKNOWN_TOOL_FALLBACK: "unknown_tool"
-};
-
-// src/core/a2o-request-adapter/message-converter.ts
-var MessageConverter = class {
+  extractErrorDetails(data, type) {
+    switch (type) {
+      case "claude-request":
+        return {
+          model: data.model,
+          messagesCount: data.messages?.length,
+          hasSystem: !!data.system,
+          hasTools: !!data.tools,
+          missingFields: this.findMissingFields(data, ["model", "messages"]),
+          invalidTypes: this.findInvalidTypes(data)
+        };
+      case "claude-message":
+        return {
+          role: data.role,
+          contentType: typeof data.content,
+          missingFields: this.findMissingFields(data, ["role", "content"]),
+          invalidRoles: ["user", "assistant", "system"].includes(data.role) ? null : data.role
+        };
+      case "claude-tool":
+        return {
+          name: data.name,
+          description: data.description?.length,
+          missingFields: this.findMissingFields(data, ["name", "description", "input_schema"])
+        };
+      default:
+        return data;
+    }
+  }
   /**
-   * 转换消息格式，正确处理工具调用和工具结果
-   * 修复关键问题：将tool_use转换为tool_calls，tool_result转换为role:"tool"消息
-   * 使用tool_use_id溯回工具名称解决unknown_tool问题
+   * 查找缺失字段
    */
-  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");
-      }
-    }
-    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");
-        }
-      }
-    }
-    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;
-    });
+  findMissingFields(obj, requiredFields) {
+    return requiredFields.filter((field) => obj[field] === void 0);
   }
   /**
-   * 创建消息转换上下文
+   * 查找无效类型
    */
-  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 {
-      toolIdToNameMap,
-      hasSystemMessage: false
-    };
+  findInvalidTypes(obj) {
+    const invalidTypes = {};
+    if (typeof obj.model !== "string") invalidTypes.model = typeof obj.model;
+    if (!Array.isArray(obj.messages)) invalidTypes.messages = typeof obj.messages;
+    if (obj.tools && !Array.isArray(obj.tools)) invalidTypes.tools = typeof obj.tools;
+    return invalidTypes;
   }
   /**
-   * 处理复杂消息（包含多种内容类型）
+   * 获取最近的验证错误日志路径
    */
-  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);
-      }
+  getRecentLogs(limit = 10) {
+    try {
+      const fs = require("fs");
+      const files = fs.readdirSync(this.logsDir).filter((f) => f.endsWith(".json")).sort((a, b) => {
+        const aTime = fs.statSync((0, import_path.join)(this.logsDir, a)).mtime;
+        const bTime = fs.statSync((0, import_path.join)(this.logsDir, b)).mtime;
+        return bTime.getTime() - aTime.getTime();
+      }).slice(0, limit).map((f) => (0, import_path.join)(this.logsDir, f));
+      return files;
+    } catch (error) {
+      return [];
     }
-    return resultMessages;
   }
+};
+var validationLogger = new ValidationLogger();
+
+// src/core/a2o-request-adapter/format-validator.ts
+var FormatValidator = class {
   /**
-   * 分类内容块
+   * 验证Claude请求格式
    */
-  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;
+  static validateClaudeRequest(request) {
+    if (!request) {
+      const errorInfo = {
+        error: "request_is_null",
+        details: "Request\u5BF9\u8C61\u4E3A\u7A7A\u6216\u672A\u5B9A\u4E49"
+      };
+      const logPath = validationLogger.logValidationError("claude-request", errorInfo, { model: "unknown" });
+      console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
+      return false;
+    }
+    if (typeof request.model !== "string") {
+      const errorInfo = {
+        error: "invalid_model_type",
+        expected: "string",
+        actual: typeof request.model,
+        value: request.model
+      };
+      const logPath = validationLogger.logValidationError("claude-request", errorInfo, { model: String(request.model) });
+      console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
+      return false;
+    }
+    if (!Array.isArray(request.messages) || request.messages.length === 0) {
+      const errorInfo = {
+        error: "invalid_messages",
+        isArray: Array.isArray(request.messages),
+        length: request.messages?.length,
+        actualType: typeof request.messages,
+        messages: request.messages
+      };
+      const logPath = validationLogger.logValidationError("claude-request", errorInfo, { model: request.model });
+      console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
+      return false;
+    }
+    for (let i = 0; i < request.messages.length; i++) {
+      const message = request.messages[i];
+      if (!this.validateClaudeMessage(message)) {
+        const errorInfo = {
+          error: "invalid_message_at_index",
+          index: i,
+          message,
+          role: message?.role,
+          contentType: typeof message?.content,
+          hasContent: message?.content !== void 0
+        };
+        const logPath = validationLogger.logValidationError("claude-message", errorInfo, { model: request.model });
+        console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
+        return false;
+      }
+    }
+    if (request.tools) {
+      if (!Array.isArray(request.tools)) {
+        const errorInfo = {
+          error: "invalid_tools_type",
+          expected: "array",
+          actual: typeof request.tools,
+          tools: request.tools
+        };
+        const logPath = validationLogger.logValidationError("claude-tool", errorInfo, { model: request.model });
+        console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
+        return false;
+      }
+      for (let i = 0; i < request.tools.length; i++) {
+        const tool = request.tools[i];
+        if (!this.validateClaudeToolDefinition(tool)) {
+          const errorInfo = {
+            error: "invalid_tool_definition",
+            index: i,
+            tool,
+            hasName: !!tool?.name,
+            hasDescription: !!tool?.description,
+            hasInputSchema: !!tool?.input_schema,
+            missingFields: this.getMissingToolFields(tool)
+          };
+          const logPath = validationLogger.logValidationError("claude-tool", errorInfo, { model: request.model });
+          console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
+          return false;
         }
       }
     }
-    return { textContent, toolUses, toolResults };
+    if (request.system !== void 0) {
+      if (!this.validateSystemMessage(request.system)) {
+        const errorInfo = {
+          error: "invalid_system_message",
+          system: request.system,
+          type: typeof request.system,
+          isString: typeof request.system === "string",
+          isArray: Array.isArray(request.system)
+        };
+        const logPath = validationLogger.logValidationError("claude-request", errorInfo, { model: request.model });
+        console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
+        return false;
+      }
+    }
+    return true;
   }
   /**
-   * 转换图片内容格式
+   * 验证OpenAI请求格式
    */
-  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;
+  static validateOpenAIRequest(request) {
+    if (!request) {
+      return false;
+    }
+    if (typeof request.model !== "string") {
+      return false;
+    }
+    if (!Array.isArray(request.messages) || request.messages.length === 0) {
+      return false;
+    }
+    for (const message of request.messages) {
+      if (!this.validateOpenAIMessage(message)) {
+        return false;
       }
-      const dataUri = `data:${item.source.media_type};base64,${item.source.data}`;
-      return {
-        type: "image_url",
-        image_url: {
-          url: dataUri
+    }
+    if (request.tools) {
+      if (!Array.isArray(request.tools)) {
+        return false;
+      }
+      for (const tool of request.tools) {
+        if (!this.validateOpenAIToolDefinition(tool)) {
+          return false;
         }
-      };
+      }
     }
-    return null;
+    return true;
   }
   /**
-   * 创建包含工具调用的助手消息
+   * 验证Claude消息格式
    */
-  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 validateClaudeMessage(message) {
+    if (!message || !message.role) {
+      const errorInfo2 = {
+        error: "missing_message_or_role",
+        hasMessage: !!message,
+        hasRole: !!message?.role,
+        message
+      };
+      const logPath2 = validationLogger.logValidationError("claude-message", errorInfo2);
+      console.warn(`\u26A0\uFE0F  [Validation] Message validation failed. Log: ${logPath2}`);
+      return false;
     }
-    assistantMessage.tool_calls = toolUses.map((toolUse) => ({
-      id: toolUse.id,
-      type: "function",
-      function: {
-        name: toolUse.name,
-        arguments: JSON.stringify(toolUse.input || {})
-      }
-    }));
-    return assistantMessage;
+    const validRoles = ["user", "assistant", "system"];
+    if (!validRoles.includes(message.role)) {
+      const errorInfo2 = {
+        error: "invalid_role",
+        role: message.role,
+        validRoles
+      };
+      const logPath2 = validationLogger.logValidationError("claude-message", errorInfo2);
+      console.warn(`\u26A0\uFE0F  [Validation] Message role validation failed. Log: ${logPath2}`);
+      return false;
+    }
+    if (message.content === void 0) {
+      const errorInfo2 = {
+        error: "content_is_undefined",
+        message,
+        role: message.role
+      };
+      const logPath2 = validationLogger.logValidationError("claude-message", errorInfo2);
+      console.warn(`\u26A0\uFE0F  [Validation] Message content validation failed. Log: ${logPath2}`);
+      return false;
+    }
+    if (typeof message.content === "string") {
+      return true;
+    }
+    if (Array.isArray(message.content)) {
+      return this.validateClaudeContentBlocks(message.content);
+    }
+    const errorInfo = {
+      error: "invalid_content_type",
+      contentType: typeof message.content,
+      content: message.content,
+      role: message.role
+    };
+    const logPath = validationLogger.logValidationError("claude-content", errorInfo);
+    console.warn(`\u26A0\uFE0F  [Validation] Message content type validation failed. Log: ${logPath}`);
+    return false;
   }
   /**
-   * 创建工具结果消息
+   * 验证Claude内容块
    */
-  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);
-        }
+  static validateClaudeContentBlocks(content) {
+    for (let i = 0; i < content.length; i++) {
+      const block = content[i];
+      if (!this.validateClaudeContentBlock(block)) {
+        const errorInfo = {
+          error: "invalid_content_block",
+          index: i,
+          block,
+          type: block?.type,
+          hasType: !!block?.type
+        };
+        validationLogger.logValidationError("claude-content", errorInfo);
+        return false;
       }
-      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
-      };
-    });
+    }
+    return true;
   }
   /**
-   * 创建文本消息
+   * 验证单个Claude内容块
    */
-  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 validateClaudeContentBlock(block) {
+    if (!block || !block.type) {
+      const errorInfo = {
+        error: "missing_block_or_type",
+        hasBlock: !!block,
+        hasType: !!block?.type,
+        block
       };
+      validationLogger.logValidationError("claude-content", errorInfo);
+      return false;
+    }
+    switch (block.type) {
+      case "text":
+        if (typeof block.text !== "string") {
+          const errorInfo2 = {
+            error: "invalid_text_content",
+            type: block.type,
+            textType: typeof block.text,
+            text: block.text
+          };
+          validationLogger.logValidationError("claude-content", errorInfo2);
+          return false;
+        }
+        return true;
+      case "thinking":
+        return typeof block.thinking === "string";
+      case "tool_use":
+        return !!(block.id && block.name && block.input !== void 0);
+      case "tool_result":
+        return !!(block.tool_use_id && block.content !== void 0);
+      case "image":
+        return this.validateImageBlock(block);
+      default:
+        const errorInfo = {
+          error: "unknown_block_type",
+          type: block.type,
+          validTypes: ["text", "thinking", "tool_use", "tool_result", "image"],
+          block
+        };
+        validationLogger.logValidationError("claude-content", errorInfo);
+        return false;
     }
   }
   /**
-   * 处理系统消息
+   * 验证图片块
    */
-  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
+  static validateImageBlock(block) {
+    const isValid = !!(block.source && block.source.type === "base64" && block.source.data && block.source.media_type);
+    if (!isValid) {
+      const errorInfo = {
+        error: "invalid_image_block",
+        hasSource: !!block.source,
+        sourceType: block.source?.type,
+        hasData: !!block.source?.data,
+        hasMediaType: !!block.source?.media_type,
+        block
       };
+      validationLogger.logValidationError("claude-content", errorInfo);
     }
-    return null;
+    return isValid;
   }
-};
-
-// src/core/a2o-request-adapter/tool-converter.ts
-var ToolConverter = class {
   /**
-   * 将Anthropic工具定义转换为OpenAI格式
+   * 验证OpenAI消息格式
    */
-  static convertAnthropicToolToOpenAI(anthropicTool) {
-    if (!anthropicTool || !anthropicTool.name) {
-      throw new Error("Invalid tool definition: missing name");
+  static validateOpenAIMessage(message) {
+    if (!message || !message.role) {
+      return false;
     }
-    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 validRoles = ["user", "assistant", "system", "tool"];
+    if (!validRoles.includes(message.role)) {
+      return false;
     }
-    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
-      }
-    };
+    const hasContent = message.content !== void 0;
+    const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+    const hasToolCallId = message.role === "tool" && message.tool_call_id;
+    if (message.role === "assistant") {
+      return hasContent || hasToolCalls;
+    }
+    if (message.role === "tool") {
+      return hasToolCallId && hasContent;
+    }
+    return hasContent;
   }
   /**
-   * 将OpenAI工具调用转换为Claude格式
+   * 获取工具定义缺失字段
    */
-  static convertOpenAIToolCallsToClaude(toolCalls) {
-    return toolCalls.map((toolCall) => {
-      const claudeToolName = toolCall.function.name;
-      let parsedInput = {};
-      try {
-        parsedInput = JSON.parse(toolCall.function.arguments);
-      } catch (error) {
-        parsedInput = { raw_arguments: toolCall.function.arguments };
-      }
-      return {
-        type: "tool_use",
-        id: toolCall.id,
-        name: claudeToolName,
-        input: parsedInput
-      };
-    });
+  static getMissingToolFields(tool) {
+    const missing = [];
+    if (!tool?.name) missing.push("name");
+    if (!tool?.description) missing.push("description");
+    if (!tool?.input_schema) missing.push("input_schema");
+    return missing;
   }
   /**
-   * 检查是否为OpenAI工具格式
+   * 验证Claude工具定义
    */
-  static isOpenAIToolFormat(tool) {
-    return tool && tool.type === "function" && tool.function && tool.function.name;
-  }
-  /**
-   * 简化Claude的详细描述为OpenAI兼容的简短描述
-   */
-  static simplifyDescription(claudeDescription) {
-    const firstLine = claudeDescription.split("\n")[0].trim();
-    const maxLength = 100;
-    if (firstLine.length > maxLength) {
-      return firstLine.substring(0, maxLength - 3) + "...";
+  static validateClaudeToolDefinition(tool) {
+    if (!tool || typeof tool.name !== "string") {
+      const errorInfo = {
+        error: "invalid_tool_name",
+        hasTool: !!tool,
+        nameType: typeof tool?.name,
+        name: tool?.name
+      };
+      validationLogger.logValidationError("claude-tool", errorInfo);
+      return false;
     }
-    return firstLine;
+    if (!tool.input_schema || typeof tool.input_schema !== "object") {
+      const errorInfo = {
+        error: "invalid_input_schema",
+        hasInputSchema: !!tool.input_schema,
+        schemaType: typeof tool.input_schema,
+        tool
+      };
+      validationLogger.logValidationError("claude-tool", errorInfo);
+      return false;
+    }
+    const schema = tool.input_schema;
+    if (!schema.type || !schema.properties) {
+      const errorInfo = {
+        error: "invalid_schema_structure",
+        hasType: !!schema.type,
+        hasProperties: !!schema.properties,
+        schema
+      };
+      validationLogger.logValidationError("claude-tool", errorInfo);
+      return false;
+    }
+    return ToolConverter.validateToolDefinition(tool);
   }
   /**
-   * 验证工具定义的有效性
+   * 验证OpenAI工具定义
    */
-  static validateToolDefinition(tool) {
-    if (!tool) return false;
-    if ("input_schema" in tool) {
-      return !!(tool.name && tool.input_schema && tool.input_schema.type);
+  static validateOpenAIToolDefinition(tool) {
+    if (!tool || tool.type !== "function") {
+      return false;
     }
-    if ("function" in tool) {
-      return !!(tool.type === "function" && tool.function?.name && tool.function?.parameters);
+    if (!tool.function || typeof tool.function.name !== "string") {
+      return false;
     }
-    return false;
+    if (!tool.function.parameters || typeof tool.function.parameters !== "object") {
+      return false;
+    }
+    return ToolConverter.validateToolDefinition(tool);
   }
   /**
-   * 获取工具名称（通用方法）
+   * 验证系统消息
    */
-  static getToolName(tool) {
-    if ("name" in tool) {
-      return tool.name;
+  static validateSystemMessage(system) {
+    if (typeof system === "string") {
+      return true;
     }
-    if ("function" in tool) {
-      return tool.function.name;
+    if (Array.isArray(system)) {
+      return system.every(
+        (item) => typeof item === "string" || typeof item === "object" && typeof item.text === "string"
+      );
     }
-    return TOOL_CONVERSION.UNKNOWN_TOOL_FALLBACK;
-  }
-};
-
-// src/utils/validation-logger.ts
-var import_fs = require("fs");
-var import_path = require("path");
-var ValidationLogger = class {
-  constructor(logsDir = "/app/logs/request-validation-errors") {
-    this.logsDir = logsDir;
-    this.ensureLogsDir();
+    return false;
   }
   /**
-   * 确保日志目录存在
+   * 验证转换结果
    */
-  ensureLogsDir() {
+  static validateConversionResult(original, converted, direction) {
     try {
-      (0, import_fs.mkdirSync)(this.logsDir, { recursive: true });
+      if (direction === "claude-to-openai") {
+        return this.validateOpenAIRequest(converted);
+      } else {
+        return this.validateClaudeRequest(converted);
+      }
     } catch (error) {
+      console.warn(`\u26A0\uFE0F  [Validation] Conversion result validation failed: ${error?.message || error}`);
+      return false;
     }
   }
   /**
-   * 记录验证错误
+   * 获取验证错误详情
    */
-  logValidationError(type, validationData, context = {}) {
-    const timestamp = context.timestamp || (/* @__PURE__ */ new Date()).toISOString();
-    const requestId = context.requestId || `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const logEntry = {
-      timestamp,
-      requestId,
-      type,
-      model: context.model,
-      validationData,
-      errorDetails: this.extractErrorDetails(validationData, type)
-    };
-    const filename = `${type}-${requestId}.json`;
-    const filepath = (0, import_path.join)(this.logsDir, filename);
+  static getValidationErrors(request, type) {
+    const errors = [];
     try {
-      (0, import_fs.writeFileSync)(filepath, JSON.stringify(logEntry, null, 2));
-      return filepath;
+      if (type === "claude") {
+        if (!this.validateClaudeRequest(request)) {
+          errors.push("Claude\u8BF7\u6C42\u683C\u5F0F\u9A8C\u8BC1\u5931\u8D25");
+        }
+      } else {
+        if (!this.validateOpenAIRequest(request)) {
+          errors.push("OpenAI\u8BF7\u6C42\u683C\u5F0F\u9A8C\u8BC1\u5931\u8D25");
+        }
+      }
     } catch (error) {
-      console.warn(`\u26A0\uFE0F  [ValidationLogger] Failed to write log file: ${filepath} (${error.code})`);
-      return "";
-    }
-  }
-  /**
-   * 提取错误详情
-   */
-  extractErrorDetails(data, type) {
-    switch (type) {
-      case "claude-request":
-        return {
-          model: data.model,
-          messagesCount: data.messages?.length,
-          hasSystem: !!data.system,
-          hasTools: !!data.tools,
-          missingFields: this.findMissingFields(data, ["model", "messages"]),
-          invalidTypes: this.findInvalidTypes(data)
-        };
-      case "claude-message":
-        return {
-          role: data.role,
-          contentType: typeof data.content,
-          missingFields: this.findMissingFields(data, ["role", "content"]),
-          invalidRoles: ["user", "assistant", "system"].includes(data.role) ? null : data.role
-        };
-      case "claude-tool":
-        return {
-          name: data.name,
-          description: data.description?.length,
-          missingFields: this.findMissingFields(data, ["name", "description", "input_schema"])
-        };
-      default:
-        return data;
+      errors.push(`\u9A8C\u8BC1\u8FC7\u7A0B\u51FA\u9519: ${error.message}`);
     }
+    return errors;
   }
   /**
-   * 查找缺失字段
-   */
-  findMissingFields(obj, requiredFields) {
-    return requiredFields.filter((field) => obj[field] === void 0);
-  }
-  /**
-   * 查找无效类型
+   * 获取最近的验证错误日志路径
    */
-  findInvalidTypes(obj) {
-    const invalidTypes = {};
-    if (typeof obj.model !== "string") invalidTypes.model = typeof obj.model;
-    if (!Array.isArray(obj.messages)) invalidTypes.messages = typeof obj.messages;
-    if (obj.tools && !Array.isArray(obj.tools)) invalidTypes.tools = typeof obj.tools;
-    return invalidTypes;
+  static getRecentValidationLogs(limit = 5) {
+    return validationLogger.getRecentLogs(limit);
   }
   /**
-   * 获取最近的验证错误日志路径
+   * 验证并返回日志路径
    */
-  getRecentLogs(limit = 10) {
-    try {
-      const fs = require("fs");
-      const files = fs.readdirSync(this.logsDir).filter((f) => f.endsWith(".json")).sort((a, b) => {
-        const aTime = fs.statSync((0, import_path.join)(this.logsDir, a)).mtime;
-        const bTime = fs.statSync((0, import_path.join)(this.logsDir, b)).mtime;
-        return bTime.getTime() - aTime.getTime();
-      }).slice(0, limit).map((f) => (0, import_path.join)(this.logsDir, f));
-      return files;
-    } catch (error) {
-      return [];
+  static validateWithLogPath(request, type) {
+    if (type === "claude") {
+      const isValid = this.validateClaudeRequest(request);
+      if (!isValid) {
+        const logPath = validationLogger.getRecentLogs(1)[0];
+        return { valid: false, logPath };
+      }
+    } else {
+      const isValid = this.validateOpenAIRequest(request);
+      if (!isValid) {
+        const logPath = validationLogger.getRecentLogs(1)[0];
+        return { valid: false, logPath };
+      }
     }
-  }
-};
-var validationLogger = new ValidationLogger();
-
-// src/core/a2o-request-adapter/format-validator.ts
-var FormatValidator = class {
-  /**
-   * 验证Claude请求格式
-   */
-  static validateClaudeRequest(request) {
-    if (!request) {
-      const errorInfo = {
-        error: "request_is_null",
-        details: "Request\u5BF9\u8C61\u4E3A\u7A7A\u6216\u672A\u5B9A\u4E49"
-      };
-      const logPath = validationLogger.logValidationError("claude-request", errorInfo, { model: "unknown" });
-      console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
-      return false;
-    }
-    if (typeof request.model !== "string") {
-      const errorInfo = {
-        error: "invalid_model_type",
-        expected: "string",
-        actual: typeof request.model,
-        value: request.model
-      };
-      const logPath = validationLogger.logValidationError("claude-request", errorInfo, { model: String(request.model) });
-      console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
-      return false;
-    }
-    if (!Array.isArray(request.messages) || request.messages.length === 0) {
-      const errorInfo = {
-        error: "invalid_messages",
-        isArray: Array.isArray(request.messages),
-        length: request.messages?.length,
-        actualType: typeof request.messages,
-        messages: request.messages
-      };
-      const logPath = validationLogger.logValidationError("claude-request", errorInfo, { model: request.model });
-      console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
-      return false;
-    }
-    for (let i = 0; i < request.messages.length; i++) {
-      const message = request.messages[i];
-      if (!this.validateClaudeMessage(message)) {
-        const errorInfo = {
-          error: "invalid_message_at_index",
-          index: i,
-          message,
-          role: message?.role,
-          contentType: typeof message?.content,
-          hasContent: message?.content !== void 0
-        };
-        const logPath = validationLogger.logValidationError("claude-message", errorInfo, { model: request.model });
-        console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
-        return false;
-      }
-    }
-    if (request.tools) {
-      if (!Array.isArray(request.tools)) {
-        const errorInfo = {
-          error: "invalid_tools_type",
-          expected: "array",
-          actual: typeof request.tools,
-          tools: request.tools
-        };
-        const logPath = validationLogger.logValidationError("claude-tool", errorInfo, { model: request.model });
-        console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
-        return false;
-      }
-      for (let i = 0; i < request.tools.length; i++) {
-        const tool = request.tools[i];
-        if (!this.validateClaudeToolDefinition(tool)) {
-          const errorInfo = {
-            error: "invalid_tool_definition",
-            index: i,
-            tool,
-            hasName: !!tool?.name,
-            hasDescription: !!tool?.description,
-            hasInputSchema: !!tool?.input_schema,
-            missingFields: this.getMissingToolFields(tool)
-          };
-          const logPath = validationLogger.logValidationError("claude-tool", errorInfo, { model: request.model });
-          console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
-          return false;
-        }
-      }
-    }
-    if (request.system !== void 0) {
-      if (!this.validateSystemMessage(request.system)) {
-        const errorInfo = {
-          error: "invalid_system_message",
-          system: request.system,
-          type: typeof request.system,
-          isString: typeof request.system === "string",
-          isArray: Array.isArray(request.system)
-        };
-        const logPath = validationLogger.logValidationError("claude-request", errorInfo, { model: request.model });
-        console.warn(`\u26A0\uFE0F  [Validation] Request validation failed. Log: ${logPath}`);
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * 验证OpenAI请求格式
-   */
-  static validateOpenAIRequest(request) {
-    if (!request) {
-      return false;
-    }
-    if (typeof request.model !== "string") {
-      return false;
-    }
-    if (!Array.isArray(request.messages) || request.messages.length === 0) {
-      return false;
-    }
-    for (const message of request.messages) {
-      if (!this.validateOpenAIMessage(message)) {
-        return false;
-      }
-    }
-    if (request.tools) {
-      if (!Array.isArray(request.tools)) {
-        return false;
-      }
-      for (const tool of request.tools) {
-        if (!this.validateOpenAIToolDefinition(tool)) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-  /**
-   * 验证Claude消息格式
-   */
-  static validateClaudeMessage(message) {
-    if (!message || !message.role) {
-      const errorInfo2 = {
-        error: "missing_message_or_role",
-        hasMessage: !!message,
-        hasRole: !!message?.role,
-        message
-      };
-      const logPath2 = validationLogger.logValidationError("claude-message", errorInfo2);
-      console.warn(`\u26A0\uFE0F  [Validation] Message validation failed. Log: ${logPath2}`);
-      return false;
-    }
-    const validRoles = ["user", "assistant", "system"];
-    if (!validRoles.includes(message.role)) {
-      const errorInfo2 = {
-        error: "invalid_role",
-        role: message.role,
-        validRoles
-      };
-      const logPath2 = validationLogger.logValidationError("claude-message", errorInfo2);
-      console.warn(`\u26A0\uFE0F  [Validation] Message role validation failed. Log: ${logPath2}`);
-      return false;
-    }
-    if (message.content === void 0) {
-      const errorInfo2 = {
-        error: "content_is_undefined",
-        message,
-        role: message.role
-      };
-      const logPath2 = validationLogger.logValidationError("claude-message", errorInfo2);
-      console.warn(`\u26A0\uFE0F  [Validation] Message content validation failed. Log: ${logPath2}`);
-      return false;
-    }
-    if (typeof message.content === "string") {
-      return true;
-    }
-    if (Array.isArray(message.content)) {
-      return this.validateClaudeContentBlocks(message.content);
-    }
-    const errorInfo = {
-      error: "invalid_content_type",
-      contentType: typeof message.content,
-      content: message.content,
-      role: message.role
-    };
-    const logPath = validationLogger.logValidationError("claude-content", errorInfo);
-    console.warn(`\u26A0\uFE0F  [Validation] Message content type validation failed. Log: ${logPath}`);
-    return false;
-  }
-  /**
-   * 验证Claude内容块
-   */
-  static validateClaudeContentBlocks(content) {
-    for (let i = 0; i < content.length; i++) {
-      const block = content[i];
-      if (!this.validateClaudeContentBlock(block)) {
-        const errorInfo = {
-          error: "invalid_content_block",
-          index: i,
-          block,
-          type: block?.type,
-          hasType: !!block?.type
-        };
-        validationLogger.logValidationError("claude-content", errorInfo);
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * 验证单个Claude内容块
-   */
-  static validateClaudeContentBlock(block) {
-    if (!block || !block.type) {
-      const errorInfo = {
-        error: "missing_block_or_type",
-        hasBlock: !!block,
-        hasType: !!block?.type,
-        block
-      };
-      validationLogger.logValidationError("claude-content", errorInfo);
-      return false;
-    }
-    switch (block.type) {
-      case "text":
-        if (typeof block.text !== "string") {
-          const errorInfo2 = {
-            error: "invalid_text_content",
-            type: block.type,
-            textType: typeof block.text,
-            text: block.text
-          };
-          validationLogger.logValidationError("claude-content", errorInfo2);
-          return false;
-        }
-        return true;
-      case "thinking":
-        return typeof block.thinking === "string";
-      case "tool_use":
-        return !!(block.id && block.name && block.input !== void 0);
-      case "tool_result":
-        return !!(block.tool_use_id && block.content !== void 0);
-      case "image":
-        return this.validateImageBlock(block);
-      default:
-        const errorInfo = {
-          error: "unknown_block_type",
-          type: block.type,
-          validTypes: ["text", "thinking", "tool_use", "tool_result", "image"],
-          block
-        };
-        validationLogger.logValidationError("claude-content", errorInfo);
-        return false;
-    }
-  }
-  /**
-   * 验证图片块
-   */
-  static validateImageBlock(block) {
-    const isValid = !!(block.source && block.source.type === "base64" && block.source.data && block.source.media_type);
-    if (!isValid) {
-      const errorInfo = {
-        error: "invalid_image_block",
-        hasSource: !!block.source,
-        sourceType: block.source?.type,
-        hasData: !!block.source?.data,
-        hasMediaType: !!block.source?.media_type,
-        block
-      };
-      validationLogger.logValidationError("claude-content", errorInfo);
-    }
-    return isValid;
-  }
-  /**
-   * 验证OpenAI消息格式
-   */
-  static validateOpenAIMessage(message) {
-    if (!message || !message.role) {
-      return false;
-    }
-    const validRoles = ["user", "assistant", "system", "tool"];
-    if (!validRoles.includes(message.role)) {
-      return false;
-    }
-    const hasContent = message.content !== void 0;
-    const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
-    const hasToolCallId = message.role === "tool" && message.tool_call_id;
-    if (message.role === "assistant") {
-      return hasContent || hasToolCalls;
-    }
-    if (message.role === "tool") {
-      return hasToolCallId && hasContent;
-    }
-    return hasContent;
-  }
-  /**
-   * 获取工具定义缺失字段
-   */
-  static getMissingToolFields(tool) {
-    const missing = [];
-    if (!tool?.name) missing.push("name");
-    if (!tool?.description) missing.push("description");
-    if (!tool?.input_schema) missing.push("input_schema");
-    return missing;
-  }
-  /**
-   * 验证Claude工具定义
-   */
-  static validateClaudeToolDefinition(tool) {
-    if (!tool || typeof tool.name !== "string") {
-      const errorInfo = {
-        error: "invalid_tool_name",
-        hasTool: !!tool,
-        nameType: typeof tool?.name,
-        name: tool?.name
-      };
-      validationLogger.logValidationError("claude-tool", errorInfo);
-      return false;
-    }
-    if (!tool.input_schema || typeof tool.input_schema !== "object") {
-      const errorInfo = {
-        error: "invalid_input_schema",
-        hasInputSchema: !!tool.input_schema,
-        schemaType: typeof tool.input_schema,
-        tool
-      };
-      validationLogger.logValidationError("claude-tool", errorInfo);
-      return false;
-    }
-    const schema = tool.input_schema;
-    if (!schema.type || !schema.properties) {
-      const errorInfo = {
-        error: "invalid_schema_structure",
-        hasType: !!schema.type,
-        hasProperties: !!schema.properties,
-        schema
-      };
-      validationLogger.logValidationError("claude-tool", errorInfo);
-      return false;
-    }
-    return ToolConverter.validateToolDefinition(tool);
-  }
-  /**
-   * 验证OpenAI工具定义
-   */
-  static validateOpenAIToolDefinition(tool) {
-    if (!tool || tool.type !== "function") {
-      return false;
-    }
-    if (!tool.function || typeof tool.function.name !== "string") {
-      return false;
-    }
-    if (!tool.function.parameters || typeof tool.function.parameters !== "object") {
-      return false;
-    }
-    return ToolConverter.validateToolDefinition(tool);
-  }
-  /**
-   * 验证系统消息
-   */
-  static validateSystemMessage(system) {
-    if (typeof system === "string") {
-      return true;
-    }
-    if (Array.isArray(system)) {
-      return system.every(
-        (item) => typeof item === "string" || typeof item === "object" && typeof item.text === "string"
-      );
-    }
-    return false;
-  }
-  /**
-   * 验证转换结果
-   */
-  static validateConversionResult(original, converted, direction) {
-    try {
-      if (direction === "claude-to-openai") {
-        return this.validateOpenAIRequest(converted);
-      } else {
-        return this.validateClaudeRequest(converted);
-      }
-    } catch (error) {
-      console.warn(`\u26A0\uFE0F  [Validation] Conversion result validation failed: ${error?.message || error}`);
-      return false;
-    }
-  }
-  /**
-   * 获取验证错误详情
-   */
-  static getValidationErrors(request, type) {
-    const errors = [];
-    try {
-      if (type === "claude") {
-        if (!this.validateClaudeRequest(request)) {
-          errors.push("Claude\u8BF7\u6C42\u683C\u5F0F\u9A8C\u8BC1\u5931\u8D25");
-        }
-      } else {
-        if (!this.validateOpenAIRequest(request)) {
-          errors.push("OpenAI\u8BF7\u6C42\u683C\u5F0F\u9A8C\u8BC1\u5931\u8D25");
-        }
-      }
-    } catch (error) {
-      errors.push(`\u9A8C\u8BC1\u8FC7\u7A0B\u51FA\u9519: ${error.message}`);
-    }
-    return errors;
-  }
-  /**
-   * 获取最近的验证错误日志路径
-   */
-  static getRecentValidationLogs(limit = 5) {
-    return validationLogger.getRecentLogs(limit);
-  }
-  /**
-   * 验证并返回日志路径
-   */
-  static validateWithLogPath(request, type) {
-    if (type === "claude") {
-      const isValid = this.validateClaudeRequest(request);
-      if (!isValid) {
-        const logPath = validationLogger.getRecentLogs(1)[0];
-        return { valid: false, logPath };
-      }
-    } else {
-      const isValid = this.validateOpenAIRequest(request);
-      if (!isValid) {
-        const logPath = validationLogger.getRecentLogs(1)[0];
-        return { valid: false, logPath };
-      }
-    }
-    return { valid: true };
+    return { valid: true };
   }
 };
 
@@ -3167,1063 +2715,1763 @@ var REQUEST_HEALING_STRATEGIES = [
     }),
     priority: 5
   },
-  // 停止序列修复
+  // 停止序列修复
+  {
+    id: "fix-stop-sequences-format",
+    name: "Fix Stop Sequences Format",
+    description: "Convert between stop_sequences and stop formats",
+    condition: (data, ctx) => {
+      return ctx.direction === "a2o" && data?.stop_sequences || ctx.direction === "o2a" && data?.stop;
+    },
+    fix: (data, ctx) => {
+      if (ctx.direction === "a2o") {
+        const { stop_sequences, ...rest } = data;
+        return {
+          ...rest,
+          stop: Array.isArray(stop_sequences) ? stop_sequences.slice(0, 4) : [stop_sequences]
+        };
+      } else {
+        const { stop, ...rest } = data;
+        return {
+          ...rest,
+          stop_sequences: Array.isArray(stop) ? stop : [stop]
+        };
+      }
+    },
+    priority: 4
+  }
+];
+var RESPONSE_HEALING_STRATEGIES = [
+  // Usage 字段修复
+  {
+    id: "fix-usage-mapping-o2a",
+    name: "Fix OpenAI to Anthropic Usage Mapping",
+    description: "Map OpenAI usage format to Anthropic format",
+    condition: (data, ctx) => {
+      return ctx.direction === "o2a" && ctx.stage === "response" && data?.usage?.prompt_tokens != null;
+    },
+    fix: (data) => {
+      const usage = data.usage;
+      return {
+        ...data,
+        usage: {
+          input_tokens: usage.prompt_tokens || 0,
+          output_tokens: usage.completion_tokens || 0,
+          cache_read_input_tokens: usage.prompt_tokens_details?.cached_tokens || void 0
+        }
+      };
+    },
+    priority: 8
+  },
+  // Finish reason 修复
+  {
+    id: "fix-finish-reason-mapping",
+    name: "Fix Finish Reason Mapping",
+    description: "Map OpenAI finish_reason to Anthropic stop_reason",
+    condition: (data, ctx) => {
+      return ctx.direction === "o2a" && ctx.stage === "response" && data?.choices?.[0]?.finish_reason;
+    },
+    fix: (data) => {
+      const choice = data.choices[0];
+      let stop_reason = "end_turn";
+      switch (choice.finish_reason) {
+        case "length":
+          stop_reason = "max_tokens";
+          break;
+        case "tool_calls":
+          stop_reason = "tool_use";
+          break;
+        case "stop":
+        default:
+          stop_reason = "end_turn";
+          break;
+      }
+      return {
+        ...data,
+        stop_reason,
+        stop_sequence: null
+      };
+    },
+    priority: 7
+  },
+  // 内容格式修复
+  {
+    id: "fix-content-format-o2a",
+    name: "Fix Content Format for Anthropic",
+    description: "Convert OpenAI message content to Anthropic content blocks",
+    condition: (data, ctx) => {
+      return ctx.direction === "o2a" && ctx.stage === "response" && data?.choices?.[0]?.message;
+    },
+    fix: (data) => {
+      const message = data.choices[0].message;
+      const content = [];
+      if (message.content) {
+        content.push({
+          type: "text",
+          text: message.content
+        });
+      }
+      if (message.tool_calls) {
+        message.tool_calls.forEach((toolCall) => {
+          content.push({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: JSON.parse(toolCall.function.arguments || "{}")
+          });
+        });
+      }
+      return {
+        id: data.id || `msg_${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        model: data.model,
+        content,
+        stop_reason: data.stop_reason || "end_turn",
+        stop_sequence: null,
+        usage: data.usage
+      };
+    },
+    priority: 9
+  }
+];
+var STREAM_HEALING_STRATEGIES = [
+  // SSE 格式修复
+  {
+    id: "fix-sse-format",
+    name: "Fix SSE Format",
+    description: "Ensure proper SSE event format",
+    condition: (data, ctx) => {
+      return ctx.stage === "stream" && typeof data === "string" && !data.startsWith("data: ");
+    },
+    fix: (data) => {
+      if (data.trim() === "[DONE]") {
+        return "data: [DONE]\n\n";
+      }
+      try {
+        JSON.parse(data);
+        return `data: ${data}
+
+`;
+      } catch {
+        return data;
+      }
+    },
+    priority: 8
+  },
+  // 事件类型修复
+  {
+    id: "fix-stream-event-type",
+    name: "Fix Stream Event Type",
+    description: "Add missing event type to stream events",
+    condition: (data, ctx) => {
+      return ctx.stage === "stream" && typeof data === "object" && !data?.type;
+    },
+    fix: (data, ctx) => {
+      if (data.choices) {
+        return { ...data, object: "chat.completion.chunk" };
+      } else if (data.delta) {
+        return { ...data, type: "content_block_delta" };
+      } else {
+        return { ...data, type: "message_start" };
+      }
+    },
+    priority: 6
+  }
+];
+var EMERGENCY_HEALING_STRATEGIES = [
+  // 空数据修复
+  {
+    id: "emergency-null-data",
+    name: "Emergency Null Data Fix",
+    description: "Handle null or undefined data with safe defaults",
+    condition: (data) => data == null,
+    fix: (data, ctx) => {
+      if (ctx.stage === "request") {
+        return {
+          model: ctx.direction === "a2o" ? "gpt-3.5-turbo" : "claude-3-haiku-20240307",
+          messages: [{ role: "user", content: "Hello" }],
+          max_tokens: ctx.direction === "o2a" ? 100 : void 0
+        };
+      }
+      return {};
+    },
+    priority: 10
+  },
+  // 循环引用修复
+  {
+    id: "emergency-circular-reference",
+    name: "Emergency Circular Reference Fix",
+    description: "Remove circular references in data",
+    condition: (data) => {
+      try {
+        JSON.stringify(data);
+        return false;
+      } catch (error) {
+        return error.message.includes("circular");
+      }
+    },
+    fix: (data) => {
+      const seen = /* @__PURE__ */ new WeakSet();
+      const cleanData = JSON.parse(JSON.stringify(data, (key, value) => {
+        if (typeof value === "object" && value !== null) {
+          if (seen.has(value)) {
+            return "[Circular Reference Removed]";
+          }
+          seen.add(value);
+        }
+        return value;
+      }));
+      return cleanData;
+    },
+    priority: 10
+  },
+  // 数据类型修复
   {
-    id: "fix-stop-sequences-format",
-    name: "Fix Stop Sequences Format",
-    description: "Convert between stop_sequences and stop formats",
-    condition: (data, ctx) => {
-      return ctx.direction === "a2o" && data?.stop_sequences || ctx.direction === "o2a" && data?.stop;
+    id: "emergency-wrong-type",
+    name: "Emergency Wrong Type Fix",
+    description: "Fix fundamental type errors",
+    condition: (data) => {
+      return typeof data === "string" && (data.startsWith("{") || data.startsWith("["));
     },
-    fix: (data, ctx) => {
-      if (ctx.direction === "a2o") {
-        const { stop_sequences, ...rest } = data;
-        return {
-          ...rest,
-          stop: Array.isArray(stop_sequences) ? stop_sequences.slice(0, 4) : [stop_sequences]
-        };
-      } else {
-        const { stop, ...rest } = data;
-        return {
-          ...rest,
-          stop_sequences: Array.isArray(stop) ? stop : [stop]
-        };
+    fix: (data) => {
+      try {
+        return JSON.parse(data);
+      } catch {
+        return { error: "Failed to parse JSON string", original: data };
       }
     },
-    priority: 4
+    priority: 9
   }
 ];
-var RESPONSE_HEALING_STRATEGIES = [
-  // Usage 字段修复
-  {
-    id: "fix-usage-mapping-o2a",
-    name: "Fix OpenAI to Anthropic Usage Mapping",
-    description: "Map OpenAI usage format to Anthropic format",
-    condition: (data, ctx) => {
-      return ctx.direction === "o2a" && ctx.stage === "response" && data?.usage?.prompt_tokens != null;
-    },
-    fix: (data) => {
-      const usage = data.usage;
+function getAllHealingStrategies() {
+  return [
+    ...EMERGENCY_HEALING_STRATEGIES,
+    ...REQUEST_HEALING_STRATEGIES,
+    ...RESPONSE_HEALING_STRATEGIES,
+    ...STREAM_HEALING_STRATEGIES
+  ].sort((a, b) => b.priority - a.priority);
+}
+function getStrategiesForContext(context) {
+  const allStrategies = getAllHealingStrategies();
+  return allStrategies.filter((strategy) => {
+    try {
+      const testData = {};
+      const testContext = {
+        direction: context.direction || "a2o",
+        stage: context.stage || "request",
+        originalData: testData,
+        attemptCount: 0,
+        maxAttempts: 3
+      };
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+
+// src/core/healing/error-recovery.ts
+var ErrorDetector = class {
+  /**
+   * 检测并分析错误
+   */
+  static analyzeError(error, context) {
+    const timestamp = Date.now();
+    if (error instanceof Error) {
       return {
-        ...data,
-        usage: {
-          input_tokens: usage.prompt_tokens || 0,
-          output_tokens: usage.completion_tokens || 0,
-          cache_read_input_tokens: usage.prompt_tokens_details?.cached_tokens || void 0
+        type: this.classifyError(error),
+        severity: this.assessSeverity(error),
+        message: error.message,
+        context,
+        timestamp,
+        stackTrace: error.stack
+      };
+    }
+    if (typeof error === "object" && error && "status" in error) {
+      const httpError = error;
+      return {
+        type: this.classifyHttpError(httpError.status),
+        severity: this.assessHttpSeverity(httpError.status),
+        message: httpError.message || `HTTP ${httpError.status}`,
+        code: httpError.status,
+        context,
+        timestamp
+      };
+    }
+    if (typeof error === "string") {
+      return {
+        type: this.classifyErrorMessage(error),
+        severity: this.assessMessageSeverity(error),
+        message: error,
+        context,
+        timestamp
+      };
+    }
+    return {
+      type: "unknown_error",
+      severity: "medium",
+      message: JSON.stringify(error),
+      context,
+      timestamp
+    };
+  }
+  /**
+   * 根据 Error 对象分类错误类型
+   */
+  static classifyError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("validation") || message.includes("schema")) {
+      return "validation_error";
+    }
+    if (message.includes("timeout")) {
+      return "timeout_error";
+    }
+    if (message.includes("network") || message.includes("fetch") || message.includes("connection")) {
+      return "network_error";
+    }
+    if (message.includes("auth") || message.includes("unauthorized")) {
+      return "auth_error";
+    }
+    if (message.includes("rate limit") || message.includes("too many requests")) {
+      return "rate_limit_error";
+    }
+    if (message.includes("quota") || message.includes("limit exceeded")) {
+      return "quota_error";
+    }
+    if (message.includes("convert") || message.includes("transform")) {
+      return "conversion_error";
+    }
+    return "client_error";
+  }
+  /**
+   * 根据 HTTP 状态码分类错误
+   */
+  static classifyHttpError(status) {
+    if (status === 401 || status === 403) return "auth_error";
+    if (status === 429) return "rate_limit_error";
+    if (status === 408 || status === 504) return "timeout_error";
+    if (status >= 500) return "server_error";
+    if (status >= 400) return "client_error";
+    return "unknown_error";
+  }
+  /**
+   * 评估错误严重程度
+   */
+  static assessSeverity(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("critical") || message.includes("fatal")) return "critical";
+    if (message.includes("timeout") || message.includes("network")) return "high";
+    if (message.includes("validation") || message.includes("auth")) return "medium";
+    return "low";
+  }
+  /**
+   * 评估 HTTP 错误严重程度
+   */
+  static assessHttpSeverity(status) {
+    if (status >= 500) return "critical";
+    if (status === 429 || status === 408 || status === 504) return "high";
+    if (status === 401 || status === 403) return "medium";
+    return "low";
+  }
+  /**
+   * 根据消息内容分类错误
+   */
+  static classifyErrorMessage(message) {
+    const lowerMessage = message.toLowerCase();
+    if (lowerMessage.includes("validation")) return "validation_error";
+    if (lowerMessage.includes("timeout")) return "timeout_error";
+    if (lowerMessage.includes("network")) return "network_error";
+    if (lowerMessage.includes("auth")) return "auth_error";
+    if (lowerMessage.includes("rate")) return "rate_limit_error";
+    if (lowerMessage.includes("quota")) return "quota_error";
+    return "unknown_error";
+  }
+  /**
+   * 评估消息严重程度
+   */
+  static assessMessageSeverity(message) {
+    const lowerMessage = message.toLowerCase();
+    if (lowerMessage.includes("critical") || lowerMessage.includes("fatal")) return "critical";
+    if (lowerMessage.includes("error")) return "high";
+    if (lowerMessage.includes("warning")) return "medium";
+    return "low";
+  }
+};
+var RECOVERY_STRATEGIES = [
+  // 网络错误恢复
+  {
+    id: "network-retry",
+    name: "Network Error Retry",
+    description: "Retry request after network errors",
+    supportedErrors: ["network_error", "timeout_error"],
+    maxRetries: 3,
+    backoffMs: 1e3,
+    condition: (error) => ["network_error", "timeout_error"].includes(error.type),
+    recover: async (error, context) => {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      return { retryRecommended: true, backoffMs: 2e3 };
+    }
+  },
+  // 限流错误恢复
+  {
+    id: "rate-limit-backoff",
+    name: "Rate Limit Backoff",
+    description: "Exponential backoff for rate limit errors",
+    supportedErrors: ["rate_limit_error"],
+    maxRetries: 5,
+    backoffMs: 5e3,
+    condition: (error) => error.type === "rate_limit_error",
+    recover: async (error, context) => {
+      const backoffTime = Math.min(3e4, 5e3 * Math.pow(2, context.attemptCount));
+      await new Promise((resolve) => setTimeout(resolve, backoffTime));
+      return { retryRecommended: true, backoffMs: backoffTime };
+    }
+  },
+  // 验证错误恢复
+  {
+    id: "validation-healing",
+    name: "Validation Error Healing",
+    description: "Attempt to fix validation errors automatically",
+    supportedErrors: ["validation_error"],
+    maxRetries: 2,
+    backoffMs: 0,
+    condition: (error) => error.type === "validation_error",
+    recover: async (error, context) => {
+      const { protocolHealer: protocolHealer3 } = await Promise.resolve().then(() => (init_protocol_healer(), protocol_healer_exports));
+      if (context.direction === "a2o") {
+        const healResult = await protocolHealer3.healA2ORequest(context.originalData);
+        if (healResult.success) {
+          return {
+            retryRecommended: true,
+            healedData: healResult.data,
+            appliedFixes: healResult.appliedFixes
+          };
+        }
+      } else if (context.direction === "o2a") {
+        const healResult = await protocolHealer3.healO2ARequest(context.originalData);
+        if (healResult.success) {
+          return {
+            retryRecommended: true,
+            healedData: healResult.data,
+            appliedFixes: healResult.appliedFixes
+          };
         }
-      };
-    },
-    priority: 8
+      }
+      return { retryRecommended: false, reason: "Healing failed" };
+    }
   },
-  // Finish reason 修复
+  // 模型不可用恢复
   {
-    id: "fix-finish-reason-mapping",
-    name: "Fix Finish Reason Mapping",
-    description: "Map OpenAI finish_reason to Anthropic stop_reason",
-    condition: (data, ctx) => {
-      return ctx.direction === "o2a" && ctx.stage === "response" && data?.choices?.[0]?.finish_reason;
+    id: "model-fallback",
+    name: "Model Fallback",
+    description: "Fallback to alternative models when primary model is unavailable",
+    supportedErrors: ["server_error", "client_error"],
+    maxRetries: 2,
+    backoffMs: 0,
+    condition: (error) => {
+      return error.message.toLowerCase().includes("model") && ["server_error", "client_error"].includes(error.type);
     },
-    fix: (data) => {
-      const choice = data.choices[0];
-      let stop_reason = "end_turn";
-      switch (choice.finish_reason) {
-        case "length":
-          stop_reason = "max_tokens";
-          break;
-        case "tool_calls":
-          stop_reason = "tool_use";
-          break;
-        case "stop":
-        default:
-          stop_reason = "end_turn";
-          break;
+    recover: async (error, context) => {
+      const data = context.originalData;
+      if (!data?.model) {
+        return { retryRecommended: false, reason: "No model specified" };
+      }
+      const fallbackMappings = {
+        "gpt-4": ["gpt-4-turbo", "gpt-3.5-turbo"],
+        "gpt-4-turbo": ["gpt-3.5-turbo", "gpt-3.5-turbo-16k"],
+        "claude-3-opus-20240229": ["claude-3-sonnet-20240229", "claude-3-haiku-20240307"],
+        "claude-3-5-sonnet-20241022": ["claude-3-sonnet-20240229", "claude-3-haiku-20240307"]
+      };
+      const fallbacks = fallbackMappings[data.model];
+      if (!fallbacks || context.attemptCount >= fallbacks.length) {
+        return { retryRecommended: false, reason: "No more fallback models" };
       }
+      const fallbackModel = fallbacks[context.attemptCount];
       return {
-        ...data,
-        stop_reason,
-        stop_sequence: null
+        retryRecommended: true,
+        healedData: { ...data, model: fallbackModel },
+        appliedFixes: [`Model fallback: ${data.model} \u2192 ${fallbackModel}`]
       };
-    },
-    priority: 7
+    }
   },
-  // 内容格式修复
+  // 认证错误恢复
   {
-    id: "fix-content-format-o2a",
-    name: "Fix Content Format for Anthropic",
-    description: "Convert OpenAI message content to Anthropic content blocks",
-    condition: (data, ctx) => {
-      return ctx.direction === "o2a" && ctx.stage === "response" && data?.choices?.[0]?.message;
-    },
-    fix: (data) => {
-      const message = data.choices[0].message;
-      const content = [];
-      if (message.content) {
-        content.push({
-          type: "text",
-          text: message.content
-        });
-      }
-      if (message.tool_calls) {
-        message.tool_calls.forEach((toolCall) => {
-          content.push({
-            type: "tool_use",
-            id: toolCall.id,
-            name: toolCall.function.name,
-            input: JSON.parse(toolCall.function.arguments || "{}")
-          });
-        });
-      }
+    id: "auth-refresh",
+    name: "Authentication Refresh",
+    description: "Attempt to refresh authentication",
+    supportedErrors: ["auth_error"],
+    maxRetries: 1,
+    backoffMs: 0,
+    condition: (error) => error.type === "auth_error",
+    recover: async (error, context) => {
       return {
-        id: data.id || `msg_${Date.now()}`,
-        type: "message",
-        role: "assistant",
-        model: data.model,
-        content,
-        stop_reason: data.stop_reason || "end_turn",
-        stop_sequence: null,
-        usage: data.usage
+        retryRecommended: false,
+        reason: "Authentication refresh not implemented - check API keys"
       };
-    },
-    priority: 9
+    }
   }
 ];
-var STREAM_HEALING_STRATEGIES = [
-  // SSE 格式修复
-  {
-    id: "fix-sse-format",
-    name: "Fix SSE Format",
-    description: "Ensure proper SSE event format",
-    condition: (data, ctx) => {
-      return ctx.stage === "stream" && typeof data === "string" && !data.startsWith("data: ");
-    },
-    fix: (data) => {
-      if (data.trim() === "[DONE]") {
-        return "data: [DONE]\n\n";
+var ErrorRecovery = class {
+  constructor(customStrategies = [], maxGlobalRetries = 5) {
+    this.strategies = [...RECOVERY_STRATEGIES, ...customStrategies];
+    this.maxGlobalRetries = maxGlobalRetries;
+  }
+  /**
+   * 尝试从错误中恢复
+   */
+  async attemptRecovery(error, context) {
+    const startTime = Date.now();
+    const errorInfo = ErrorDetector.analyzeError(error, context);
+    const messages = [];
+    messages.push(`Analyzing error: ${errorInfo.type} - ${errorInfo.message}`);
+    const applicableStrategies = this.strategies.filter(
+      (strategy) => strategy.condition(errorInfo, context)
+    );
+    if (applicableStrategies.length === 0) {
+      return {
+        success: false,
+        error: errorInfo,
+        attemptCount: context.attemptCount,
+        totalTime: Date.now() - startTime,
+        messages: [...messages, "No applicable recovery strategies found"]
+      };
+    }
+    for (const strategy of applicableStrategies) {
+      if (context.attemptCount >= strategy.maxRetries) {
+        messages.push(`Strategy ${strategy.name} exceeded max retries (${strategy.maxRetries})`);
+        continue;
+      }
+      if (context.attemptCount >= this.maxGlobalRetries) {
+        messages.push(`Global retry limit exceeded (${this.maxGlobalRetries})`);
+        break;
       }
       try {
-        JSON.parse(data);
-        return `data: ${data}
+        messages.push(`Attempting recovery with strategy: ${strategy.name}`);
+        const recoveryResult = await strategy.recover(errorInfo, context);
+        if (recoveryResult.retryRecommended) {
+          return {
+            success: true,
+            data: recoveryResult.healedData || context.originalData,
+            strategy: strategy.name,
+            attemptCount: context.attemptCount + 1,
+            totalTime: Date.now() - startTime,
+            messages: [
+              ...messages,
+              `Recovery successful with ${strategy.name}`,
+              ...recoveryResult.appliedFixes || []
+            ]
+          };
+        } else {
+          messages.push(`Strategy ${strategy.name} declined to retry: ${recoveryResult.reason || "Unknown reason"}`);
+        }
+      } catch (strategyError) {
+        messages.push(`Strategy ${strategy.name} failed: ${strategyError.message}`);
+      }
+    }
+    return {
+      success: false,
+      error: errorInfo,
+      attemptCount: context.attemptCount,
+      totalTime: Date.now() - startTime,
+      messages: [...messages, "All recovery strategies failed"]
+    };
+  }
+  /**
+   * 检查错误是否可恢复
+   */
+  isRecoverable(error, context) {
+    const errorInfo = ErrorDetector.analyzeError(error, context);
+    const hasApplicableStrategy = this.strategies.some(
+      (strategy) => strategy.condition(errorInfo, context) && context.attemptCount < strategy.maxRetries
+    );
+    const withinGlobalLimit = context.attemptCount < this.maxGlobalRetries;
+    return hasApplicableStrategy && withinGlobalLimit;
+  }
+  /**
+   * 获取错误的恢复建议
+   */
+  getRecoveryRecommendations(error, context) {
+    const errorInfo = ErrorDetector.analyzeError(error, context);
+    const applicableStrategies = this.strategies.filter(
+      (strategy) => strategy.condition(errorInfo, context)
+    );
+    const estimatedTime = applicableStrategies.reduce(
+      (total, strategy) => total + strategy.backoffMs,
+      0
+    );
+    let confidence = 0;
+    if (applicableStrategies.length > 0) {
+      const severityWeight = {
+        low: 0.9,
+        medium: 0.7,
+        high: 0.5,
+        critical: 0.2
+      }[errorInfo.severity];
+      const strategyWeight = Math.min(1, applicableStrategies.length / 3);
+      confidence = severityWeight * strategyWeight;
+    }
+    return {
+      isRecoverable: this.isRecoverable(error, context),
+      strategies: applicableStrategies.map((s) => s.name),
+      estimatedTime,
+      confidence
+    };
+  }
+  /**
+   * 添加自定义恢复策略
+   */
+  addStrategy(strategy) {
+    this.strategies.push(strategy);
+  }
+  /**
+   * 移除恢复策略
+   */
+  removeStrategy(strategyId) {
+    const index = this.strategies.findIndex((s) => s.id === strategyId);
+    if (index >= 0) {
+      this.strategies.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 获取所有策略信息
+   */
+  getStrategies() {
+    return this.strategies.map((strategy) => ({
+      id: strategy.id,
+      name: strategy.name,
+      description: strategy.description,
+      supportedErrors: strategy.supportedErrors,
+      maxRetries: strategy.maxRetries,
+      backoffMs: strategy.backoffMs
+    }));
+  }
+};
+var errorRecovery = new ErrorRecovery();
+var attemptRecovery = (error, context) => errorRecovery.attemptRecovery(error, context);
+var isRecoverable = (error, context) => errorRecovery.isRecoverable(error, context);
+var getRecoveryRecommendations = (error, context) => errorRecovery.getRecoveryRecommendations(error, context);
 
-`;
-      } catch {
-        return data;
-      }
-    },
-    priority: 8
-  },
-  // 事件类型修复
-  {
-    id: "fix-stream-event-type",
-    name: "Fix Stream Event Type",
-    description: "Add missing event type to stream events",
-    condition: (data, ctx) => {
-      return ctx.stage === "stream" && typeof data === "object" && !data?.type;
-    },
-    fix: (data, ctx) => {
-      if (data.choices) {
-        return { ...data, object: "chat.completion.chunk" };
-      } else if (data.delta) {
-        return { ...data, type: "content_block_delta" };
-      } else {
-        return { ...data, type: "message_start" };
-      }
-    },
-    priority: 6
+// src/core/a2o-request-adapter/adapter.ts
+var A2ORequestAdapter = class {
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
   }
-];
-var EMERGENCY_HEALING_STRATEGIES = [
-  // 空数据修复
-  {
-    id: "emergency-null-data",
-    name: "Emergency Null Data Fix",
-    description: "Handle null or undefined data with safe defaults",
-    condition: (data) => data == null,
-    fix: (data, ctx) => {
-      if (ctx.stage === "request") {
-        return {
-          model: ctx.direction === "a2o" ? "gpt-3.5-turbo" : "claude-3-haiku-20240307",
-          messages: [{ role: "user", content: "Hello" }],
-          max_tokens: ctx.direction === "o2a" ? 100 : void 0
-        };
-      }
-      return {};
-    },
-    priority: 10
-  },
-  // 循环引用修复
-  {
-    id: "emergency-circular-reference",
-    name: "Emergency Circular Reference Fix",
-    description: "Remove circular references in data",
-    condition: (data) => {
-      try {
-        JSON.stringify(data);
-        return false;
-      } catch (error) {
-        return error.message.includes("circular");
+  /**
+   * 转换Anthropic请求格式为OpenAI兼容格式 - 增强版
+   * 集成校验、修复和错误恢复功能
+   */
+  async convertAnthropicRequestToOpenAIEnhanced(anthropicRequest) {
+    const startTime = Date.now();
+    const result = {
+      success: false,
+      originalData: anthropicRequest,
+      warnings: [],
+      errors: [],
+      healingApplied: false,
+      appliedFixes: []
+    };
+    try {
+      let validatedInput;
+      if (this.config.validation.enabled) {
+        if (this.config.validation.strict) {
+          try {
+            validatedInput = validateAnthropicRequest(anthropicRequest);
+            result.validationResult = {
+              inputValid: true,
+              outputValid: false,
+              issues: []
+            };
+          } catch (error) {
+            result.errors.push(`Input validation failed: ${error.message}`);
+            return result;
+          }
+        } else {
+          if (this.config.healing.enabled) {
+            const healingResult = await healA2ORequest(anthropicRequest, this.config.healing.maxAttempts);
+            if (healingResult.success) {
+              validatedInput = healingResult.data;
+              result.healingApplied = true;
+              result.appliedFixes = healingResult.appliedFixes;
+              result.warnings.push(...healingResult.warnings);
+            } else {
+              result.errors.push(...healingResult.errors);
+              return result;
+            }
+          } else {
+            try {
+              validatedInput = validateAnthropicRequest(anthropicRequest);
+            } catch {
+              validatedInput = anthropicRequest;
+              result.warnings.push("Input validation skipped due to errors");
+            }
+          }
+        }
+      } else {
+        validatedInput = anthropicRequest;
       }
-    },
-    fix: (data) => {
-      const seen = /* @__PURE__ */ new WeakSet();
-      const cleanData = JSON.parse(JSON.stringify(data, (key, value) => {
-        if (typeof value === "object" && value !== null) {
-          if (seen.has(value)) {
-            return "[Circular Reference Removed]";
+      const openaiRequest = await this.performCoreConversion(validatedInput);
+      if (this.config.validation.enabled) {
+        try {
+          const validatedOutput = validateOpenAIRequest(openaiRequest);
+          result.data = validatedOutput;
+          result.validationResult = {
+            inputValid: true,
+            outputValid: true,
+            issues: []
+          };
+        } catch (error) {
+          if (this.config.validation.strict) {
+            result.errors.push(`Output validation failed: ${error.message}`);
+            return result;
+          } else {
+            result.warnings.push(`Output validation warning: ${error.message}`);
+            result.data = openaiRequest;
           }
-          seen.add(value);
         }
-        return value;
-      }));
-      return cleanData;
-    },
-    priority: 10
-  },
-  // 数据类型修复
-  {
-    id: "emergency-wrong-type",
-    name: "Emergency Wrong Type Fix",
-    description: "Fix fundamental type errors",
-    condition: (data) => {
-      return typeof data === "string" && (data.startsWith("{") || data.startsWith("["));
-    },
-    fix: (data) => {
-      try {
-        return JSON.parse(data);
-      } catch {
-        return { error: "Failed to parse JSON string", original: data };
+      } else {
+        result.data = openaiRequest;
       }
-    },
-    priority: 9
-  }
-];
-function getAllHealingStrategies() {
-  return [
-    ...EMERGENCY_HEALING_STRATEGIES,
-    ...REQUEST_HEALING_STRATEGIES,
-    ...RESPONSE_HEALING_STRATEGIES,
-    ...STREAM_HEALING_STRATEGIES
-  ].sort((a, b) => b.priority - a.priority);
-}
-function getStrategiesForContext(context) {
-  const allStrategies = getAllHealingStrategies();
-  return allStrategies.filter((strategy) => {
-    try {
-      const testData = {};
-      const testContext = {
-        direction: context.direction || "a2o",
-        stage: context.stage || "request",
-        originalData: testData,
-        attemptCount: 0,
-        maxAttempts: 3
-      };
-      return true;
-    } catch {
-      return false;
+      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;
     }
-  });
-}
-
-// src/core/healing/error-recovery.ts
-var ErrorDetector = class {
+  }
   /**
-   * 检测并分析错误
+   * 执行核心转换逻辑（原有逻辑保持不变）
    */
-  static analyzeError(error, context) {
-    const timestamp = Date.now();
-    if (error instanceof Error) {
-      return {
-        type: this.classifyError(error),
-        severity: this.assessSeverity(error),
-        message: error.message,
-        context,
-        timestamp,
-        stackTrace: error.stack
-      };
-    }
-    if (typeof error === "object" && error && "status" in error) {
-      const httpError = error;
-      return {
-        type: this.classifyHttpError(httpError.status),
-        severity: this.assessHttpSeverity(httpError.status),
-        message: httpError.message || `HTTP ${httpError.status}`,
-        code: httpError.status,
-        context,
-        timestamp
-      };
-    }
-    if (typeof error === "string") {
-      return {
-        type: this.classifyErrorMessage(error),
-        severity: this.assessMessageSeverity(error),
-        message: error,
-        context,
-        timestamp
-      };
-    }
-    return {
-      type: "unknown_error",
-      severity: "medium",
-      message: JSON.stringify(error),
-      context,
-      timestamp
+  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
     };
+    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;
   }
   /**
-   * 根据 Error 对象分类错误类型
+   * 转换Anthropic请求格式为OpenAI兼容格式 - 原有方法保持兼容
    */
-  static classifyError(error) {
-    const message = error.message.toLowerCase();
-    if (message.includes("validation") || message.includes("schema")) {
-      return "validation_error";
-    }
-    if (message.includes("timeout")) {
-      return "timeout_error";
+  convertAnthropicRequestToOpenAI(anthropicRequest) {
+    if (this.config.enableFormatValidation) {
+      FormatValidator.validateClaudeRequest(anthropicRequest);
     }
-    if (message.includes("network") || message.includes("fetch") || message.includes("connection")) {
-      return "network_error";
+    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);
     }
-    if (message.includes("auth") || message.includes("unauthorized")) {
-      return "auth_error";
+    const specialFields = ["_anthropic_protocol", "_rovo_tool_injected", "_routeResult"];
+    for (const field of specialFields) {
+      if (anthropicRequest[field] !== void 0) {
+        openaiRequest[field] = anthropicRequest[field];
+      }
     }
-    if (message.includes("rate limit") || message.includes("too many requests")) {
-      return "rate_limit_error";
+    if (this.config.enableFormatValidation && !FormatValidator.validateOpenAIRequest(openaiRequest)) {
+      throw new Error("Generated OpenAI request format is invalid");
     }
-    if (message.includes("quota") || message.includes("limit exceeded")) {
-      return "quota_error";
+    return openaiRequest;
+  }
+  /**
+   * 转换OpenAI响应格式为Claude兼容格式
+   */
+  convertOpenAIResponseToClaude(openaiResponse) {
+    const claudeContent = [];
+    const message = openaiResponse.choices?.[0]?.message;
+    if (message?.content) {
+      claudeContent.push({
+        type: "text",
+        text: message.content
+      });
     }
-    if (message.includes("convert") || message.includes("transform")) {
-      return "conversion_error";
+    if (message?.tool_calls) {
+      const toolUseContents = ToolConverter.convertOpenAIToolCallsToClaude(message.tool_calls);
+      claudeContent.push(...toolUseContents);
     }
-    return "client_error";
+    const claudeResponse = {
+      role: "assistant",
+      content: claudeContent
+    };
+    return claudeResponse;
   }
   /**
-   * 根据 HTTP 状态码分类错误
+   * 转换工具定义列表
    */
-  static classifyHttpError(status) {
-    if (status === 401 || status === 403) return "auth_error";
-    if (status === 429) return "rate_limit_error";
-    if (status === 408 || status === 504) return "timeout_error";
-    if (status >= 500) return "server_error";
-    if (status >= 400) return "client_error";
-    return "unknown_error";
+  convertToolDefinitions(tools) {
+    return tools.map((tool) => {
+      if (ToolConverter.isOpenAIToolFormat(tool)) {
+        return tool;
+      } else {
+        return ToolConverter.convertAnthropicToolToOpenAI(tool);
+      }
+    });
   }
   /**
-   * 评估错误严重程度
+   * 验证Claude请求格式
    */
-  static assessSeverity(error) {
-    const message = error.message.toLowerCase();
-    if (message.includes("critical") || message.includes("fatal")) return "critical";
-    if (message.includes("timeout") || message.includes("network")) return "high";
-    if (message.includes("validation") || message.includes("auth")) return "medium";
-    return "low";
+  validateClaudeRequest(request) {
+    return FormatValidator.validateClaudeRequest(request);
   }
   /**
-   * 评估 HTTP 错误严重程度
+   * 验证OpenAI请求格式
    */
-  static assessHttpSeverity(status) {
-    if (status >= 500) return "critical";
-    if (status === 429 || status === 408 || status === 504) return "high";
-    if (status === 401 || status === 403) return "medium";
-    return "low";
+  validateOpenAIRequest(request) {
+    return FormatValidator.validateOpenAIRequest(request);
   }
   /**
-   * 根据消息内容分类错误
+   * 获取支持的工具列表
    */
-  static classifyErrorMessage(message) {
-    const lowerMessage = message.toLowerCase();
-    if (lowerMessage.includes("validation")) return "validation_error";
-    if (lowerMessage.includes("timeout")) return "timeout_error";
-    if (lowerMessage.includes("network")) return "network_error";
-    if (lowerMessage.includes("auth")) return "auth_error";
-    if (lowerMessage.includes("rate")) return "rate_limit_error";
-    if (lowerMessage.includes("quota")) return "quota_error";
-    return "unknown_error";
+  getSupportedTools() {
+    return [];
   }
   /**
-   * 评估消息严重程度
+   * 检查工具是否支持
    */
-  static assessMessageSeverity(message) {
-    const lowerMessage = message.toLowerCase();
-    if (lowerMessage.includes("critical") || lowerMessage.includes("fatal")) return "critical";
-    if (lowerMessage.includes("error")) return "high";
-    if (lowerMessage.includes("warning")) return "medium";
-    return "low";
+  isToolSupported(_toolName) {
+    return true;
   }
-};
-var RECOVERY_STRATEGIES = [
-  // 网络错误恢复
-  {
-    id: "network-retry",
-    name: "Network Error Retry",
-    description: "Retry request after network errors",
-    supportedErrors: ["network_error", "timeout_error"],
-    maxRetries: 3,
-    backoffMs: 1e3,
-    condition: (error) => ["network_error", "timeout_error"].includes(error.type),
-    recover: async (error, context) => {
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-      return { retryRecommended: true, backoffMs: 2e3 };
-    }
-  },
-  // 限流错误恢复
-  {
-    id: "rate-limit-backoff",
-    name: "Rate Limit Backoff",
-    description: "Exponential backoff for rate limit errors",
-    supportedErrors: ["rate_limit_error"],
-    maxRetries: 5,
-    backoffMs: 5e3,
-    condition: (error) => error.type === "rate_limit_error",
-    recover: async (error, context) => {
-      const backoffTime = Math.min(3e4, 5e3 * Math.pow(2, context.attemptCount));
-      await new Promise((resolve) => setTimeout(resolve, backoffTime));
-      return { retryRecommended: true, backoffMs: backoffTime };
-    }
-  },
-  // 验证错误恢复
-  {
-    id: "validation-healing",
-    name: "Validation Error Healing",
-    description: "Attempt to fix validation errors automatically",
-    supportedErrors: ["validation_error"],
-    maxRetries: 2,
-    backoffMs: 0,
-    condition: (error) => error.type === "validation_error",
-    recover: async (error, context) => {
-      const { protocolHealer: protocolHealer3 } = await Promise.resolve().then(() => (init_protocol_healer(), protocol_healer_exports));
-      if (context.direction === "a2o") {
-        const healResult = await protocolHealer3.healA2ORequest(context.originalData);
-        if (healResult.success) {
-          return {
-            retryRecommended: true,
-            healedData: healResult.data,
-            appliedFixes: healResult.appliedFixes
-          };
-        }
-      } else if (context.direction === "o2a") {
-        const healResult = await protocolHealer3.healO2ARequest(context.originalData);
-        if (healResult.success) {
-          return {
-            retryRecommended: true,
-            healedData: healResult.data,
-            appliedFixes: healResult.appliedFixes
-          };
-        }
-      }
-      return { retryRecommended: false, reason: "Healing failed" };
-    }
-  },
-  // 模型不可用恢复
-  {
-    id: "model-fallback",
-    name: "Model Fallback",
-    description: "Fallback to alternative models when primary model is unavailable",
-    supportedErrors: ["server_error", "client_error"],
-    maxRetries: 2,
-    backoffMs: 0,
-    condition: (error) => {
-      return error.message.toLowerCase().includes("model") && ["server_error", "client_error"].includes(error.type);
-    },
-    recover: async (error, context) => {
-      const data = context.originalData;
-      if (!data?.model) {
-        return { retryRecommended: false, reason: "No model specified" };
-      }
-      const fallbackMappings = {
-        "gpt-4": ["gpt-4-turbo", "gpt-3.5-turbo"],
-        "gpt-4-turbo": ["gpt-3.5-turbo", "gpt-3.5-turbo-16k"],
-        "claude-3-opus-20240229": ["claude-3-sonnet-20240229", "claude-3-haiku-20240307"],
-        "claude-3-5-sonnet-20241022": ["claude-3-sonnet-20240229", "claude-3-haiku-20240307"]
-      };
-      const fallbacks = fallbackMappings[data.model];
-      if (!fallbacks || context.attemptCount >= fallbacks.length) {
-        return { retryRecommended: false, reason: "No more fallback models" };
+  /**
+   * 获取工具映射（已弃用，保持兼容性）
+   */
+  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.`);
+        }
       }
-      const fallbackModel = fallbacks[context.attemptCount];
-      return {
-        retryRecommended: true,
-        healedData: { ...data, model: fallbackModel },
-        appliedFixes: [`Model fallback: ${data.model} \u2192 ${fallbackModel}`]
-      };
     }
-  },
-  // 认证错误恢复
-  {
-    id: "auth-refresh",
-    name: "Authentication Refresh",
-    description: "Attempt to refresh authentication",
-    supportedErrors: ["auth_error"],
-    maxRetries: 1,
-    backoffMs: 0,
-    condition: (error) => error.type === "auth_error",
-    recover: async (error, context) => {
-      return {
-        retryRecommended: false,
-        reason: "Authentication refresh not implemented - check API keys"
-      };
+    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;
   }
-];
-var ErrorRecovery = class {
-  constructor(customStrategies = [], maxGlobalRetries = 5) {
-    this.strategies = [...RECOVERY_STRATEGIES, ...customStrategies];
-    this.maxGlobalRetries = maxGlobalRetries;
+  /**
+   * 执行基础转换逻辑（原有逻辑的提取）
+   */
+  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;
   }
   /**
-   * 尝试从错误中恢复
+   * 应用同步修复逻辑
+   * 简化版的修复，不依赖异步操作
    */
-  async attemptRecovery(error, context) {
-    const startTime = Date.now();
-    const errorInfo = ErrorDetector.analyzeError(error, context);
-    const messages = [];
-    messages.push(`Analyzing error: ${errorInfo.type} - ${errorInfo.message}`);
-    const applicableStrategies = this.strategies.filter(
-      (strategy) => strategy.condition(errorInfo, context)
-    );
-    if (applicableStrategies.length === 0) {
-      return {
-        success: false,
-        error: errorInfo,
-        attemptCount: context.attemptCount,
-        totalTime: Date.now() - startTime,
-        messages: [...messages, "No applicable recovery strategies found"]
-      };
+  applySyncHealing(request) {
+    const healedRequest = { ...request };
+    if (!healedRequest.max_tokens || healedRequest.max_tokens <= 0) {
+      healedRequest.max_tokens = 4096;
     }
-    for (const strategy of applicableStrategies) {
-      if (context.attemptCount >= strategy.maxRetries) {
-        messages.push(`Strategy ${strategy.name} exceeded max retries (${strategy.maxRetries})`);
-        continue;
+    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 (context.attemptCount >= this.maxGlobalRetries) {
-        messages.push(`Global retry limit exceeded (${this.maxGlobalRetries})`);
-        break;
+      if (!message.content) {
+        message.content = "";
       }
-      try {
-        messages.push(`Attempting recovery with strategy: ${strategy.name}`);
-        const recoveryResult = await strategy.recover(errorInfo, context);
-        if (recoveryResult.retryRecommended) {
-          return {
-            success: true,
-            data: recoveryResult.healedData || context.originalData,
-            strategy: strategy.name,
-            attemptCount: context.attemptCount + 1,
-            totalTime: Date.now() - startTime,
-            messages: [
-              ...messages,
-              `Recovery successful with ${strategy.name}`,
-              ...recoveryResult.appliedFixes || []
-            ]
-          };
-        } else {
-          messages.push(`Strategy ${strategy.name} declined to retry: ${recoveryResult.reason || "Unknown reason"}`);
-        }
-      } catch (strategyError) {
-        messages.push(`Strategy ${strategy.name} failed: ${strategyError.message}`);
+    }
+    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 {
-      success: false,
-      error: errorInfo,
-      attemptCount: context.attemptCount,
-      totalTime: Date.now() - startTime,
-      messages: [...messages, "All recovery strategies failed"]
+    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;
+  }
+};
+
+// 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()
     };
   }
-  /**
-   * 检查错误是否可恢复
-   */
-  isRecoverable(error, context) {
-    const errorInfo = ErrorDetector.analyzeError(error, context);
-    const hasApplicableStrategy = this.strategies.some(
-      (strategy) => strategy.condition(errorInfo, context) && context.attemptCount < strategy.maxRetries
-    );
-    const withinGlobalLimit = context.attemptCount < this.maxGlobalRetries;
-    return hasApplicableStrategy && withinGlobalLimit;
+  logDebug(message, meta) {
+    if (this.config.debugMode) {
+      this.config.logger.debug(message, meta);
+    }
   }
   /**
-   * 获取错误的恢复建议
+   * 转换Anthropic请求为OpenAI格式
    */
-  getRecoveryRecommendations(error, context) {
-    const errorInfo = ErrorDetector.analyzeError(error, context);
-    const applicableStrategies = this.strategies.filter(
-      (strategy) => strategy.condition(errorInfo, context)
-    );
-    const estimatedTime = applicableStrategies.reduce(
-      (total, strategy) => total + strategy.backoffMs,
-      0
-    );
-    let confidence = 0;
-    if (applicableStrategies.length > 0) {
-      const severityWeight = {
-        low: 0.9,
-        medium: 0.7,
-        high: 0.5,
-        critical: 0.2
-      }[errorInfo.severity];
-      const strategyWeight = Math.min(1, applicableStrategies.length / 3);
-      confidence = severityWeight * strategyWeight;
+  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 {
-      isRecoverable: this.isRecoverable(error, context),
-      strategies: applicableStrategies.map((s) => s.name),
-      estimatedTime,
-      confidence
+      openaiRequest,
+      metadata: {
+        hasImages,
+        requiresVisionHeaders: hasImages
+      }
     };
   }
   /**
-   * 添加自定义恢复策略
+   * 与StandardProtocolAdapter保持一致的API，用于集成测试和向后兼容。
    */
-  addStrategy(strategy) {
-    this.strategies.push(strategy);
+  convertRequest(anthropicRequest) {
+    return this.convertAnthropicToOpenAI(anthropicRequest);
   }
   /**
-   * 移除恢复策略
+   * 转换OpenAI流式响应为Anthropic SSE格式
    */
-  removeStrategy(strategyId) {
-    const index = this.strategies.findIndex((s) => s.id === strategyId);
-    if (index >= 0) {
-      this.strategies.splice(index, 1);
-      return true;
+  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
+        };
+      }
+      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
+      };
     }
-    return false;
-  }
-  /**
-   * 获取所有策略信息
-   */
-  getStrategies() {
-    return this.strategies.map((strategy) => ({
-      id: strategy.id,
-      name: strategy.name,
-      description: strategy.description,
-      supportedErrors: strategy.supportedErrors,
-      maxRetries: strategy.maxRetries,
-      backoffMs: strategy.backoffMs
-    }));
-  }
-};
-var errorRecovery = new ErrorRecovery();
-var attemptRecovery = (error, context) => errorRecovery.attemptRecovery(error, context);
-var isRecoverable = (error, context) => errorRecovery.isRecoverable(error, context);
-var getRecoveryRecommendations = (error, context) => errorRecovery.getRecoveryRecommendations(error, context);
-
-// src/core/a2o-request-adapter/adapter.ts
-var A2ORequestAdapter = class {
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
   }
   /**
-   * 转换Anthropic请求格式为OpenAI兼容格式 - 增强版
-   * 集成校验、修复和错误恢复功能
+   * 将OpenAI流转换为Anthropic SSE格式
    */
-  async convertAnthropicRequestToOpenAIEnhanced(anthropicRequest) {
-    const startTime = Date.now();
-    const result = {
-      success: false,
-      originalData: anthropicRequest,
-      warnings: [],
-      errors: [],
-      healingApplied: false,
-      appliedFixes: []
-    };
-    try {
-      let validatedInput;
-      if (this.config.validation.enabled) {
-        if (this.config.validation.strict) {
-          try {
-            validatedInput = validateAnthropicRequest(anthropicRequest);
-            result.validationResult = {
-              inputValid: true,
-              outputValid: false,
-              issues: []
-            };
-          } catch (error) {
-            result.errors.push(`Input validation failed: ${error.message}`);
-            return result;
-          }
-        } else {
-          if (this.config.healing.enabled) {
-            const healingResult = await healA2ORequest(anthropicRequest, this.config.healing.maxAttempts);
-            if (healingResult.success) {
-              validatedInput = healingResult.data;
-              result.healingApplied = true;
-              result.appliedFixes = healingResult.appliedFixes;
-              result.warnings.push(...healingResult.warnings);
-            } else {
-              result.errors.push(...healingResult.errors);
-              return result;
-            }
-          } else {
-            try {
-              validatedInput = validateAnthropicRequest(anthropicRequest);
-            } catch {
-              validatedInput = anthropicRequest;
-              result.warnings.push("Input validation skipped due to errors");
-            }
-          }
+  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;
         }
-      } else {
-        validatedInput = anthropicRequest;
-      }
-      const openaiRequest = await this.performCoreConversion(validatedInput);
-      if (this.config.validation.enabled) {
         try {
-          const validatedOutput = validateOpenAIRequest(openaiRequest);
-          result.data = validatedOutput;
-          result.validationResult = {
-            inputValid: true,
-            outputValid: true,
-            issues: []
-          };
+          const chunk = JSON.parse(dataLine);
+          this.processStreamChunk(chunk, state, sseLines);
         } catch (error) {
-          if (this.config.validation.strict) {
-            result.errors.push(`Output validation failed: ${error.message}`);
-            return result;
-          } else {
-            result.warnings.push(`Output validation warning: ${error.message}`);
-            result.data = openaiRequest;
+          if (this.config.debugMode) {
+            this.config.logger.warn("Failed to parse stream chunk", { line: dataLine.substring(0, 200) });
           }
         }
-      } 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
-          });
-        }
-      }
-      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 openaiRequest = {
-      model: anthropicRequest.model,
-      messages: MessageConverter.convertMessages(anthropicRequest.messages, anthropicRequest.system),
-      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;
+    return sseLines.join("\n");
   }
   /**
-   * 转换Anthropic请求格式为OpenAI兼容格式 - 原有方法保持兼容
+   * 处理单个流式数据块 - 支持thinking和content双模式
    */
-  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);
+  processStreamChunk(chunk, state, sseLines) {
+    if (this.isResponsesEvent(chunk)) {
+      this.processResponsesEvent(chunk, state, sseLines);
+      return;
     }
-    const specialFields = ["_anthropic_protocol", "_rovo_tool_injected", "_routeResult"];
-    for (const field of specialFields) {
-      if (anthropicRequest[field] !== void 0) {
-        openaiRequest[field] = anthropicRequest[field];
+    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 });
       }
     }
-    if (this.config.enableFormatValidation && !FormatValidator.validateOpenAIRequest(openaiRequest)) {
-      throw new Error("Generated OpenAI request format is invalid");
+    if (!choice) {
+      this.updateUsageFromChunk(chunk, state);
+      return;
     }
-    return openaiRequest;
+    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响应格式为Claude兼容格式
+   * 处理工具调用 - 支持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
    */
-  convertOpenAIResponseToClaude(openaiResponse) {
-    const claudeContent = [];
-    const message = openaiResponse.choices?.[0]?.message;
-    if (message?.content) {
-      claudeContent.push({
-        type: "text",
-        text: message.content
+  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;
+      }
+      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);
+      }
     }
-    if (message?.tool_calls) {
-      const toolUseContents = ToolConverter.convertOpenAIToolCallsToClaude(message.tool_calls);
-      claudeContent.push(...toolUseContents);
+  }
+  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);
     }
-    const claudeResponse = {
-      role: "assistant",
-      content: claudeContent
-    };
-    return claudeResponse;
+    return existing;
   }
-  /**
-   * 转换工具定义列表
-   */
-  convertToolDefinitions(tools) {
-    return tools.map((tool) => {
-      if (ToolConverter.isOpenAIToolFormat(tool)) {
-        return tool;
-      } else {
-        return ToolConverter.convertAnthropicToolToOpenAI(tool);
-      }
-    });
+  registerToolCallAlias(state, alias, toolData) {
+    if (!alias) return;
+    const current = state.toolCallsMap.get(alias);
+    if (!current || current !== toolData) {
+      state.toolCallsMap.set(alias, toolData);
+    }
   }
-  /**
-   * 验证Claude请求格式
-   */
-  validateClaudeRequest(request) {
-    return FormatValidator.validateClaudeRequest(request);
+  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;
   }
-  /**
-   * 验证OpenAI请求格式
-   */
-  validateOpenAIRequest(request) {
-    return FormatValidator.validateOpenAIRequest(request);
+  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 });
+    }
   }
-  /**
-   * 获取支持的工具列表
-   */
-  getSupportedTools() {
-    return [];
+  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;
   }
-  /**
-   * 检查工具是否支持
-   */
-  isToolSupported(_toolName) {
-    return true;
+  appendThinkingContent(content, state, sseLines) {
+    if (!content) return;
+    state.reasoningContent += 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;
+    }
+    sseLines.push(
+      "event: content_block_delta",
+      `data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"${this.escapeJsonString(content)}"}}`,
+      ""
+    );
   }
-  /**
-   * 获取工具映射（已弃用，保持兼容性）
-   */
-  getToolMapping(claudeToolName) {
-    return claudeToolName;
+  appendTextContent(content, state, sseLines) {
+    if (!content || content === "") return;
+    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;
+    }
+    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)}"}}`,
+      ""
+    );
   }
-  /**
-   * 更新配置
-   */
-  updateConfig(newConfig) {
-    this.config = { ...this.config, ...newConfig };
+  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;
+    }
   }
-  /**
-   * 获取当前配置
-   */
-  getConfig() {
-    return { ...this.config };
+  isResponsesEvent(chunk) {
+    return typeof chunk?.type === "string" && chunk.type.startsWith("response.");
   }
-  /**
-   * 执行带验证的核心转换（同步版本）
-   * 为静态方法提供增强功能，但保持同步特性
-   */
-  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.`);
-        }
-      }
+  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;
     }
-    let processedRequest = anthropicRequest;
-    if (this.config.healing.enabled) {
-      try {
-        processedRequest = this.applySyncHealing(anthropicRequest);
-      } catch (healingError) {
-        console.warn("[A2ORequestAdapter] Healing failed:", healingError);
+  }
+  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;
       }
     }
-    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);
-        }
+    if (!toolData) {
+      const baseAlias = aliases[0] ?? `responses_auto_${++state.toolCallCounter}`;
+      toolData = this.getOrCreateToolCallState(state, baseAlias);
+      if (!aliases.length) {
+        aliases.push(baseAlias);
       }
     }
-    return result;
+    for (const alias of aliases) {
+      this.registerToolCallAlias(state, alias, toolData);
+    }
+    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 (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);
+    }
+  }
+  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;
+    }
+    const name = event.name ?? event.function_name ?? event.function?.name;
+    if (name) {
+      toolData.name = name;
+    }
+    const argsChunk = this.extractArgumentsDelta(event);
+    if (argsChunk) {
+      toolData.pendingChunks.push(argsChunk);
+    }
+    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 });
     }
-    if (this.config.enableFormatValidation && !FormatValidator.validateOpenAIRequest(openaiRequest)) {
-      throw new Error("Generated OpenAI request format is invalid");
+  }
+  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 openaiRequest;
+    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;
   }
   /**
-   * 应用同步修复逻辑
-   * 简化版的修复，不依赖异步操作
+   * 在流结束时关闭所有未关闭的工具调用块
    */
-  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";
+  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_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}',
+        ""
+      );
+    }
+    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
+    };
+  }
   /**
-   * 转换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
+    }));
+  }
   /**
-   * 验证Claude请求格式（静态方法）
+   * 映射Anthropic模型到OpenAI模型
    */
-  validateClaudeRequest: (request) => {
-    return FormatValidator.validateClaudeRequest(request);
-  },
+  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";
+  }
   /**
-   * 验证OpenAI请求格式（静态方法）
+   * 检查请求是否包含图片内容
    */
-  validateOpenAIRequest: (request) => {
-    return FormatValidator.validateOpenAIRequest(request);
-  },
+  hasImageContent(request) {
+    return request.messages.some(
+      (msg) => Array.isArray(msg.content) && msg.content.some((content) => content?.type === "image")
+    );
+  }
   /**
-   * 获取支持的工具列表（静态方法）
+   * 转义JSON字符串
    */
-  getSupportedTools: () => {
-    return [];
-  },
+  escapeJsonString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  }
   /**
-   * 检查工具是否支持（静态方法）
+   * 获取初始SSE事件（message_start + ping）
    */
-  isToolSupported: (_toolName) => {
-    return true;
-  },
+  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事件
+   * 用于逐个处理流式数据片段
    */
-  getToolMapping: (claudeToolName) => {
-    return claudeToolName;
+  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 [];
+    }
+  }
+  /**
+   * 暴露内部状态创建方法，供外部增量处理流程使用。
+   */
+  createIncrementalState() {
+    return this.createConversionState();
   }
 };