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

package/dist/index.mjs

@@ -581,17 +581,32 @@ var StreamingProtocolAdapter = class {
   processToolCalls(toolCalls, state, sseLines) {
     for (const toolCall of toolCalls) {
       if (toolCall.id && toolCall.function?.name) {
+        const toolArgs = toolCall.function.arguments || "";
         const toolData = {
           id: toolCall.id,
           name: toolCall.function.name,
-          input: toolCall.function.arguments || ""
+          input: toolArgs
         };
         state.toolCallsMap.set(toolCall.id, toolData);
+        const blockIndex = state.completedToolCalls.length + 1;
         sseLines.push(
           "event: content_block_start",
-          `data: {"type":"content_block_start","index":${state.completedToolCalls.length + 1},"content_block":{"type":"tool_use","id":"${toolCall.id}","name":"${toolCall.function.name}","input":{}}}`,
+          `data: {"type":"content_block_start","index":${blockIndex},"content_block":{"type":"tool_use","id":"${toolCall.id}","name":"${toolCall.function.name}","input":{}}}`,
           ""
         );
+        if (toolArgs) {
+          sseLines.push(
+            "event: content_block_delta",
+            `data: {"type":"content_block_delta","index":${blockIndex},"delta":{"type":"input_json_delta","partial_json":${JSON.stringify(toolArgs)}}}`,
+            ""
+          );
+        }
+        sseLines.push(
+          "event: content_block_stop",
+          `data: {"type":"content_block_stop","index":${blockIndex}}`,
+          ""
+        );
+        state.completedToolCalls.push(toolCall.id);
       }
     }
   }
@@ -616,9 +631,10 @@ var StreamingProtocolAdapter = class {
         ""
       );
     }
