ai-world-sdk 1.1.6 → 1.1.7

package/README.md

@@ -339,6 +339,12 @@ const model = createChatModel('gemini-2.5-flash-image', {
 **结构化输出参数:**
 - `jsonSchema?: Record<string, any>` - JSON Schema 定义，用于结构化输出（使用 `with_structured_output`）
 
+**推理模式参数:**
+- `reasoning?: object` - 推理配置，不同模型配置不同：
+  - **OpenAI (o1, gpt-5 系列)**: `{ effort: 'low' | 'medium' | 'high', summary?: 'detailed' | 'auto' }`
+  - **Gemini**: `{ thinking_level: 'low' | 'high' }`
+  - **Claude**: `{ type: 'enabled', budget_tokens: number }`
+
 ### 图像生成
 
 #### DoubaoImageGenerationClient
@@ -856,6 +862,107 @@ const response2 = await model.invoke([
 ]);
 ```
 
+### 推理模式（Reasoning）
+
+推理模式允许模型在生成响应时展示其思考过程。不同的模型提供商有不同的推理配置方式。
+
+#### OpenAI 推理模式（o1、gpt-5 系列）
+
+```typescript
+import { ChatOpenAI, HumanMessage, AIMessageChunk } from 'ai-world-sdk';
+
+const model = new ChatOpenAI({
+  modelName: 'gpt-5.2',
+  temperature: 0.7,
+  provider: 'aihubmix',
+  reasoning: {
+    effort: 'high',      // 'low' | 'medium' | 'high'
+    summary: 'detailed', // 'detailed' | 'auto'（可选）
+  },
+});
+
+// 流式调用获取推理过程
+let fullText = '';
+let reasoningText = '';
+for await (const chunk of model.stream([
+  new HumanMessage('解释量子纠缠原理'),
+])) {
+  fullText += chunk.content || '';
+  reasoningText += chunk.reasoning || ''; // 获取推理内容
+}
+
+console.log('推理过程:', reasoningText);
+console.log('最终回复:', fullText);
+```
+
+#### Google Gemini 推理模式
+
+```typescript
+import { ChatGoogleGenerativeAI, HumanMessage } from 'ai-world-sdk';
+
+const model = new ChatGoogleGenerativeAI({
+  modelName: 'gemini-3-pro-preview',
+  temperature: 0.7,
+  provider: 'gemini',
+  reasoning: {
+    thinking_level: 'high', // 'low' | 'high'
+  },
+});
+
+// 流式调用获取思考过程
+for await (const chunk of model.stream([
+  new HumanMessage('分析这个数学问题'),
+])) {
+  console.log('内容:', chunk.content);
+  console.log('思考:', chunk.reasoning); // 获取思考内容
+}
+```
+
+#### Anthropic Claude 推理模式（Extended Thinking）
+
+```typescript
+import { ChatAnthropic, HumanMessage } from 'ai-world-sdk';
+
+const model = new ChatAnthropic({
+  modelName: 'claude-3-5-sonnet-20241022',
+  temperature: 0.7,
+  provider: 'aihubmix',
+  reasoning: {
+    type: 'enabled',
+    budget_tokens: 5000, // 思考预算（token 数量）
+  },
+});
+
+// 流式调用获取思考过程
+for await (const chunk of model.stream([
+  new HumanMessage('解决这个复杂问题'),
+])) {
+  console.log('内容:', chunk.content);
+  console.log('思考:', chunk.reasoning);
+}
+```
+
+**推理参数说明：**
+
+| 模型类型 | 参数 | 说明 |
+|---------|------|------|
+| OpenAI (o1, gpt-5) | `effort: 'low' \| 'medium' \| 'high'` | 推理努力程度 |
+| OpenAI (o1, gpt-5) | `summary: 'detailed' \| 'auto'` | 推理摘要模式（可选） |
+| Gemini | `thinking_level: 'low' \| 'high'` | 思考深度级别 |
+| Claude | `type: 'enabled'` | 启用扩展思考 |
+| Claude | `budget_tokens: number` | 思考预算（建议 2000-10000） |
+
+**获取推理内容：**
+
+在流式调用中，可以通过 `AIMessageChunk.reasoning` 属性获取模型的推理/思考内容：
+
+```typescript
+for await (const chunk of model.stream([...])) {
+  // chunk.content - 最终响应内容
+  // chunk.reasoning - 推理/思考过程（如果模型支持）
+}
+```
+
 ### 结构化输出（JSON Schema）
 
 使用 `jsonSchema` 参数可以让模型返回结构化的 JSON 数据，而不是自由文本。
@@ -1486,16 +1593,20 @@ for await (const chunk of client.streamDownload({
 
 ### 聊天模型
 
-| 提供商 | Provider | 模型示例 | 模型类 |
-|--------|----------|----------|--------|
-| OpenAI | `aihubmix` | `gpt-4o-mini`, `gpt-4`, `o1-preview` | `ChatOpenAI` |
-| Google Gemini | `gemini` 或 `aihubmix` | `gemini-2.5-flash-image`, `gemini-3-pro-image-preview` | `ChatGoogleGenerativeAI` |
-| Anthropic Claude | `aihubmix` | `claude-3-sonnet-20240229`, `claude-3-opus-20240229` | `ChatAnthropic` |
-| Doubao | `doubao` 或 `aihubmix` | `doubao-pro-4k`, `doubao-seedream-4-5-251128` | `ChatOpenAI` |
+| 提供商 | Provider | 模型示例 | 模型类 | 支持推理 |
+|--------|----------|----------|--------|---------|
+| OpenAI | `aihubmix` | `gpt-4o-mini`, `gpt-4` | `ChatOpenAI` | ❌ |
+| OpenAI | `aihubmix` | `o1-preview`, `o1-mini`, `gpt-5.2` | `ChatOpenAI` | ✅ |
+| Google Gemini | `gemini` 或 `aihubmix` | `gemini-2.5-flash-image` | `ChatGoogleGenerativeAI` | ❌ |
+| Google Gemini | `gemini` 或 `aihubmix` | `gemini-3-pro-preview` | `ChatGoogleGenerativeAI` | ✅ |
+| Anthropic Claude | `aihubmix` | `claude-3-sonnet-20240229` | `ChatAnthropic` | ❌ |
+| Anthropic Claude | `aihubmix` | `claude-3-5-sonnet-20241022` | `ChatAnthropic` | ✅ |
+| Doubao | `doubao` 或 `aihubmix` | `doubao-pro-4k`, `doubao-seedream-4-5-251128` | `ChatOpenAI` | ❌ |
 
 **注意:** 
 - 使用 `aihubmix` 或 `api2img` provider 可以访问所有模型，推荐用于多模型场景
 - 使用特定 provider（如 `gemini`、`doubao`）会直接调用对应的官方 API
+- 支持推理的模型可以通过 `reasoning` 参数启用思考/推理功能
 
 ### 图像生成模型
 

package/dist/__tests__/example.test.js

@@ -96,6 +96,31 @@ describe("Langchain SDK Tests", () => {
         console.log("✅ 流式测试成功");
         console.log(`完整回复长度: ${fullText.length} 字符`);
     }, 30000);
+    test("ChatGoogleGenerativeAI - 流式调用 reasoning", async () => {
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            modelName: "gemini-3-pro-preview",
+            temperature: 0.7,
+            provider: "gemini",
+            reasoning: {
+                thinking_level: "high",
+            },
+        });
+        let fullText = "";
+        let reasoningText = "";
+        for await (const chunk of gemini.stream([
+            new index_1.HumanMessage("请介绍人工智能。"),
+        ])) {
+            // chunk 是 AIMessageChunk 对象，提取 content
+            fullText += extractTextFromChunk(chunk);
+            reasoningText += chunk.reasoning ?? "";
+            console.log("AI stream chunk:", chunk);
+            console.log("AI stream text:", fullText);
+        }
+        console.log("✅ ChatGoogleGenerativeAI 流式测试 reasoning: " + reasoningText);
+        console.log("✅ ChatGoogleGenerativeAI 流式测试 content: " + fullText);
+        expect(fullText.length).toBeGreaterThan(0);
+        console.log(`完整回复长度: ${fullText.length} 字符`);
+    }, 30000);
     test("createChatModel 工厂函数", async () => {
         const model = (0, index_1.createChatModel)("gemini-2.0-flash-exp-image-generation", {
             temperature: 0.7,
@@ -894,6 +919,29 @@ describe("Langchain SDK Tests", () => {
         console.log("✅ ChatOpenAI 流式测试成功 " + fullText);
         console.log(`完整回复长度: ${fullText.length} 字符`);
     }, 30000);
+    test("ChatOpenAI Reasoning - 流式调用", async () => {
+        const openai = new index_1.ChatOpenAI({
+            modelName: "gpt-5.2",
+            temperature: 0.7,
+            provider: "api2img",
+            reasoning: {
+                effort: "high",
+                summary: "detailed",
+            },
+        });
+        let fullText = "";
+        let reasoningText = "";
+        for await (const chunk of openai.stream([
+            new index_1.HumanMessage("请介绍人工智能。"),
+        ])) {
+            fullText += extractTextFromChunk(chunk);
+            reasoningText += chunk.reasoning ?? "";
+        }
+        console.log("✅ ChatOpenAI 流式测试 reasoning: " + reasoningText);
+        expect(fullText.length).toBeGreaterThan(0);
+        console.log("✅ ChatOpenAI 流式测试 content: " + fullText);
+        console.log(`完整回复长度: ${fullText.length} 字符`);
+    }, 30000);
     test("ChatOpenAI - batch 方法", async () => {
         const openai = new index_1.ChatOpenAI({
             modelName: "gpt-4",

package/dist/base.d.ts

@@ -39,10 +39,12 @@ export interface BindOptions {
             name: string;
         };
     };
+    reasoning?: any;
 }
 export declare abstract class BaseChatModel {
     protected headers: Record<string, string>;
     protected temperature: number;
+    protected reasoning?: any;
     protected maxTokens?: number;
     protected topP?: number;
     protected modelName: string;
@@ -62,6 +64,7 @@ export declare abstract class BaseChatModel {
         apiKey?: string;
         vertexai?: boolean;
         jsonSchema?: Record<string, any>;
+        reasoning?: any;
     });
     /**
      * Invoke the model with messages (non-streaming)

package/dist/base.js

@@ -23,6 +23,7 @@ class BaseChatModel {
         this.apiKey = config.apiKey;
         this.vertexai = config.vertexai;
         this.jsonSchema = config.jsonSchema;
+        this.reasoning = config.reasoning;
         this.temperature = config.temperature ?? 0.7;
         this.maxTokens = config.maxTokens;
         this.topP = config.topP;
@@ -44,6 +45,7 @@ class BaseChatModel {
                 top_p: options.topP ?? this.topP,
                 tools: options.tools,
                 tool_choice: options.toolChoice,
+                reasoning: this.reasoning,
             },
             model: this.modelName,
             provider: this.provider,
@@ -95,6 +97,7 @@ class BaseChatModel {
                 top_p: options.topP ?? this.topP,
                 tools: options.tools,
                 tool_choice: options.toolChoice,
+                reasoning: this.reasoning,
             },
             model: this.modelName,
             provider: this.provider,
@@ -216,6 +219,7 @@ class BaseChatModel {
                 temperature: this.temperature,
                 max_tokens: this.maxTokens,
                 top_p: this.topP,
+                reasoning: this.reasoning,
             },
             model: this.modelName,
             provider: this.provider,

package/dist/chat_models/anthropic.d.ts

@@ -3,8 +3,41 @@
  * Similar to LangChain.js ChatAnthropic
  */
 import { BaseChatModel, BaseChatModelParams } from "../base";
+/**
+ * Anthropic Claude reasoning configuration
+ * 用于控制 Claude 模型的扩展思考（Extended Thinking）功能
+ */
+export interface AnthropicReasoningConfig {
+    /**
+     * 思考类型，目前仅支持 "enabled"
+     */
+    type: "enabled";
+    /**
+     * 思考预算（token 数量）
+     * 控制模型可以用于思考的最大 token 数
+     * 建议值：2000-10000
+     */
+    budget_tokens: number;
+}
 export interface ChatAnthropicConfig extends BaseChatModelParams {
     modelName: string;
+    /**
+     * Reasoning configuration for Claude models
+     * 启用扩展思考（Extended Thinking）功能，模型会在响应中包含思考过程
+     *
+     * @example
+     * ```typescript
+     * const model = new ChatAnthropic({
+     *   modelName: 'claude-3-5-sonnet-20241022',
+     *   provider: 'aihubmix',
+     *   reasoning: {
+     *     type: 'enabled',
+     *     budget_tokens: 5000,
+     *   },
+     * });
+     * ```
+     */
+    reasoning?: AnthropicReasoningConfig;
 }
 export declare class ChatAnthropic extends BaseChatModel {
     constructor(config: ChatAnthropicConfig);

package/dist/chat_models/google.d.ts

@@ -3,8 +3,36 @@
  * Similar to LangChain.js ChatGoogleGenerativeAI
  */
 import { BaseChatModel, BaseChatModelParams } from "../base";
+/**
+ * Google Gemini reasoning configuration
+ * 用于控制 Gemini 模型的思考深度
+ */
+export interface GeminiReasoningConfig {
+    /**
+     * 思考深度级别
+     * - "low": 低深度思考，响应更快
+     * - "high": 高深度思考，推理更深入
+     */
+    thinking_level: "low" | "high";
+}
 export interface ChatGoogleGenerativeAIConfig extends BaseChatModelParams {
     modelName: string;
+    /**
+     * Reasoning configuration for Gemini models
+     * 启用后，模型会在响应中包含思考过程
+     *
+     * @example
+     * ```typescript
+     * const model = new ChatGoogleGenerativeAI({
+     *   modelName: 'gemini-3-pro-preview',
+     *   provider: 'gemini',
+     *   reasoning: {
+     *     thinking_level: 'high',
+     *   },
+     * });
+     * ```
+     */
+    reasoning?: GeminiReasoningConfig;
 }
 export declare class ChatGoogleGenerativeAI extends BaseChatModel {
     constructor(config: ChatGoogleGenerativeAIConfig);

package/dist/chat_models/openai.d.ts

@@ -3,8 +3,44 @@
  * Similar to LangChain.js ChatOpenAI
  */
 import { BaseChatModel, BaseChatModelParams } from "../base";
+/**
+ * OpenAI reasoning configuration
+ * 用于控制 OpenAI 模型（如 o1、gpt-5 系列）的推理深度
+ */
+export interface OpenAIReasoningConfig {
+    /**
+     * 推理努力程度
+     * - "low": 低努力程度，响应更快
+     * - "medium": 中等努力程度
+     * - "high": 高努力程度，推理更深入
+     */
+    effort: "low" | "medium" | "high";
+    /**
+     * 推理摘要模式
+     * - "detailed": 详细摘要
+     * - "auto": 自动选择
+     */
+    summary?: "detailed" | "auto";
+}
 export interface ChatOpenAIConfig extends BaseChatModelParams {
     modelName: string;
+    /**
+     * Reasoning configuration for OpenAI models (o1, gpt-5 series)
+     * 启用后，模型会在响应中包含推理过程
+     *
+     * @example
+     * ```typescript
+     * const model = new ChatOpenAI({
+     *   modelName: 'gpt-5.2',
+     *   provider: 'aihubmix',
+     *   reasoning: {
+     *     effort: 'high',
+     *     summary: 'detailed',
+     *   },
+     * });
+     * ```
+     */
+    reasoning?: OpenAIReasoningConfig;
 }
 export declare class ChatOpenAI extends BaseChatModel {
     constructor(config: ChatOpenAIConfig);

package/dist/config.d.ts

@@ -9,7 +9,7 @@
  *
  * 注意: {VERSION} 占位符会在构建时被替换为实际版本号
  */
-export declare const SDK_SIGNATURE = "AI_WORLD_SDK_V:1.1.6";
+export declare const SDK_SIGNATURE = "AI_WORLD_SDK_V:1.1.7";
 /**
  * 版本兼容性错误
  */
@@ -24,8 +24,8 @@ declare class SDKConfig {
     private _pluginId;
     private _versionCompatible;
     private _versionCheckPromise;
-    readonly sdkSignature = "AI_WORLD_SDK_V:1.1.6";
-    readonly sdkVersion = "1.1.6";
+    readonly sdkSignature = "AI_WORLD_SDK_V:1.1.7";
+    readonly sdkVersion = "1.1.7";
     constructor();
     /**
      * Set global base URL

package/dist/config.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sdkConfig = exports.VersionCompatibilityError = exports.SDK_SIGNATURE = void 0;
 // SDK 版本号（构建时自动从 package.json 更新）
 // 此版本号会在运行 npm run build 时自动从 package.json 读取并更新
-const SDK_VERSION = "1.1.6";
+const SDK_VERSION = "1.1.7";
 /**
  * SDK 特征码 - 用于在构建后的 JS 文件中识别 SDK 版本
  * 格式: AI_WORLD_SDK_V:版本号
@@ -15,7 +15,7 @@ const SDK_VERSION = "1.1.6";
  *
  * 注意: {VERSION} 占位符会在构建时被替换为实际版本号
  */
-exports.SDK_SIGNATURE = "AI_WORLD_SDK_V:1.1.6";
+exports.SDK_SIGNATURE = "AI_WORLD_SDK_V:1.1.7";
 /**
  * 版本兼容性错误
  */

package/dist/messages.d.ts

@@ -3,9 +3,11 @@
  * Similar to LangChain.js message interface
  */
 export interface MessageContent {
-    type: "text" | "image_url";
+    type: "text" | "image_url" | "reasoning" | "thinking";
     text?: string;
     image_url?: string;
+    reasoning?: string;
+    thinking?: string;
 }
 export interface BaseMessage {
     content: string | MessageContent[] | Record<string, any>;
@@ -52,6 +54,7 @@ export declare class AIMessageChunk implements BaseMessage {
     usage_metadata?: Record<string, any>;
     additional_kwargs?: Record<string, any>;
     constructor(data: AIMessageChunkData | string | MessageContent[]);
+    get reasoning(): string | undefined;
     toJSON(): {
         role: string;
         content: string | MessageContent[];

package/dist/messages.js

@@ -51,6 +51,36 @@ class AIMessageChunk {
             this.additional_kwargs = data.additional_kwargs;
         }
     }
+    get reasoning() {
+        if (Array.isArray(this.content)) {
+            // 根据 content 返回 reasoning 文本
+            // content 可能为 MessageContent[]，需要找到 type 为 "reasoning" 或 "thinking" 的 block，将其 summary 按顺序拼接其 text 字段
+            // 例如: [{'summary': [{'index': 0, 'type': 'summary_text', 'text': ' in'}], 'index': 0, 'type': 'reasoning'}]
+            // [{'type': 'thinking', 'thinking': "**Initiating AI Overview**\n", 'index': 0}]
+            // 类型也可能为 thinking，所以需要兼容 type 为 "reasoning" 或 "thinking" 的情况
+            const reasoningText = this.content
+                .filter((block) => typeof block === "object" &&
+                block !== null &&
+                "type" in block &&
+                (block.type === "reasoning" || block.type === "thinking"))
+                .map((block) => {
+                if (block.type === "thinking") {
+                    return block.thinking ?? "";
+                }
+                if (Array.isArray(block.summary)) {
+                    // 按 summary 的 index 排序，拼接 text
+                    return block.summary
+                        .sort((a, b) => (a.index ?? 0) - (b.index ?? 0))
+                        .map((summaryItem) => summaryItem.text ?? "")
+                        .join("");
+                }
+                return "";
+            })
+                .join("");
+            return reasoningText;
+        }
+        return '';
+    }
     toJSON() {
         return {
             role: this.role,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-world-sdk",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "TypeScript SDK for AI World Platform - Chat Models, Image Generation, and Video Generation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",