@scenemesh/entity-engine-aimodule 1.0.0

package/dist/chunk-25C2NRSD.mjs

@@ -0,0 +1,611 @@
+// src/core/ai-tools.ts
+import { EventEmitter } from "events";
+import {
+  tool,
+  dynamicTool,
+  stepCountIs,
+  NoSuchToolError,
+  InvalidToolInputError
+} from "ai";
+var AIToolsIntegration = class extends EventEmitter {
+  constructor() {
+    super();
+    this.initialized = false;
+    this.requestCounter = 0;
+    this.registeredTools = /* @__PURE__ */ new Map();
+    this.dynamicTools = /* @__PURE__ */ new Map();
+    this.mcpClients = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 初始化
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      this.emit("ai_tools:initializing");
+      this.initialized = true;
+      this.emit("ai_tools:initialized");
+    } catch (error) {
+      this.emit("ai_tools:initialization_failed", { error });
+      throw error;
+    }
+  }
+  /**
+   * 生成请求ID
+   */
+  generateRequestId() {
+    return `ai-tools-${Date.now()}-${++this.requestCounter}`;
+  }
+  // Tool Management
+  /**
+   * Create tool - following official specifications
+   */
+  createTool(description, inputSchema, execute) {
+    if (execute) {
+      return tool({
+        description,
+        inputSchema,
+        execute: async (params) => execute(params, {
+          // 传递标准的AI SDK执行选项
+          toolCallId: "tool-call-" + Date.now(),
+          messages: [],
+          abortSignal: void 0,
+          experimental_context: void 0
+        })
+      });
+    } else {
+      return tool({
+        description,
+        inputSchema
+      });
+    }
+  }
+  /**
+   * 创建动态工具 - 完全基于 AI SDK 的 dynamicTool
+   */
+  createDynamicTool(description, inputSchema, execute) {
+    return dynamicTool({
+      description,
+      inputSchema,
+      execute: execute ? async (input, options) => {
+        const toolOptions = {
+          toolCallId: options.toolCallId || "unknown",
+          messages: options.messages || [],
+          abortSignal: options.abortSignal,
+          experimental_context: options.experimental_context
+        };
+        return execute(input, toolOptions);
+      } : async (input, options) => (
+        // 默认实现：返回输入参数
+        input
+      )
+    });
+  }
+  /**
+   * 注册工具到集成器
+   */
+  registerTool(name, toolInstance) {
+    this.registeredTools.set(name, toolInstance);
+    this.emit("ai_tools:tool_registered", { name, tool: toolInstance });
+  }
+  /**
+   * 获取已注册的工具
+   */
+  getRegisteredTools() {
+    const tools = {};
+    this.registeredTools.forEach((registeredTool, name) => {
+      tools[name] = registeredTool;
+    });
+    return tools;
+  }
+  /**
+   * 注册动态工具
+   */
+  registerDynamicTool(name, dynamicToolInstance) {
+    this.dynamicTools.set(name, dynamicToolInstance);
+    this.emit("ai_tools:dynamic_tool_registered", { name, tool: dynamicToolInstance });
+  }
+  // ================================
+  // 🔄 多步调用系统 - 按照官方文档规范实现
+  // ================================
+  /**
+   * 使用工具执行文本生成 - 遵循官方 generateText + tools 模式
+   * 这是 AI SDK 工具调用的标准方式
+   */
+  async generateTextWithTools(options) {
+    const { generateText } = await import("ai");
+    const requestId = this.generateRequestId();
+    const startTime = Date.now();
+    try {
+      this.emit("ai_tools:multi_step_started", {
+        requestId,
+        model: typeof options.model === "string" ? options.model : "unknown",
+        hasTools: !!options.tools,
+        stopWhen: !!options.stopWhen,
+        maxSteps: options.maxSteps || 5
+      });
+      const generateOptions = {
+        model: options.model,
+        system: options.system,
+        prompt: options.prompt,
+        messages: options.messages,
+        tools: options.tools,
+        toolChoice: options.toolChoice,
+        activeTools: options.activeTools,
+        maxOutputTokens: options.maxOutputTokens,
+        temperature: options.temperature,
+        topP: options.topP,
+        topK: options.topK,
+        presencePenalty: options.presencePenalty,
+        frequencyPenalty: options.frequencyPenalty,
+        seed: options.seed,
+        maxRetries: options.maxRetries,
+        abortSignal: options.abortSignal,
+        headers: options.headers,
+        experimental_context: options.experimental_context,
+        experimental_telemetry: options.experimental_telemetry,
+        experimental_repairToolCall: options.experimental_repairToolCall,
+        onStepFinish: options.onStepFinish,
+        prepareStep: options.prepareStep
+      };
+      if (options.stopWhen) {
+        generateOptions.stopWhen = Array.isArray(options.stopWhen) ? options.stopWhen.map((cond) => this.parseStopCondition(cond)) : this.parseStopCondition(options.stopWhen);
+      } else if (options.maxSteps) {
+        generateOptions.stopWhen = stepCountIs(options.maxSteps);
+      }
+      const result = await generateText(generateOptions);
+      this.emit("ai_tools:multi_step_completed", {
+        requestId,
+        latency: Date.now() - startTime,
+        steps: result.steps?.length || 1,
+        toolCalls: result.toolCalls?.length || 0,
+        toolResults: result.toolResults?.length || 0,
+        finishReason: result.finishReason,
+        usage: result.usage
+      });
+      return {
+        text: result.text,
+        steps: result.steps || [],
+        toolCalls: result.toolCalls || [],
+        toolResults: result.toolResults || [],
+        finishReason: result.finishReason,
+        usage: result.usage,
+        totalUsage: result.totalUsage || result.usage,
+        content: result.content || [],
+        reasoning: result.reasoning || [],
+        reasoningText: result.reasoningText,
+        sources: result.sources || [],
+        files: result.files || [],
+        warnings: result.warnings,
+        response: result.response,
+        providerMetadata: result.providerMetadata
+      };
+    } catch (error) {
+      this.emit("ai_tools:generate_text_with_tools_failed", {
+        requestId,
+        error: error.message,
+        latency: Date.now() - startTime,
+        errorType: error.constructor.name
+      });
+      throw error;
+    }
+  }
+  /**
+   * 使用工具执行流式文本生成 - 遵循官方 streamText + tools 模式
+   */
+  async streamTextWithTools(options) {
+    const { streamText } = await import("ai");
+    const requestId = this.generateRequestId();
+    this.emit("ai_tools:multi_step_stream_started", {
+      requestId,
+      model: typeof options.model === "string" ? options.model : "unknown",
+      hasTools: !!options.tools,
+      stopWhen: !!options.stopWhen
+    });
+    const wrappedOptions = {
+      ...options,
+      onStepFinish: (result) => {
+        this.emit("ai_tools:step_finished", {
+          requestId,
+          stepType: result.stepType,
+          stepNumber: result.stepNumber || 0,
+          toolCalls: result.toolCalls?.length || 0,
+          toolResults: result.toolResults?.length || 0,
+          finishReason: result.finishReason
+        });
+        if (options.onStepFinish) {
+          options.onStepFinish(result);
+        }
+      }
+    };
+    const streamOptions = { ...wrappedOptions };
+    if (options.stopWhen) {
+      streamOptions.stopWhen = Array.isArray(options.stopWhen) ? options.stopWhen.map((cond) => this.parseStopCondition(cond)) : this.parseStopCondition(options.stopWhen);
+    }
+    const streamResult = streamText(streamOptions);
+    const enhancedStreamResult = {
+      ...streamResult,
+      // 工具调用分析方法
+      analyzeToolUsage: async () => {
+        const steps = await streamResult.steps;
+        return this.analyzeToolUsage(steps);
+      },
+      // 提取所有工具调用
+      getAllToolCalls: async () => {
+        const steps = await streamResult.steps;
+        return this.extractToolCallsFromSteps(steps);
+      },
+      // 提取所有工具结果
+      getAllToolResults: async () => {
+        const steps = await streamResult.steps;
+        return this.extractToolResultsFromSteps(steps);
+      },
+      // 获取响应消息 - 官方文档重点功能
+      getResponseMessages: async () => {
+        const response = await streamResult.response;
+        return this.extractResponseMessages({ response });
+      }
+    };
+    return enhancedStreamResult;
+  }
+  /**
+   * 创建步骤计数停止条件
+   */
+  createStepCountCondition(maxSteps) {
+    return { type: "stepCount", value: maxSteps };
+  }
+  /**
+   * 创建自定义停止条件  
+   */
+  createCustomStopCondition(condition) {
+    return condition;
+  }
+  /**
+   * 解析停止条件
+   */
+  parseStopCondition(condition) {
+    if (typeof condition === "function") {
+      return condition;
+    }
+    if (condition.type === "stepCount") {
+      return stepCountIs(condition.value);
+    }
+    if (condition.type === "custom") {
+      return condition.condition;
+    }
+    return stepCountIs(5);
+  }
+  // ================================
+  // Tool repair system
+  // ================================
+  /**
+   * 创建结构化输出修复器
+   */
+  createStructuredRepairFunction(repairModel) {
+    return async (options) => {
+      if (NoSuchToolError.isInstance(options.error)) {
+        return null;
+      }
+      try {
+        const { generateObject } = await import("ai");
+        const toolDef = options.tools[options.toolCall.toolName];
+        if (!toolDef) return null;
+        const { object: repairedArgs } = await generateObject({
+          model: repairModel,
+          schema: toolDef.parameters || toolDef.schema,
+          prompt: [
+            `The model tried to call the tool "${options.toolCall.toolName}" with the following inputs:`,
+            JSON.stringify(options.toolCall.input),
+            `The tool accepts the following schema:`,
+            JSON.stringify(options.inputSchema(options.toolCall)),
+            "Please fix the inputs to match the schema."
+          ].join("\n")
+        });
+        return {
+          ...options.toolCall,
+          input: JSON.stringify(repairedArgs)
+        };
+      } catch (repairError) {
+        this.emit("ai_tools:repair_failed", {
+          originalError: options.error,
+          repairError,
+          toolCall: options.toolCall
+        });
+        return null;
+      }
+    };
+  }
+  /**
+   * 创建重新询问修复器
+   */
+  createReaskRepairFunction(repairModel) {
+    return async (options) => {
+      try {
+        const { generateText } = await import("ai");
+        const result = await generateText({
+          model: repairModel,
+          system: options.system,
+          messages: [
+            ...options.messages,
+            {
+              role: "assistant",
+              content: [{
+                type: "tool-call",
+                toolCallId: options.toolCall.toolCallId,
+                toolName: options.toolCall.toolName,
+                input: options.toolCall.input
+              }]
+            },
+            {
+              role: "tool",
+              content: [{
+                type: "tool-result",
+                toolCallId: options.toolCall.toolCallId,
+                toolName: options.toolCall.toolName,
+                output: options.error.message
+              }]
+            }
+          ],
+          tools: options.tools
+        });
+        const newToolCall = result.toolCalls.find(
+          (newCall) => newCall.toolName === options.toolCall.toolName
+        );
+        return newToolCall ? {
+          toolCallType: "function",
+          toolCallId: options.toolCall.toolCallId,
+          toolName: options.toolCall.toolName,
+          input: JSON.stringify(newToolCall.input)
+        } : null;
+      } catch (repairError) {
+        this.emit("ai_tools:reask_repair_failed", {
+          originalError: options.error,
+          repairError,
+          toolCall: options.toolCall
+        });
+        return null;
+      }
+    };
+  }
+  // ================================
+  // 🔗 MCP集成系统
+  // ================================
+  /**
+   * 创建MCP客户端
+   */
+  async createMCPClient(config) {
+    const { experimental_createMCPClient } = await import("ai");
+    let transportConfig;
+    switch (config.transport.type) {
+      case "sse":
+        transportConfig = {
+          transport: {
+            type: "sse",
+            url: config.transport.url,
+            headers: config.transport.headers
+          }
+        };
+        break;
+      case "stdio":
+        if (typeof window === "undefined" && typeof process !== "undefined") {
+          try {
+            const { Experimental_StdioMCPTransport } = await import("ai/mcp-stdio");
+            transportConfig = {
+              transport: new Experimental_StdioMCPTransport({
+                command: config.transport.command,
+                args: config.transport.args
+              })
+            };
+          } catch (error) {
+            throw new Error("stdio transport requires Node.js environment and ai/mcp-stdio package");
+          }
+        } else {
+          throw new Error("stdio transport is only available in Node.js environment");
+        }
+        break;
+      case "custom":
+        transportConfig = {
+          transport: config.transport.transport
+        };
+        break;
+      default:
+        throw new Error(`Unsupported MCP transport type: ${config.transport.type}`);
+    }
+    const mcpClient = await experimental_createMCPClient(transportConfig);
+    const clientId = `mcp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const wrappedClient = {
+      async tools(toolConfig) {
+        if (config.schemas || toolConfig?.schemas) {
+          return mcpClient.tools({ schemas: config.schemas || toolConfig?.schemas });
+        } else {
+          return mcpClient.tools();
+        }
+      },
+      async close() {
+        await mcpClient.close();
+        this.mcpClients.delete(clientId);
+        this.emit("ai_tools:mcp_client_closed", { clientId });
+      }
+    };
+    this.mcpClients.set(clientId, wrappedClient);
+    this.emit("ai_tools:mcp_client_created", { clientId, config });
+    return wrappedClient;
+  }
+  /**
+   * 关闭所有MCP客户端
+   */
+  async closeAllMCPClients() {
+    const closePromises = Array.from(this.mcpClients.values()).map((client) => client.close());
+    await Promise.all(closePromises);
+    this.mcpClients.clear();
+  }
+  // Utility methods
+  /**
+   * Create simple tool call configuration
+   */
+  createSimpleToolCall(model, tools, prompt, options) {
+    return {
+      model,
+      tools,
+      prompt,
+      ...options
+    };
+  }
+  /**
+   * 创建多步工具调用配置 - 使用 stopWhen 参数
+   */
+  createMultiStepToolCall(model, tools, prompt, maxSteps = 5, options) {
+    return {
+      model,
+      tools,
+      prompt,
+      stopWhen: this.createStepCountCondition(maxSteps),
+      ...options
+    };
+  }
+  /**
+   * 直接执行单个工具 - 用于测试或直接调用
+   */
+  async executeSingleTool(toolName, input, tools, options) {
+    const selectedTool = tools[toolName];
+    if (!selectedTool || !selectedTool.execute) {
+      throw new Error(`Tool '${String(toolName)}' not found or not executable`);
+    }
+    const toolOptions = {
+      toolCallId: `direct-${Date.now()}`,
+      messages: options?.messages || [],
+      abortSignal: options?.abortSignal,
+      experimental_context: options?.experimental_context
+    };
+    return selectedTool.execute(input, toolOptions);
+  }
+  /**
+   * 获取响应消息 - 官方文档重点推荐的功能
+   * 用于将助手和工具消息添加到对话历史
+   */
+  extractResponseMessages(result) {
+    return result.response?.messages || [];
+  }
+  /**
+   * 将响应消息添加到对话历史 - 官方文档示例
+   */
+  addResponseMessagesToHistory(messages, result) {
+    const responseMessages = this.extractResponseMessages(result);
+    return [...messages, ...responseMessages];
+  }
+  /**
+   * 批量工具调用验证
+   */
+  validateBatchToolCalls(toolCalls, tools) {
+    return toolCalls.map((toolCall) => ({
+      toolCall,
+      ...this.validateToolCall(toolCall, tools)
+    }));
+  }
+  /**
+   * 工具调用结果验证
+   */
+  validateToolCall(toolCall, tools) {
+    const toolName = toolCall.toolName;
+    const targetTool = tools[toolName];
+    if (!targetTool) {
+      return { valid: false, error: `Tool '${String(toolName)}' not found` };
+    }
+    try {
+      if (targetTool.inputSchema || targetTool.parameters) {
+        const schema = targetTool.inputSchema || targetTool.parameters;
+        schema.parse(toolCall.input);
+      }
+      return { valid: true };
+    } catch (validationError) {
+      return {
+        valid: false,
+        error: `Invalid tool input: ${validationError.message}`
+      };
+    }
+  }
+  /**
+   * 工具调用统计分析
+   */
+  analyzeToolUsage(steps) {
+    const allToolCalls = this.extractToolCallsFromSteps(steps);
+    const allToolResults = this.extractToolResultsFromSteps(steps);
+    const toolUsageByName = {};
+    allToolCalls.forEach((call) => {
+      const toolName = String(call.toolName);
+      toolUsageByName[toolName] = (toolUsageByName[toolName] || 0) + 1;
+    });
+    const stepTypes = {};
+    steps.forEach((step) => {
+      stepTypes[step.stepType] = (stepTypes[step.stepType] || 0) + 1;
+    });
+    return {
+      totalToolCalls: allToolCalls.length,
+      totalToolResults: allToolResults.length,
+      toolUsageByName,
+      avgToolCallsPerStep: steps.length > 0 ? allToolCalls.length / steps.length : 0,
+      stepTypes
+    };
+  }
+  /**
+   * 提取步骤中的所有工具调用
+   */
+  extractToolCallsFromSteps(steps) {
+    return steps.flatMap((step) => step.toolCalls);
+  }
+  /**
+   * 提取步骤中的所有工具结果
+   */
+  extractToolResultsFromSteps(steps) {
+    return steps.flatMap((step) => step.toolResults);
+  }
+  /**
+   * 检查初始化状态
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    return {
+      requestCount: this.requestCounter,
+      isInitialized: this.initialized,
+      registeredTools: this.registeredTools.size,
+      dynamicTools: this.dynamicTools.size,
+      mcpClients: this.mcpClients.size
+    };
+  }
+  /**
+   * 重置统计信息
+   */
+  resetStats() {
+    this.requestCounter = 0;
+  }
+  /**
+   * 销毁实例
+   */
+  async destroy() {
+    await this.closeAllMCPClients();
+    this.registeredTools.clear();
+    this.dynamicTools.clear();
+    this.removeAllListeners();
+    this.initialized = false;
+    this.requestCounter = 0;
+  }
+};
+var ai_tools_default = AIToolsIntegration;
+
+export {
+  tool,
+  dynamicTool,
+  stepCountIs,
+  NoSuchToolError,
+  InvalidToolInputError,
+  AIToolsIntegration,
+  ai_tools_default
+};
+//# sourceMappingURL=chunk-25C2NRSD.mjs.map