+    const stopReason = state.completedToolCalls.length > 0 ? "tool_use" : "end_turn";
     sseLines.push(
       "event: message_delta",
-      `data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":${state.usage.output_tokens}}}`,
+      `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"}',
@@ -4151,15 +4167,28 @@ var ToolCallProcessor = class _ToolCallProcessor {
    * 处理增量工具调用
    */
   static processIncrementalToolCalls(toolCalls, state, sseLines) {
+    console.log("\u{1F50D}\u{1F50D}\u{1F50D} [ToolProcessor] processIncrementalToolCalls called with:", JSON.stringify(toolCalls, null, 2));
     for (const toolCall of toolCalls) {
       const toolId = toolCall.id;
       const toolName = toolCall.function?.name;
       const toolArgs = toolCall.function?.arguments;
+      console.log("\u{1F50D} [ToolProcessor] Processing tool call:", {
+        toolId,
+        toolName,
+        toolArgs: toolArgs || "UNDEFINED",
+        toolArgsType: typeof toolArgs,
+        toolArgsLength: toolArgs?.length || 0,
+        hasArgs: !!toolArgs
+      });
       if (toolName && toolId && !state.toolCallsMap.has(toolId)) {
+        console.log("\u2705 [ToolProcessor] Starting new tool call:", toolName);
         _ToolCallProcessor.processToolCallStart(toolId, toolName, state, sseLines);
       }
       if (toolArgs) {
+        console.log("\u2705 [ToolProcessor] Processing tool args, calling processToolArgs");
         _ToolCallProcessor.processToolArgs(toolId, toolArgs, state, sseLines);
+      } else {
+        console.warn("\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F [ToolProcessor] No tool args to process! This will result in empty input!");
       }
     }
   }
@@ -4167,15 +4196,28 @@ var ToolCallProcessor = class _ToolCallProcessor {
    * 处理工具调用
    */
   static processBatchToolCalls(toolCalls, state, sseLines) {
+    console.log("\u{1F50D}\u{1F50D}\u{1F50D} [ToolProcessor] processBatchToolCalls called with:", JSON.stringify(toolCalls, null, 2));
     for (const toolCall of toolCalls) {
       const toolId = toolCall.id;
       const toolName = toolCall.function?.name;
       const toolArgs = toolCall.function?.arguments;
+      console.log("\u{1F50D} [ToolProcessor] Processing batch tool call:", {
+        toolId,
+        toolName,
+        toolArgs: toolArgs || "UNDEFINED",
+        toolArgsType: typeof toolArgs,
+        toolArgsLength: toolArgs?.length || 0,
+        hasArgs: !!toolArgs
+      });
       if (toolName && toolId && !state.toolCallsMap.has(toolId)) {
+        console.log("\u2705 [ToolProcessor] Starting new batch tool call:", toolName);
         _ToolCallProcessor.processToolCallStart(toolId, toolName, state, sseLines);
       }
       if (toolArgs) {
+        console.log("\u2705 [ToolProcessor] Processing batch tool args, calling processToolArgs");
         _ToolCallProcessor.processToolArgs(toolId, toolArgs, state, sseLines);
+      } else {
+        console.warn("\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F [ToolProcessor] No batch tool args to process! This will result in empty input!");
       }
     }
   }
@@ -4373,6 +4415,247 @@ function generateMessageId() {
   return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
 }
 
+// src/core/o2a-sse-adapter/stream-converter.ts
+var StreamConverter = class {
+  constructor(adapter, options = {}) {
+    this.buffer = "";
+    this.adapter = adapter;
+    this.options = {
+      bufferTimeout: 5e3,
+      errorRecovery: true,
+      maxRetries: 3,
+      debug: false,
+      ...options
+    };
+    this.state = this.adapter.createIncrementalState();
+    this.stats = {
+      chunksProcessed: 0,
+      eventsGenerated: 0,
+      errors: 0,
+      retries: 0,
+      startTime: Date.now(),
+      lastUpdateTime: Date.now(),
+      bufferSize: 0
+    };
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u5DF2\u521D\u59CB\u5316\uFF0C\u914D\u7F6E:", this.options);
+    }
+  }
+  /**
+   * 获取初始事件
+   */
+  getInitialEvents() {
+    const events = this.adapter.getInitialSSEEvents(
+      this.options.modelName,
+      this.options.messageId
+    );
+    this.stats.eventsGenerated += events.length;
+    this.stats.lastUpdateTime = Date.now();
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u751F\u6210\u521D\u59CB\u4E8B\u4EF6:", events.length, "\u4E2A");
+    }
+    return events;
+  }
+  /**
+   * 处理单个数据块
+   */
+  processChunk(chunk) {
+    this.stats.chunksProcessed++;
+    this.stats.lastUpdateTime = Date.now();
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u5904\u7406\u6570\u636E\u5757:", chunk.substring(0, 100) + "...");
+    }
+    try {
+      const events = this.processBufferedData(chunk);
+      this.stats.eventsGenerated += events.length;
+      if (this.options.onChunkProcessed) {
+        this.options.onChunkProcessed(chunk, events);
+      }
+      return events;
+    } catch (error) {
+      return this.handleChunkError(error, chunk);
+    }
+  }
+  /**
+   * 结束流处理
+   */
+  finalize() {
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u7ED3\u675F\u6D41\u5904\u7406\uFF0C\u7F13\u51B2\u533A\u5927\u5C0F:", this.buffer.length);
+    }
+    let events = [];
+    if (this.buffer.trim()) {
+      console.warn("[StreamConverter] \u7F13\u51B2\u533A\u4E2D\u6709\u672A\u5904\u7406\u6570\u636E\uFF0C\u5F3A\u5236\u5904\u7406:", this.buffer);
+      events = this.processIncompleteBuffer();
+    }
+    try {
+      const finalEvents = this.adapter.convertIncrementalChunk("[DONE]", this.state);
+      events.push(...finalEvents);
+      this.stats.eventsGenerated += finalEvents.length;
+    } catch (error) {
+      console.error("[StreamConverter] \u5904\u7406\u7ED3\u675F\u4E8B\u4EF6\u5931\u8D25:", error);
+    }
+    this.clearBufferTimeout();
+    this.stats.lastUpdateTime = Date.now();
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u6D41\u5904\u7406\u5B8C\u6210\uFF0C\u7EDF\u8BA1\u4FE1\u606F:", this.stats);
+    }
+    return events;
+  }
+  /**
+   * 获取当前状态
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * 重置状态
+   */
+  reset() {
+    this.state = this.adapter.createIncrementalState();
+    this.buffer = "";
+    this.clearBufferTimeout();
+    this.stats = {
+      chunksProcessed: 0,
+      eventsGenerated: 0,
+      errors: 0,
+      retries: 0,
+      startTime: Date.now(),
+      lastUpdateTime: Date.now(),
+      bufferSize: 0
+    };
+    if (this.options.debug) {
+      console.log("[StreamConverter] \u72B6\u6001\u5DF2\u91CD\u7F6E");
+    }
+  }
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      bufferSize: this.buffer.length
+    };
+  }
+  /**
+   * 处理缓冲的数据
+   */
+  processBufferedData(newChunk) {
+    this.buffer += newChunk;
+    this.stats.bufferSize = this.buffer.length;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || "";
+    const events = [];
+    for (const line of lines) {
+      if (line.startsWith("data:")) {
+        const jsonStr = line.slice(5).trim();
+        if (jsonStr && jsonStr !== "[DONE]") {
+          const lineEvents = this.processDataLine(jsonStr);
+          events.push(...lineEvents);
+        } else if (jsonStr === "[DONE]") {
+          const finalEvents = this.adapter.convertIncrementalChunk("[DONE]", this.state);
+          events.push(...finalEvents);
+        }
+      }
+    }
+    this.resetBufferTimeout();
+    return events;
+  }
+  /**
+   * 处理单行数据
+   */
+  processDataLine(jsonStr, attempt = 0) {
+    try {
+      const chunkEvents = this.adapter.convertIncrementalChunk(jsonStr, this.state);
+      if (this.options.debug && chunkEvents.length > 0) {
+        console.log("[StreamConverter] \u751F\u6210\u4E8B\u4EF6:", chunkEvents.length, "\u4E2A");
+      }
+      return chunkEvents;
+    } catch (error) {
+      if (this.options.errorRecovery && attempt < (this.options.maxRetries || 3)) {
+        console.warn(`[StreamConverter] \u5904\u7406\u6570\u636E\u884C\u5931\u8D25\uFF0C\u91CD\u8BD5 ${attempt + 1}/${this.options.maxRetries}:`, error);
+        this.stats.retries++;
+        return this.processDataLine(jsonStr, attempt + 1);
+      }
+      this.stats.errors++;
+      console.error("[StreamConverter] \u5904\u7406\u6570\u636E\u884C\u6700\u7EC8\u5931\u8D25:", error, "Data:", jsonStr);
+      if (this.options.onError) {
+        this.options.onError(error, {
+          chunk: jsonStr,
+          state: this.state,
+          attempt,
+          totalRetries: this.stats.retries
+        });
+      }
+      return [];
+    }
+  }
+  /**
+   * 处理块错误
+   */
+  handleChunkError(error, chunk) {
+    this.stats.errors++;
+    if (this.options.debug) {
+      console.error("[StreamConverter] \u5757\u5904\u7406\u9519\u8BEF:", error.message);
+    }
+    if (!this.options.errorRecovery) {
+      throw error;
+    }
+    this.state.errors.push(`Chunk processing error: ${error.message}`);
+    if (this.options.onError) {
+      this.options.onError(error, {
+        chunk,
+        state: this.state,
+        totalRetries: this.stats.retries
+      });
+    }
+    return [];
+  }
+  /**
+   * 处理不完整的缓冲区数据
+   */
+  processIncompleteBuffer() {
+    if (!this.buffer.trim()) {
+      return [];
+    }
+    console.warn("[StreamConverter] \u5904\u7406\u4E0D\u5B8C\u6574\u7F13\u51B2\u533A\u6570\u636E:", this.buffer);
+    if (this.buffer.startsWith("data:")) {
+      const jsonStr = this.buffer.slice(5).trim();
+      if (jsonStr) {
+        return this.processDataLine(jsonStr);
+      }
+    }
+    return [];
+  }
+  /**
+   * 重置缓冲区超时
+   */
+  resetBufferTimeout() {
+    this.clearBufferTimeout();
+    if (this.options.bufferTimeout && this.options.bufferTimeout > 0) {
+      this.bufferTimeout = setTimeout(() => {
+        if (this.buffer.trim()) {
+          console.warn("[StreamConverter] \u7F13\u51B2\u533A\u8D85\u65F6\uFF0C\u5F3A\u5236\u5904\u7406\u6570\u636E:", this.buffer);
+          const events = this.processIncompleteBuffer();
+          this.buffer = "";
+          if (events.length > 0 && this.options.onChunkProcessed) {
+            this.options.onChunkProcessed("TIMEOUT_FLUSH", events);
+          }
+        }
+      }, this.options.bufferTimeout);
+    }
+  }
+  /**
+   * 清理缓冲区超时
+   */
+  clearBufferTimeout() {
+    if (this.bufferTimeout) {
+      clearTimeout(this.bufferTimeout);
+      this.bufferTimeout = void 0;
+    }
+  }
+};
+
 // src/core/o2a-sse-adapter/adapter.ts
 var O2ASSEAdapter = class {
   constructor(debugMode = false, config = {}) {
@@ -4627,6 +4910,101 @@ var O2ASSEAdapter = class {
   validateClaudeSSE(sseContent) {
     return FormatValidator2.validateClaudeSSE(sseContent);
   }
+  /**
+   * 将 OpenAI Response 流直接转换为 Anthropic SSE 流
+   * 这是新增的核心流式处理方法，支持实时转换
+   */
+  convertResponseStream(openaiResponse, options = {}) {
+    if (!openaiResponse.body) {
+      throw new Error("Response body is null or undefined");
+    }
+    return this.convertReadableStream(openaiResponse.body, options);
+  }
+  /**
+   * 将 ReadableStream 转换为 Anthropic SSE 流
+   */
+  convertReadableStream(openaiStream, options = {}) {
+    const converter = this.createStreamConverter(options);
+    const decoder = new TextDecoder();
+    return new ReadableStream({
+      async start(controller) {
+        if (options.debug) {
+          console.log("[O2ASSEAdapter] \u5F00\u59CB\u6D41\u5F0F\u8F6C\u6362\uFF0C\u914D\u7F6E:", options);
+        }
+        try {
+          const initialEvents = converter.getInitialEvents();
+          for (const event of initialEvents) {
+            controller.enqueue(event);
+          }
+        } catch (error) {
+          console.error("[O2ASSEAdapter] \u521D\u59CB\u5316\u5931\u8D25:", error);
+          controller.error(error);
+          return;
+        }
+        const reader = openaiStream.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              try {
+                const finalEvents = converter.finalize();
+                for (const event of finalEvents) {
+                  controller.enqueue(event);
+                }
+                if (options.debug) {
+                  console.log("[O2ASSEAdapter] \u6D41\u5F0F\u8F6C\u6362\u5B8C\u6210\uFF0C\u7EDF\u8BA1:", converter.getStats());
+                }
+              } catch (error) {
+                console.error("[O2ASSEAdapter] \u7ED3\u675F\u5904\u7406\u5931\u8D25:", error);
+              }
+              break;
+            }
+            const chunk = decoder.decode(value, { stream: true });
+            try {
+              const events = converter.processChunk(chunk);
+              for (const event of events) {
+                controller.enqueue(event);
+              }
+            } catch (error) {
+              console.error("[O2ASSEAdapter] \u5757\u5904\u7406\u5931\u8D25:", error);
+              if (options.errorRecovery === false) {
+                controller.error(error);
+                return;
+              }
+              if (options.onError) {
+                options.onError(error, {
+                  chunk,
+                  state: converter.getState()
+                });
+              }
+            }
+          }
+        } catch (error) {
+          console.error("[O2ASSEAdapter] \u6D41\u5904\u7406\u5931\u8D25:", error);
+          if (options.onError) {
+            options.onError(error, {
+              chunk: "",
+              state: converter.getState()
+            });
+          }
+          controller.error(error);
+        } finally {
+          controller.close();
+        }
+      }
+    });
+  }
+  /**
+   * 创建流式转换器实例
+   * 提供更精细的流处理控制
+   */
+  createStreamConverter(options = {}) {
+    return new StreamConverter(this, {
+      modelName: options.modelName || this.config.defaultModel,
+      debug: options.debug || this.debugMode,
+      ...options
+    });
+  }
   /**
    * 应用增强功能到SSE转换
    * 包括输入验证、输出修复等
@@ -4698,13 +5076,49 @@ var O2ASSEAdapterStatic = {
   validateClaudeSSE: (sseContent) => {
     const adapter = new O2ASSEAdapter(false);
     return adapter.validateClaudeSSE(sseContent);
+  },
+  /**
+   * 转换 Response 流为 Anthropic SSE（静态方法）
+   * 新增：直接处理 Response 对象的流式转换
+   */
+  convertResponseStream: (openaiResponse, options = {}) => {
+    const adapter = new O2ASSEAdapter(options.debug || false, {
+      defaultModel: options.modelName || "claude-sonnet-4",
+      generateUniqueMessageId: !options.messageId,
+      errorDataMaxLength: 500
+    });
+    return adapter.convertResponseStream(openaiResponse, options);
+  },
+  /**
+   * 转换 ReadableStream 为 Anthropic SSE（静态方法）
+   * 新增：处理任意 ReadableStream<Uint8Array> 的流式转换
+   */
+  convertReadableStream: (openaiStream, options = {}) => {
+    const adapter = new O2ASSEAdapter(options.debug || false, {
+      defaultModel: options.modelName || "claude-sonnet-4",
+      generateUniqueMessageId: !options.messageId,
+      errorDataMaxLength: 500
+    });
+    return adapter.convertReadableStream(openaiStream, options);
+  },
+  /**
+   * 创建流式转换器（静态方法）
+   * 新增：提供更精细的流处理控制
+   */
+  createStreamConverter: (options = {}) => {
+    const adapter = new O2ASSEAdapter(options.debug || false, {
+      defaultModel: options.modelName || "claude-sonnet-4",
+      generateUniqueMessageId: !options.messageId,
+      errorDataMaxLength: 500
+    });
+    return adapter.createStreamConverter(options);
   }
 };
 
 // src/core/standard/standard-protocol-adapter.ts
 var StandardProtocolAdapter = class {
   constructor(options = {}) {
-    this.debugMode = options.debugMode || false;
+    this.debugMode = options.debugMode !== void 0 ? options.debugMode : true;
     this.sseAdapter = new O2ASSEAdapter(this.debugMode);
   }
   /**
@@ -4781,6 +5195,8 @@ var StandardProtocolAdapter = class {
     };
     let currentTextContent = "";
     const toolCalls = /* @__PURE__ */ new Map();
+    const toolInputBuffers = /* @__PURE__ */ new Map();
+    const indexToToolId = /* @__PURE__ */ new Map();
     let processedDataLines = 0;
     for (const line of lines) {
       if (line.startsWith("data: ")) {
@@ -4793,15 +5209,22 @@ var StandardProtocolAdapter = class {
           if (data.type === "content_block_start") {
             const contentBlock = data.content_block;
             if (contentBlock.type === "tool_use") {
+              const toolIndex = data.index;
               toolCalls.set(contentBlock.id, {
                 type: "tool_use",
                 id: contentBlock.id,
                 name: contentBlock.name,
                 input: contentBlock.input || {}
+                // 初始为空对象，稍后会被更新
+              });
+              toolInputBuffers.set(toolIndex, "");
+              indexToToolId.set(toolIndex, contentBlock.id);
+              console.log("\u{1F527}\u{1F527}\u{1F527} [StandardProtocolAdapter] \u6DFB\u52A0\u5DE5\u5177\u8C03\u7528:", {
+                index: toolIndex,
+                toolId: contentBlock.id,
+                name: contentBlock.name,
+                indexToToolIdSize: indexToToolId.size
               });
-              if (this.debugMode) {
-                console.log("\u{1F527} [StandardProtocolAdapter] \u6DFB\u52A0\u5DE5\u5177\u8C03\u7528:", contentBlock);
-              }
             }
           }
           if (data.type === "content_block_delta" && data.delta?.type === "text_delta") {
@@ -4811,6 +5234,46 @@ var StandardProtocolAdapter = class {
             }
           }
           if (data.type === "content_block_delta" && data.delta?.type === "input_json_delta") {
+            const toolIndex = data.index;
+            const toolId = indexToToolId.get(toolIndex);
+            console.log(`\u{1F527}\u{1F527}\u{1F527} [StandardProtocolAdapter] \u68C0\u6D4B\u5230input_json_delta\u4E8B\u4EF6\uFF01`, {
+              toolIndex,
+              toolId: toolId || "NOT_FOUND",
+              delta: data.delta.partial_json
+            });
+            if (toolId) {
+              const currentBuffer = toolInputBuffers.get(toolIndex) || "";
+              const newBuffer = currentBuffer + data.delta.partial_json;
+              toolInputBuffers.set(toolIndex, newBuffer);
+              console.log(`\u{1F527} [StandardProtocolAdapter] \u7D2F\u79EF\u5DE5\u5177\u53C2\u6570 (index=${toolIndex}, id=${toolId}):`, {
+                delta: data.delta.partial_json,
+                bufferLength: newBuffer.length
+              });
+            } else {
+              console.warn(`\u26A0\uFE0F [StandardProtocolAdapter] \u627E\u4E0D\u5230toolId for index=${toolIndex}`);
+            }
+          }
+          if (data.type === "content_block_stop") {
+            const toolIndex = data.index;
+            const toolId = indexToToolId.get(toolIndex);
+            if (toolId) {
+              const jsonBuffer = toolInputBuffers.get(toolIndex);
+              const tool = toolCalls.get(toolId);
+              if (jsonBuffer && tool) {
+                try {
+                  const parsedInput = JSON.parse(jsonBuffer);
+                  tool.input = parsedInput;
+                  if (this.debugMode) {
+                    console.log(`\u2705 [StandardProtocolAdapter] \u5DE5\u5177\u53C2\u6570\u89E3\u6790\u5B8C\u6210 (index=${toolIndex}, id=${toolId}):`, parsedInput);
+                  }
+                } catch (parseError) {
+                  console.warn(`\u26A0\uFE0F [StandardProtocolAdapter] \u5DE5\u5177\u53C2\u6570JSON\u89E3\u6790\u5931\u8D25 (index=${toolIndex}, id=${toolId}):`, {
+                    buffer: jsonBuffer,
+                    error: parseError
+                  });
+                }
+              }
+            }
           }
           if (data.type === "message_delta") {
             if (data.delta?.stop_reason) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-protocol-adapters",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "description": "Universal AI Protocol Converter - OpenAI ⇄ Anthropic with full TypeScript support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",