@scenemesh/entity-engine-aimodule 1.0.0

package/dist/chunk-YSVMY77H.js

@@ -0,0 +1,611 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/core/ai-tools.ts
+var _events = require('events');
+
+
+
+
+
+
+var _ai = require('ai');
+var AIToolsIntegration = class extends _events.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 _ai.tool.call(void 0, {
+        description,
+        inputSchema,
+        execute: async (params) => execute(params, {
+          // 传递标准的AI SDK执行选项
+          toolCallId: "tool-call-" + Date.now(),
+          messages: [],
+          abortSignal: void 0,
+          experimental_context: void 0
+        })
+      });
+    } else {
+      return _ai.tool.call(void 0, {
+        description,
+        inputSchema
+      });
+    }
+  }
+  /**
+   * 创建动态工具 - 完全基于 AI SDK 的 dynamicTool
+   */
+  createDynamicTool(description, inputSchema, execute) {
+    return _ai.dynamicTool.call(void 0, {
+      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 Promise.resolve().then(() => _interopRequireWildcard(require("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 = _ai.stepCountIs.call(void 0, options.maxSteps);
+      }
+      const result = await generateText(generateOptions);
+      this.emit("ai_tools:multi_step_completed", {
+        requestId,
+        latency: Date.now() - startTime,
+        steps: _optionalChain([result, 'access', _ => _.steps, 'optionalAccess', _2 => _2.length]) || 1,
+        toolCalls: _optionalChain([result, 'access', _3 => _3.toolCalls, 'optionalAccess', _4 => _4.length]) || 0,
+        toolResults: _optionalChain([result, 'access', _5 => _5.toolResults, 'optionalAccess', _6 => _6.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 Promise.resolve().then(() => _interopRequireWildcard(require("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: _optionalChain([result, 'access', _7 => _7.toolCalls, 'optionalAccess', _8 => _8.length]) || 0,
+          toolResults: _optionalChain([result, 'access', _9 => _9.toolResults, 'optionalAccess', _10 => _10.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 _ai.stepCountIs.call(void 0, condition.value);
+    }
+    if (condition.type === "custom") {
+      return condition.condition;
+    }
+    return _ai.stepCountIs.call(void 0, 5);
+  }
+  // ================================
+  // Tool repair system
+  // ================================
+  /**
+   * 创建结构化输出修复器
+   */
+  createStructuredRepairFunction(repairModel) {
+    return async (options) => {
+      if (_ai.NoSuchToolError.isInstance(options.error)) {
+        return null;
+      }
+      try {
+        const { generateObject } = await Promise.resolve().then(() => _interopRequireWildcard(require("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 Promise.resolve().then(() => _interopRequireWildcard(require("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 Promise.resolve().then(() => _interopRequireWildcard(require("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 Promise.resolve().then(() => _interopRequireWildcard(require("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 || _optionalChain([toolConfig, 'optionalAccess', _11 => _11.schemas])) {
+          return mcpClient.tools({ schemas: config.schemas || _optionalChain([toolConfig, 'optionalAccess', _12 => _12.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: _optionalChain([options, 'optionalAccess', _13 => _13.messages]) || [],
+      abortSignal: _optionalChain([options, 'optionalAccess', _14 => _14.abortSignal]),
+      experimental_context: _optionalChain([options, 'optionalAccess', _15 => _15.experimental_context])
+    };
+    return selectedTool.execute(input, toolOptions);
+  }
+  /**
+   * 获取响应消息 - 官方文档重点推荐的功能
+   * 用于将助手和工具消息添加到对话历史
+   */
+  extractResponseMessages(result) {
+    return _optionalChain([result, 'access', _16 => _16.response, 'optionalAccess', _17 => _17.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;
+
+
+
+
+
+
+
+
+
+exports.tool = _ai.tool; exports.dynamicTool = _ai.dynamicTool; exports.stepCountIs = _ai.stepCountIs; exports.NoSuchToolError = _ai.NoSuchToolError; exports.InvalidToolInputError = _ai.InvalidToolInputError; exports.AIToolsIntegration = AIToolsIntegration; exports.ai_tools_default = ai_tools_default;
+//# sourceMappingURL=chunk-YSVMY77H.js.map