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

package/README.md

@@ -1,6 +1,6 @@
-# @ai-protocol/adapters
+# ai-protocol-adapters
 
-[![npm version](https://badge.fury.io/js/@ai-protocol%2Fadapters.svg)](https://badge.fury.io/js/@ai-protocol%2Fadapters)
+[![npm version](https://badge.fury.io/js/ai-protocol-adapters.svg)](https://badge.fury.io/js/ai-protocol-adapters)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
 
@@ -19,15 +19,15 @@
 ## 📦 安装
 
 ```bash
-npm install @ai-protocol/adapters
+npm install ai-protocol-adapters
 ```
 
 ```bash
-yarn add @ai-protocol/adapters
+yarn add ai-protocol-adapters
 ```
 
 ```bash
-pnpm add @ai-protocol/adapters
+pnpm add ai-protocol-adapters
 ```
 
 ## 🚀 快速开始
@@ -35,7 +35,7 @@ pnpm add @ai-protocol/adapters
 ### 基础使用
 
 ```typescript
-import { StreamingProtocolAdapter } from '@ai-protocol/adapters'
+import { StreamingProtocolAdapter } from 'ai-protocol-adapters'
 
 // 创建适配器实例
 const adapter = new StreamingProtocolAdapter({
@@ -103,7 +103,7 @@ const { openaiRequest } = adapter.convertAnthropicToOpenAI(glmRequest)
 ### 自定义日志器
 
 ```typescript
-import { setGlobalLogger, StreamingProtocolAdapter } from '@ai-protocol/adapters'
+import { setGlobalLogger, StreamingProtocolAdapter } from 'ai-protocol-adapters'
 
 // 使用自定义日志器
 setGlobalLogger({

package/dist/index.d.mts

@@ -6029,6 +6029,89 @@ declare class FormatValidator {
     };
 }
 
+/**
+ * 流式处理相关类型定义
+ */
+
+/**
+ * 流式转换配置选项
+ */
+interface StreamConversionOptions {
+    /** 模型名称 */
+    modelName?: string;
+    /** 消息ID */
+    messageId?: string;
+    /** 缓冲区超时时间（毫秒） */
+    bufferTimeout?: number;
+    /** 是否启用错误恢复 */
+    errorRecovery?: boolean;
+    /** 最大重试次数 */
+    maxRetries?: number;
+    /** 块处理回调 */
+    onChunkProcessed?: (chunk: string, events: string[]) => void;
+    /** 错误回调 */
+    onError?: (error: Error, context: StreamErrorContext) => void;
+    /** 调试模式 */
+    debug?: boolean;
+}
+/**
+ * 流式错误上下文
+ */
+interface StreamErrorContext {
+    chunk: string;
+    state: IncrementalConversionState;
+    attempt?: number;
+    totalRetries?: number;
+}
+/**
+ * 流式转换器接口
+ */
+interface IStreamConverter {
+    /**
+     * 获取初始事件
+     */
+    getInitialEvents(): string[];
+    /**
+     * 处理单个数据块
+     */
+    processChunk(chunk: string): string[];
+    /**
+     * 结束流处理
+     */
+    finalize(): string[];
+    /**
+     * 获取当前状态
+     */
+    getState(): IncrementalConversionState;
+    /**
+     * 重置状态
+     */
+    reset(): void;
+    /**
+     * 获取统计信息
+     */
+    getStats(): StreamStats;
+}
+/**
+ * 流式处理统计信息
+ */
+interface StreamStats {
+    /** 处理的块数量 */
+    chunksProcessed: number;
+    /** 生成的事件数量 */
+    eventsGenerated: number;
+    /** 错误数量 */
+    errors: number;
+    /** 重试次数 */
+    retries: number;
+    /** 处理开始时间 */
+    startTime: number;
+    /** 最后更新时间 */
+    lastUpdateTime: number;
+    /** 缓冲区大小 */
+    bufferSize: number;
+}
+
 /**
  * O2A SSE适配器配置
  */
@@ -6103,6 +6186,20 @@ declare class O2ASSEAdapter {
         errors: string[];
         warnings: string[];
     };
+    /**
+     * 将 OpenAI Response 流直接转换为 Anthropic SSE 流
+     * 这是新增的核心流式处理方法，支持实时转换
+     */
+    convertResponseStream(openaiResponse: Response, options?: StreamConversionOptions): ReadableStream<string>;
+    /**
+     * 将 ReadableStream 转换为 Anthropic SSE 流
+     */
+    convertReadableStream(openaiStream: ReadableStream<Uint8Array>, options?: StreamConversionOptions): ReadableStream<string>;
+    /**
+     * 创建流式转换器实例
+     * 提供更精细的流处理控制
+     */
+    createStreamConverter(options?: StreamConversionOptions): IStreamConverter;
     /**
      * 应用增强功能到SSE转换
      * 包括输入验证、输出修复等
@@ -6135,6 +6232,21 @@ declare const O2ASSEAdapterStatic: {
         errors: string[];
         warnings: string[];
     };
+    /**
+     * 转换 Response 流为 Anthropic SSE（静态方法）
+     * 新增：直接处理 Response 对象的流式转换
+     */
+    convertResponseStream: (openaiResponse: Response, options?: StreamConversionOptions) => ReadableStream<string>;
+    /**
+     * 转换 ReadableStream 为 Anthropic SSE（静态方法）
+     * 新增：处理任意 ReadableStream<Uint8Array> 的流式转换
+     */
+    convertReadableStream: (openaiStream: ReadableStream<Uint8Array>, options?: StreamConversionOptions) => ReadableStream<string>;
+    /**
+     * 创建流式转换器（静态方法）
+     * 新增：提供更精细的流处理控制
+     */
+    createStreamConverter: (options?: StreamConversionOptions) => IStreamConverter;
 };
 
 /**
@@ -7155,7 +7267,7 @@ interface Logger {
 declare function getGlobalLogger(): Logger;
 
 /**
- * @ai-protocol/adapters - Universal AI Protocol Converter
+ * ai-protocol-adapters - Universal AI Protocol Converter
  * OpenAI ⇄ Anthropic with full TypeScript support
  */
 

package/dist/index.d.ts

@@ -6029,6 +6029,89 @@ declare class FormatValidator {
     };
 }
 
+/**
+ * 流式处理相关类型定义
+ */
+
+/**
+ * 流式转换配置选项
+ */
+interface StreamConversionOptions {
+    /** 模型名称 */
+    modelName?: string;
+    /** 消息ID */
+    messageId?: string;
+    /** 缓冲区超时时间（毫秒） */
+    bufferTimeout?: number;
+    /** 是否启用错误恢复 */
+    errorRecovery?: boolean;
+    /** 最大重试次数 */
+    maxRetries?: number;
+    /** 块处理回调 */
+    onChunkProcessed?: (chunk: string, events: string[]) => void;
+    /** 错误回调 */
+    onError?: (error: Error, context: StreamErrorContext) => void;
+    /** 调试模式 */
+    debug?: boolean;
+}
+/**
+ * 流式错误上下文
+ */
+interface StreamErrorContext {
+    chunk: string;
+    state: IncrementalConversionState;
+    attempt?: number;
+    totalRetries?: number;
+}
+/**
+ * 流式转换器接口
+ */
+interface IStreamConverter {
+    /**
+     * 获取初始事件
+     */
+    getInitialEvents(): string[];
+    /**
+     * 处理单个数据块
+     */
+    processChunk(chunk: string): string[];
+    /**
+     * 结束流处理
+     */
+    finalize(): string[];
+    /**
+     * 获取当前状态
+     */
+    getState(): IncrementalConversionState;
+    /**
+     * 重置状态
+     */
+    reset(): void;
+    /**
+     * 获取统计信息
+     */
+    getStats(): StreamStats;
+}
+/**
+ * 流式处理统计信息
+ */
+interface StreamStats {
+    /** 处理的块数量 */
+    chunksProcessed: number;
+    /** 生成的事件数量 */
+    eventsGenerated: number;
+    /** 错误数量 */
+    errors: number;
+    /** 重试次数 */
+    retries: number;
+    /** 处理开始时间 */
+    startTime: number;
+    /** 最后更新时间 */
+    lastUpdateTime: number;
+    /** 缓冲区大小 */
+    bufferSize: number;
+}
+
 /**
  * O2A SSE适配器配置
  */
@@ -6103,6 +6186,20 @@ declare class O2ASSEAdapter {
         errors: string[];
         warnings: string[];
     };
+    /**
+     * 将 OpenAI Response 流直接转换为 Anthropic SSE 流
+     * 这是新增的核心流式处理方法，支持实时转换
+     */
+    convertResponseStream(openaiResponse: Response, options?: StreamConversionOptions): ReadableStream<string>;
+    /**
+     * 将 ReadableStream 转换为 Anthropic SSE 流
+     */
+    convertReadableStream(openaiStream: ReadableStream<Uint8Array>, options?: StreamConversionOptions): ReadableStream<string>;
+    /**
+     * 创建流式转换器实例
+     * 提供更精细的流处理控制
+     */
+    createStreamConverter(options?: StreamConversionOptions): IStreamConverter;
     /**
      * 应用增强功能到SSE转换
      * 包括输入验证、输出修复等
@@ -6135,6 +6232,21 @@ declare const O2ASSEAdapterStatic: {
         errors: string[];
         warnings: string[];
     };
+    /**
+     * 转换 Response 流为 Anthropic SSE（静态方法）
+     * 新增：直接处理 Response 对象的流式转换
+     */
+    convertResponseStream: (openaiResponse: Response, options?: StreamConversionOptions) => ReadableStream<string>;
+    /**
+     * 转换 ReadableStream 为 Anthropic SSE（静态方法）
+     * 新增：处理任意 ReadableStream<Uint8Array> 的流式转换
+     */
+    convertReadableStream: (openaiStream: ReadableStream<Uint8Array>, options?: StreamConversionOptions) => ReadableStream<string>;
+    /**
+     * 创建流式转换器（静态方法）
+     * 新增：提供更精细的流处理控制
+     */
+    createStreamConverter: (options?: StreamConversionOptions) => IStreamConverter;
 };
 
 /**
@@ -7155,7 +7267,7 @@ interface Logger {
 declare function getGlobalLogger(): Logger;
 
 /**
- * @ai-protocol/adapters - Universal AI Protocol Converter
+ * ai-protocol-adapters - Universal AI Protocol Converter
  * OpenAI ⇄ Anthropic with full TypeScript support
  */
 

package/dist/index.js

@@ -4480,6 +4480,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 = {}) {
@@ -4734,6 +4975,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转换
    * 包括输入验证、输出修复等
@@ -4805,13 +5141,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);
   }
   /**
@@ -4888,6 +5260,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: ")) {
@@ -4900,15 +5274,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") {
@@ -4918,6 +5299,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/dist/index.mjs

@@ -4373,6 +4373,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 +4868,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 +5034,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 +5153,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 +5167,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 +5192,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.3",
   "description": "Universal AI Protocol Converter - OpenAI ⇄ Anthropic with full TypeScript support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",