@scenemesh/entity-engine-aimodule 1.0.0 → 1.0.2

package/dist/chunk-YSVMY77H.js

@@ -1,611 +0,0 @@
-"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