sdkwork-browser-agent 1.0.0

package/dist/node/index.cjs

@@ -0,0 +1,3293 @@
+"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 _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14;
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkMTFOABGCcjs = require('./chunk-MTFOABGC.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkYDHQCPSNcjs = require('./chunk-YDHQCPSN.cjs');
+
+
+
+
+
+
+var _chunkKXXS33G3cjs = require('./chunk-KXXS33G3.cjs');
+
+
+
+var _chunkIYG37UN3cjs = require('./chunk-IYG37UN3.cjs');
+
+
+
+
+
+
+var _chunkJF33ZOMBcjs = require('./chunk-JF33ZOMB.cjs');
+
+// src/core/agent.ts
+var Agent = (_class = class {
+  constructor(config) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);
+    this.config = config;
+    this.name = config.name;
+    this.description = config.description;
+    this.version = config.version;
+    this.llmProvider = config.llmProvider;
+    this.systemPrompt = config.systemPrompt;
+    this.maxIterations = config.maxIterations || 10;
+    this.hooks = config.hooks;
+    this._middlewares = config.middlewares || [];
+  }
+  __init() {this._skills = /* @__PURE__ */ new Map()}
+  __init2() {this._tools = /* @__PURE__ */ new Map()}
+  __init3() {this._plugins = /* @__PURE__ */ new Map()}
+  __init4() {this._mcpResources = /* @__PURE__ */ new Map()}
+  __init5() {this._mcpTools = /* @__PURE__ */ new Map()}
+  __init6() {this._middlewares = []}
+  __init7() {this._initialized = false}
+  
+  
+  
+  
+  
+  
+  
+  async initialize() {
+    if (this._initialized) return;
+    _optionalChain([this, 'access', _2 => _2.config, 'access', _3 => _3.skills, 'optionalAccess', _4 => _4.forEach, 'call', _5 => _5((skill) => this.registerSkill(skill))]);
+    _optionalChain([this, 'access', _6 => _6.config, 'access', _7 => _7.tools, 'optionalAccess', _8 => _8.forEach, 'call', _9 => _9((tool) => this.registerTool(tool))]);
+    _optionalChain([this, 'access', _10 => _10.config, 'access', _11 => _11.mcpResources, 'optionalAccess', _12 => _12.forEach, 'call', _13 => _13((resource) => this.registerMCPResource(resource))]);
+    _optionalChain([this, 'access', _14 => _14.config, 'access', _15 => _15.mcpTools, 'optionalAccess', _16 => _16.forEach, 'call', _17 => _17((tool) => this.registerMCPTool(tool))]);
+    const pluginContext = {
+      agent: this,
+      registerSkill: (skill) => this.registerSkill(skill),
+      registerTool: (tool) => this.registerTool(tool),
+      registerMCPResource: (resource) => this.registerMCPResource(resource),
+      registerMCPTool: (tool) => this.registerMCPTool(tool),
+      getLLMProvider: () => this.llmProvider,
+      config: {}
+    };
+    for (const plugin of this.config.plugins || []) {
+      await plugin.initialize(pluginContext);
+      this._plugins.set(plugin.name, plugin);
+    }
+    this._initialized = true;
+  }
+  // ============================================
+  // Registration Methods
+  // ============================================
+  registerSkill(skill) {
+    if (this._skills.has(skill.name)) {
+      console.warn(`Skill '${skill.name}' is already registered. Overwriting.`);
+    }
+    this._skills.set(skill.name, skill);
+  }
+  registerTool(tool) {
+    if (this._tools.has(tool.name)) {
+      console.warn(`Tool '${tool.name}' is already registered. Overwriting.`);
+    }
+    this._tools.set(tool.name, tool);
+  }
+  registerMCPResource(resource) {
+    if (this._mcpResources.has(resource.uri)) {
+      console.warn(`MCP Resource '${resource.uri}' is already registered. Overwriting.`);
+    }
+    this._mcpResources.set(resource.uri, resource);
+  }
+  registerMCPTool(tool) {
+    if (this._mcpTools.has(tool.name)) {
+      console.warn(`MCP Tool '${tool.name}' is already registered. Overwriting.`);
+    }
+    this._mcpTools.set(tool.name, tool);
+  }
+  use(middleware) {
+    this._middlewares.push(middleware);
+  }
+  // ============================================
+  // Execution Methods
+  // ============================================
+  async executeSkill(name, params = {}) {
+    const skill = this._skills.get(name);
+    if (!skill) {
+      return { success: false, error: `Skill '${name}' not found` };
+    }
+    const context = {
+      agent: this,
+      skillName: name,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    await _optionalChain([this, 'access', _18 => _18.hooks, 'optionalAccess', _19 => _19.beforeSkillExecution, 'optionalCall', _20 => _20(name, params)]);
+    const execute = async () => {
+      try {
+        const result = await skill.handler(params, context);
+        await _optionalChain([this, 'access', _21 => _21.hooks, 'optionalAccess', _22 => _22.afterSkillExecution, 'optionalCall', _23 => _23(name, result)]);
+        return result;
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        await _optionalChain([this, 'access', _24 => _24.hooks, 'optionalAccess', _25 => _25.onError, 'optionalCall', _26 => _26(err, context)]);
+        return { success: false, error: err.message };
+      }
+    };
+    const chain = this._middlewares.reduceRight(
+      (next, middleware) => () => middleware(context, next),
+      execute
+    );
+    return chain();
+  }
+  async executeTool(name, input) {
+    const tool = this._tools.get(name);
+    if (!tool) {
+      return {
+        content: [{ type: "error", text: `Tool '${name}' not found` }],
+        isError: true
+      };
+    }
+    const context = {
+      agent: this,
+      skillName: name,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    try {
+      await _optionalChain([this, 'access', _27 => _27.hooks, 'optionalAccess', _28 => _28.onToolCall, 'optionalCall', _29 => _29(name, input)]);
+      return await tool.execute(input, context);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "error", text: message }],
+        isError: true
+      };
+    }
+  }
+  async readMCPResource(uri) {
+    const resource = this._mcpResources.get(uri);
+    if (!resource) return null;
+    return resource.read();
+  }
+  async executeMCPTool(name, args) {
+    const tool = this._mcpTools.get(name);
+    if (!tool) {
+      return {
+        content: [{ type: "error", text: `MCP Tool '${name}' not found` }],
+        isError: true
+      };
+    }
+    const context = {
+      agent: this,
+      skillName: name,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    try {
+      return await tool.execute(args, context);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "error", text: message }],
+        isError: true
+      };
+    }
+  }
+  // ============================================
+  // LLM Integration
+  // ============================================
+  async chat(messages, options) {
+    if (!this.llmProvider) {
+      throw new Error("No LLM provider configured");
+    }
+    const request = {
+      messages: this.systemPrompt ? [{ role: "system", content: this.systemPrompt }, ...messages] : messages,
+      ...options
+    };
+    return this.llmProvider.complete(request);
+  }
+  async *streamChat(messages, options) {
+    if (!this.llmProvider) {
+      throw new Error("No LLM provider configured");
+    }
+    const request = {
+      messages: this.systemPrompt ? [{ role: "system", content: this.systemPrompt }, ...messages] : messages,
+      stream: true,
+      ...options
+    };
+    yield* this.llmProvider.stream(request);
+  }
+  async executeWithTools(messages, tools) {
+    if (!this.llmProvider) {
+      throw new Error("No LLM provider configured");
+    }
+    const request = {
+      messages: this.systemPrompt ? [{ role: "system", content: this.systemPrompt }, ...messages] : messages,
+      tools,
+      tool_choice: "auto"
+    };
+    return this.llmProvider.complete(request);
+  }
+  // ============================================
+  // Query Methods
+  // ============================================
+  getSkill(name) {
+    return this._skills.get(name);
+  }
+  getTool(name) {
+    return this._tools.get(name);
+  }
+  getMCPResource(uri) {
+    return this._mcpResources.get(uri);
+  }
+  getMCPTool(name) {
+    return this._mcpTools.get(name);
+  }
+  getPlugin(name) {
+    return this._plugins.get(name);
+  }
+  getSkillNames() {
+    return Array.from(this._skills.keys());
+  }
+  getToolNames() {
+    return Array.from(this._tools.keys());
+  }
+  getMCPResourceURIs() {
+    return Array.from(this._mcpResources.keys());
+  }
+  getMCPToolNames() {
+    return Array.from(this._mcpTools.keys());
+  }
+  getPluginNames() {
+    return Array.from(this._plugins.keys());
+  }
+  getAllSkills() {
+    return Array.from(this._skills.values());
+  }
+  getAllTools() {
+    return Array.from(this._tools.values());
+  }
+  // ============================================
+  // Lifecycle Methods
+  // ============================================
+  async destroy() {
+    for (const plugin of this._plugins.values()) {
+      await _optionalChain([plugin, 'access', _30 => _30.destroy, 'optionalCall', _31 => _31()]);
+    }
+    this._skills.clear();
+    this._tools.clear();
+    this._plugins.clear();
+    this._mcpResources.clear();
+    this._mcpTools.clear();
+    this._middlewares = [];
+    this._initialized = false;
+  }
+}, _class);
+
+// src/core/decision-engine.ts
+var SimpleEmbeddingProvider = (_class2 = class {constructor() { _class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this); }
+  __init8() {this.vocabulary = /* @__PURE__ */ new Map()}
+  __init9() {this.vocabSize = 0}
+  __init10() {this.maxVocabSize = 1e3}
+  async embed(text) {
+    const tokens = this.tokenize(text);
+    const embedding = new Array(this.maxVocabSize).fill(0);
+    for (const token of tokens) {
+      if (!this.vocabulary.has(token)) {
+        if (this.vocabSize < this.maxVocabSize) {
+          this.vocabulary.set(token, this.vocabSize++);
+        }
+      }
+      const idx = this.vocabulary.get(token);
+      if (idx !== void 0) {
+        embedding[idx] += 1;
+      }
+    }
+    const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+    if (magnitude > 0) {
+      return embedding.map((val) => val / magnitude);
+    }
+    return embedding;
+  }
+  similarity(a, b) {
+    let dotProduct = 0;
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+      dotProduct += a[i] * b[i];
+    }
+    return dotProduct;
+  }
+  tokenize(text) {
+    return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+  }
+}, _class2);
+var DecisionEngine = (_class3 = class {
+  __init11() {this.skillEmbeddings = /* @__PURE__ */ new Map()}
+  
+  __init12() {this.decisionCache = /* @__PURE__ */ new Map()}
+  
+  constructor(config = {}, embeddingProvider) {;_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);
+    this.config = {
+      threshold: _nullishCoalesce(config.threshold, () => ( 0.6)),
+      maxSkills: _nullishCoalesce(config.maxSkills, () => ( 3)),
+      enableEmbeddings: _nullishCoalesce(config.enableEmbeddings, () => ( true)),
+      enableCaching: _nullishCoalesce(config.enableCaching, () => ( true)),
+      similarityThreshold: _nullishCoalesce(config.similarityThreshold, () => ( 0.5))
+    };
+    this.embeddingProvider = _nullishCoalesce(embeddingProvider, () => ( new SimpleEmbeddingProvider()));
+  }
+  /**
+   * Index skills for fast retrieval
+   */
+  async indexSkill(skill) {
+    if (!this.config.enableEmbeddings) return;
+    const text = `${skill.name} ${skill.description} ${this.extractKeywords(skill)}`;
+    const embedding = await this.embeddingProvider.embed(text);
+    this.skillEmbeddings.set(skill.name, embedding);
+  }
+  /**
+   * Make decision based on input
+   */
+  async decide(context) {
+    const cacheKey = this.generateCacheKey(context);
+    if (this.config.enableCaching) {
+      const cached = this.decisionCache.get(cacheKey);
+      if (cached) return cached;
+    }
+    const relevantSkills = await this.findRelevantSkills(context);
+    const relevantTools = this.findRelevantTools(context);
+    let decision;
+    if (relevantSkills.length === 0 && relevantTools.length === 0) {
+      decision = {
+        type: "llm",
+        confidence: 1,
+        reasoning: "No relevant skills found, using LLM directly"
+      };
+    } else if (relevantSkills.length === 1 && relevantTools.length === 0) {
+      decision = {
+        type: "skill",
+        skills: [relevantSkills[0].name],
+        confidence: relevantSkills[0].confidence,
+        reasoning: `Single skill match: ${relevantSkills[0].name}`
+      };
+    } else if (relevantTools.length === 1 && relevantSkills.length === 0) {
+      decision = {
+        type: "tool",
+        tools: [relevantTools[0].name],
+        confidence: relevantTools[0].confidence,
+        reasoning: `Single tool match: ${relevantTools[0].name}`
+      };
+    } else {
+      const topSkills = relevantSkills.slice(0, this.config.maxSkills);
+      const topTools = relevantTools.slice(0, 2);
+      decision = {
+        type: "multi",
+        skills: topSkills.map((s) => s.name),
+        tools: topTools.map((t) => t.name),
+        confidence: Math.max(_nullishCoalesce(_optionalChain([topSkills, 'access', _32 => _32[0], 'optionalAccess', _33 => _33.confidence]), () => ( 0)), _nullishCoalesce(_optionalChain([topTools, 'access', _34 => _34[0], 'optionalAccess', _35 => _35.confidence]), () => ( 0))),
+        reasoning: `Multiple matches: ${topSkills.map((s) => s.name).join(", ")}`,
+        fallback: "llm"
+      };
+    }
+    if (this.config.enableCaching) {
+      this.decisionCache.set(cacheKey, decision);
+      if (this.decisionCache.size > 1e3) {
+        const firstKey = this.decisionCache.keys().next().value;
+        if (firstKey !== void 0) {
+          this.decisionCache.delete(firstKey);
+        }
+      }
+    }
+    return decision;
+  }
+  /**
+   * Find relevant skills using similarity matching
+   */
+  async findRelevantSkills(context) {
+    if (!this.config.enableEmbeddings || this.skillEmbeddings.size === 0) {
+      return this.fallbackSkillMatching(context);
+    }
+    const inputEmbedding = await this.embeddingProvider.embed(context.input);
+    const results = [];
+    for (const [skillName, skillEmbedding] of this.skillEmbeddings) {
+      const similarity = this.embeddingProvider.similarity(inputEmbedding, skillEmbedding);
+      if (similarity >= this.config.similarityThreshold) {
+        results.push({ name: skillName, confidence: similarity });
+      }
+    }
+    results.sort((a, b) => b.confidence - a.confidence);
+    return results;
+  }
+  /**
+   * Fallback matching using keyword extraction
+   */
+  fallbackSkillMatching(context) {
+    const inputKeywords = this.extractKeywordsFromText(context.input);
+    const results = [];
+    for (const skillName of context.availableSkills) {
+      const skillKeywords = skillName.toLowerCase().split(/[_-]/);
+      const matches = inputKeywords.filter(
+        (kw) => skillKeywords.some((sk) => sk.includes(kw) || kw.includes(sk))
+      );
+      if (matches.length > 0) {
+        const confidence = matches.length / Math.max(inputKeywords.length, skillKeywords.length);
+        if (confidence >= this.config.threshold) {
+          results.push({ name: skillName, confidence });
+        }
+      }
+    }
+    results.sort((a, b) => b.confidence - a.confidence);
+    return results;
+  }
+  /**
+   * Find relevant tools
+   */
+  findRelevantTools(context) {
+    const inputKeywords = this.extractKeywordsFromText(context.input);
+    const results = [];
+    for (const toolName of context.availableTools) {
+      const toolKeywords = toolName.toLowerCase().split(/[_-]/);
+      const matches = inputKeywords.filter(
+        (kw) => toolKeywords.some((tk) => tk.includes(kw) || kw.includes(tk))
+      );
+      if (matches.length > 0) {
+        const confidence = matches.length / Math.max(inputKeywords.length, toolKeywords.length);
+        if (confidence >= this.config.threshold) {
+          results.push({ name: toolName, confidence });
+        }
+      }
+    }
+    results.sort((a, b) => b.confidence - a.confidence);
+    return results;
+  }
+  /**
+   * Extract keywords from skill
+   */
+  extractKeywords(skill) {
+    const keywords = [
+      skill.name,
+      skill.description,
+      ..._nullishCoalesce(_optionalChain([skill, 'access', _36 => _36.metadata, 'optionalAccess', _37 => _37.tags]), () => ( [])),
+      _nullishCoalesce(_optionalChain([skill, 'access', _38 => _38.metadata, 'optionalAccess', _39 => _39.category]), () => ( ""))
+    ];
+    for (const [key, prop] of Object.entries(skill.parameters.properties)) {
+      keywords.push(key, prop.description);
+    }
+    return keywords.join(" ");
+  }
+  /**
+   * Extract keywords from text
+   */
+  extractKeywordsFromText(text) {
+    return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+  }
+  /**
+   * Generate cache key
+   */
+  generateCacheKey(context) {
+    return `${context.input}:${context.availableSkills.join(",")}:${context.availableTools.join(",")}`;
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.decisionCache.clear();
+  }
+  /**
+   * Get cache stats
+   */
+  getCacheStats() {
+    return { size: this.decisionCache.size };
+  }
+}, _class3);
+
+// src/core/skill-loader.ts
+var DynamicSkillLoader = (_class4 = class {
+  __init13() {this.loadedSkills = /* @__PURE__ */ new Map()}
+  __init14() {this.skillCache = /* @__PURE__ */ new Map()}
+  __init15() {this.skillSources = /* @__PURE__ */ new Map()}
+  
+  constructor(config = {}) {;_class4.prototype.__init13.call(this);_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);
+    this.config = {
+      skillDirectory: _nullishCoalesce(config.skillDirectory, () => ( "./skills")),
+      enableLazyLoading: _nullishCoalesce(config.enableLazyLoading, () => ( true)),
+      enableCaching: _nullishCoalesce(config.enableCaching, () => ( true)),
+      cacheSize: _nullishCoalesce(config.cacheSize, () => ( 100)),
+      hotReload: _nullishCoalesce(config.hotReload, () => ( false))
+    };
+  }
+  /**
+   * Register a skill source for lazy loading
+   */
+  registerSource(source) {
+    this.skillSources.set(source.name, source);
+  }
+  /**
+   * Load a skill dynamically
+   */
+  async load(name) {
+    if (this.config.enableCaching) {
+      const cached = this.skillCache.get(name);
+      if (cached) return cached;
+    }
+    const loaded = this.loadedSkills.get(name);
+    if (loaded) {
+      return loaded;
+    }
+    const source = this.skillSources.get(name);
+    if (!source) {
+      return null;
+    }
+    let skill = null;
+    switch (source.type) {
+      case "builtin":
+        skill = await this.loadBuiltin(source);
+        break;
+      case "file":
+        skill = await this.loadFromFile(source);
+        break;
+      case "url":
+        skill = await this.loadFromUrl(source);
+        break;
+      case "module":
+        skill = await this.loadFromModule(source);
+        break;
+    }
+    if (skill) {
+      if (this.config.enableCaching) {
+        this.skillCache.set(name, skill);
+        this.enforceCacheLimit();
+      }
+      const loadedSkill = {
+        ...skill,
+        loadedAt: /* @__PURE__ */ new Date(),
+        source,
+        size: JSON.stringify(skill).length
+      };
+      this.loadedSkills.set(name, loadedSkill);
+    }
+    return skill;
+  }
+  /**
+   * Load multiple skills
+   */
+  async loadMultiple(names) {
+    const results = /* @__PURE__ */ new Map();
+    await Promise.all(
+      names.map(async (name) => {
+        const skill = await this.load(name);
+        if (skill) {
+          results.set(name, skill);
+        }
+      })
+    );
+    return results;
+  }
+  /**
+   * Unload a skill
+   */
+  unload(name) {
+    this.skillCache.delete(name);
+    return this.loadedSkills.delete(name);
+  }
+  /**
+   * Check if skill is loaded
+   */
+  isLoaded(name) {
+    return this.loadedSkills.has(name) || this.skillCache.has(name);
+  }
+  /**
+   * Get loaded skill info
+   */
+  getLoadedSkill(name) {
+    return this.loadedSkills.get(name);
+  }
+  /**
+   * List all loaded skills
+   */
+  listLoaded() {
+    return Array.from(this.loadedSkills.values());
+  }
+  /**
+   * List available skill sources
+   */
+  listSources() {
+    return Array.from(this.skillSources.values());
+  }
+  /**
+   * Preload skills (eager loading)
+   */
+  async preload(names) {
+    await this.loadMultiple(names);
+  }
+  /**
+   * Get memory usage stats
+   */
+  getStats() {
+    const loaded = this.listLoaded();
+    return {
+      loaded: loaded.length,
+      cached: this.skillCache.size,
+      sources: this.skillSources.size,
+      totalSize: loaded.reduce((sum, s) => sum + (_nullishCoalesce(s.size, () => ( 0))), 0)
+    };
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.skillCache.clear();
+  }
+  /**
+   * Clear all loaded skills
+   */
+  clear() {
+    this.loadedSkills.clear();
+    this.skillCache.clear();
+  }
+  // Private loading methods
+  async loadBuiltin(_source) {
+    return null;
+  }
+  async loadFromFile(source) {
+    if (typeof window !== "undefined") {
+      console.warn("File loading not supported in browser");
+      return null;
+    }
+    try {
+      const fs = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+      const content = await fs.readFile(source.source, "utf-8");
+      const module = JSON.parse(content);
+      return this.validateSkill(module);
+    } catch (error) {
+      console.error(`Failed to load skill from file: ${source.source}`, error);
+      return null;
+    }
+  }
+  async loadFromUrl(source) {
+    try {
+      const response = await fetch(source.source);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const module = await response.json();
+      return this.validateSkill(module);
+    } catch (error) {
+      console.error(`Failed to load skill from URL: ${source.source}`, error);
+      return null;
+    }
+  }
+  async loadFromModule(source) {
+    try {
+      const module = await Promise.resolve().then(() => _interopRequireWildcard(require(source.source)));
+      const skill = module.default || module.skill || module;
+      return this.validateSkill(skill);
+    } catch (error) {
+      console.error(`Failed to load skill from module: ${source.source}`, error);
+      return null;
+    }
+  }
+  validateSkill(obj) {
+    if (typeof obj !== "object" || obj === null) return null;
+    const skill = obj;
+    if (typeof skill.name === "string" && typeof skill.description === "string" && typeof skill.parameters === "object" && typeof skill.handler === "function") {
+      return skill;
+    }
+    return null;
+  }
+  enforceCacheLimit() {
+    while (this.skillCache.size > this.config.cacheSize) {
+      const firstKey = this.skillCache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.skillCache.delete(firstKey);
+      }
+    }
+  }
+}, _class4);
+
+// src/core/token-optimizer.ts
+var TokenOptimizer = class {
+  
+  constructor(config = {}) {
+    this.config = {
+      maxContextTokens: _nullishCoalesce(config.maxContextTokens, () => ( 4e3)),
+      maxSkillDescriptionLength: _nullishCoalesce(config.maxSkillDescriptionLength, () => ( 200)),
+      enableCompression: _nullishCoalesce(config.enableCompression, () => ( true)),
+      preserveSystemPrompt: _nullishCoalesce(config.preserveSystemPrompt, () => ( true))
+    };
+  }
+  /**
+   * Optimize skills for minimal token usage
+   */
+  optimizeSkills(skills, forQuery) {
+    if (!this.config.enableCompression) return skills;
+    return skills.map((skill) => this.compressSkill(skill, forQuery));
+  }
+  /**
+   * Compress a single skill
+   */
+  compressSkill(skill, forQuery) {
+    const compressed = {
+      ...skill,
+      description: this.truncateDescription(skill.description),
+      parameters: this.compressParameters(skill.parameters)
+    };
+    if (forQuery && skill.metadata) {
+      const relevant = this.isMetadataRelevant(skill.metadata, forQuery);
+      if (!relevant) {
+        delete compressed.metadata;
+      }
+    }
+    return compressed;
+  }
+  /**
+   * Optimize tools for minimal token usage
+   */
+  optimizeTools(tools) {
+    if (!this.config.enableCompression) return tools;
+    return tools.map((tool) => ({
+      ...tool,
+      description: this.truncateDescription(tool.description),
+      parameters: tool.parameters ? this.compressParameters(tool.parameters) : void 0
+    }));
+  }
+  /**
+   * Optimize messages for context window
+   */
+  optimizeMessages(messages, maxTokens) {
+    const limit = _nullishCoalesce(maxTokens, () => ( this.config.maxContextTokens));
+    let totalTokens = this.estimateMessagesTokens(messages);
+    if (totalTokens <= limit) return messages;
+    const optimized = [];
+    let systemMessage = null;
+    if (this.config.preserveSystemPrompt) {
+      systemMessage = messages.find((m) => m.role === "system") || null;
+      if (systemMessage) {
+        optimized.push(systemMessage);
+        totalTokens -= this.estimateTokens(systemMessage.content);
+      }
+    }
+    const recentMessages = messages.filter((m) => m.role !== "system").reverse();
+    for (const message of recentMessages) {
+      const messageTokens = this.estimateTokens(message.content);
+      if (totalTokens + messageTokens <= limit) {
+        optimized.unshift(message);
+        totalTokens += messageTokens;
+      } else {
+        break;
+      }
+    }
+    return optimized;
+  }
+  /**
+   * Build optimized prompt with skills
+   */
+  buildOptimizedPrompt(userInput, availableSkills, context) {
+    const parts = [];
+    if (context) {
+      parts.push(`Context: ${this.truncateDescription(context, 500)}`);
+    }
+    parts.push(`User: ${userInput}`);
+    if (availableSkills.length > 0) {
+      const skillDescriptions = availableSkills.map((skill) => this.formatSkillForPrompt(skill));
+      parts.push(`
+Available skills:
+${skillDescriptions.join("\n")}`);
+    }
+    return parts.join("\n\n");
+  }
+  /**
+   * Estimate tokens for text
+   */
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Estimate tokens for messages
+   */
+  estimateMessagesTokens(messages) {
+    return messages.reduce((total, msg) => {
+      const baseTokens = 4;
+      return total + baseTokens + this.estimateTokens(msg.content);
+    }, 0);
+  }
+  /**
+   * Estimate tokens for skills
+   */
+  estimateSkillsTokens(skills) {
+    return skills.reduce((total, skill) => {
+      return total + this.estimateTokens(skill.name) + this.estimateTokens(skill.description) + this.estimateTokens(JSON.stringify(skill.parameters));
+    }, 0);
+  }
+  /**
+   * Get optimization stats
+   */
+  getOptimizationStats(original, optimized) {
+    const originalTokens = this.estimateSkillsTokens(original);
+    const optimizedTokens = this.estimateSkillsTokens(optimized);
+    const savings = originalTokens - optimizedTokens;
+    return {
+      originalTokens,
+      optimizedTokens,
+      savings,
+      savingsPercent: originalTokens > 0 ? savings / originalTokens * 100 : 0
+    };
+  }
+  // Private helper methods
+  truncateDescription(description, maxLength) {
+    const limit = _nullishCoalesce(maxLength, () => ( this.config.maxSkillDescriptionLength));
+    if (description.length <= limit) return description;
+    return description.substring(0, limit - 3) + "...";
+  }
+  compressParameters(parameters) {
+    const compressed = {
+      type: parameters.type,
+      properties: {}
+    };
+    if (parameters.required) {
+      compressed.required = parameters.required;
+    }
+    for (const [key, prop] of Object.entries(parameters.properties)) {
+      compressed.properties[key] = {
+        type: prop.type,
+        description: this.truncateDescription(prop.description, 100),
+        ...prop.enum && { enum: prop.enum },
+        ...prop.default !== void 0 && { default: prop.default }
+      };
+    }
+    return compressed;
+  }
+  isMetadataRelevant(metadata, query) {
+    if (!metadata) return false;
+    const queryLower = query.toLowerCase();
+    const metadataStr = JSON.stringify(metadata).toLowerCase();
+    return metadataStr.includes(queryLower);
+  }
+  formatSkillForPrompt(skill) {
+    const params = Object.keys(skill.parameters.properties).join(", ");
+    return `- ${skill.name}(${params}): ${skill.description}`;
+  }
+};
+
+// src/core/evaluation-engine.ts
+var ExactMatchEvaluator = (_class5 = class {constructor() { _class5.prototype.__init16.call(this); }
+  __init16() {this.name = "exact"}
+  async evaluate(result, context) {
+    if (context.expectedOutput === void 0) {
+      return {
+        overall: 0.5,
+        correctness: 0.5,
+        completeness: 0.5,
+        relevance: 0.5,
+        details: [{
+          category: "exact_match",
+          score: 0.5,
+          message: "No expected output provided for comparison"
+        }]
+      };
+    }
+    const isMatch = JSON.stringify(result) === JSON.stringify(context.expectedOutput);
+    const score = isMatch ? 1 : 0;
+    return {
+      overall: score,
+      correctness: score,
+      completeness: score,
+      relevance: score,
+      details: [{
+        category: "exact_match",
+        score,
+        message: isMatch ? "Result matches expected output exactly" : "Result does not match expected output",
+        suggestion: isMatch ? void 0 : "Check output format and values"
+      }]
+    };
+  }
+}, _class5);
+var SemanticEvaluator = (_class6 = class {constructor() { _class6.prototype.__init17.call(this); }
+  __init17() {this.name = "semantic"}
+  async evaluate(result, context) {
+    const resultStr = JSON.stringify(result).toLowerCase();
+    const inputStr = context.originalInput.toLowerCase();
+    const inputKeywords = this.extractKeywords(inputStr);
+    const resultKeywords = this.extractKeywords(resultStr);
+    const matchingKeywords = inputKeywords.filter(
+      (kw) => resultKeywords.some((rkw) => rkw.includes(kw) || kw.includes(rkw))
+    );
+    const relevanceScore = inputKeywords.length > 0 ? matchingKeywords.length / inputKeywords.length : 0.5;
+    const completenessScore = this.assessCompleteness(result);
+    return {
+      overall: (relevanceScore + completenessScore) / 2,
+      correctness: relevanceScore,
+      completeness: completenessScore,
+      relevance: relevanceScore,
+      details: [
+        {
+          category: "semantic_relevance",
+          score: relevanceScore,
+          message: `Matched ${matchingKeywords.length}/${inputKeywords.length} keywords`
+        },
+        {
+          category: "completeness",
+          score: completenessScore,
+          message: completenessScore > 0.8 ? "Result appears complete" : "Result may be incomplete"
+        }
+      ]
+    };
+  }
+  extractKeywords(text) {
+    return text.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2).filter((w) => !this.isStopWord(w));
+  }
+  isStopWord(word) {
+    const stopWords = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "might",
+      "must",
+      "shall",
+      "can",
+      "need",
+      "dare",
+      "ought",
+      "used",
+      "to",
+      "of",
+      "in",
+      "for",
+      "on",
+      "with",
+      "at",
+      "by",
+      "from",
+      "as",
+      "into",
+      "through",
+      "during",
+      "before",
+      "after",
+      "above",
+      "below",
+      "between",
+      "and",
+      "but",
+      "or",
+      "yet",
+      "so",
+      "if",
+      "because",
+      "although",
+      "though",
+      "while",
+      "where",
+      "when",
+      "that",
+      "which",
+      "who",
+      "whom",
+      "whose",
+      "what",
+      "this",
+      "these",
+      "those",
+      "i",
+      "you",
+      "he",
+      "she",
+      "it",
+      "we",
+      "they",
+      "me",
+      "him",
+      "her",
+      "us",
+      "them",
+      "my",
+      "your",
+      "his",
+      "its",
+      "our",
+      "their"
+    ]);
+    return stopWords.has(word.toLowerCase());
+  }
+  assessCompleteness(result) {
+    if (result === null || result === void 0) return 0;
+    if (typeof result === "string") {
+      return result.length > 10 ? 0.8 : 0.5;
+    }
+    if (typeof result === "object" && result !== null) {
+      const keys = Object.keys(result);
+      if (keys.length === 0) return 0.3;
+      if (keys.length >= 3) return 0.9;
+      return 0.6;
+    }
+    return 0.7;
+  }
+}, _class6);
+var SchemaValidator = (_class7 = class {constructor() { _class7.prototype.__init18.call(this); }
+  __init18() {this.name = "schema"}
+  async evaluate(result, context) {
+    if (!context.expectedSchema) {
+      return {
+        overall: 0.5,
+        correctness: 0.5,
+        completeness: 0.5,
+        relevance: 0.5,
+        details: [{
+          category: "schema_validation",
+          score: 0.5,
+          message: "No schema provided for validation"
+        }]
+      };
+    }
+    const validation = this.validateAgainstSchema(result, context.expectedSchema);
+    return {
+      overall: validation.score,
+      correctness: validation.score,
+      completeness: validation.score,
+      relevance: validation.score,
+      details: validation.errors.map((err) => ({
+        category: "schema_validation",
+        score: 0,
+        message: err
+      }))
+    };
+  }
+  validateAgainstSchema(result, schema) {
+    const errors = [];
+    if (typeof schema !== "object" || schema === null) {
+      return { score: 1, errors: [] };
+    }
+    const schemaObj = schema;
+    if (schemaObj.type && typeof schemaObj.type === "string" && typeof result !== schemaObj.type) {
+      errors.push(`Expected type ${schemaObj.type}, got ${typeof result}`);
+    }
+    if (schemaObj.required && Array.isArray(schemaObj.required)) {
+      if (typeof result === "object" && result !== null) {
+        const resultObj = result;
+        for (const prop of schemaObj.required) {
+          if (!(prop in resultObj)) {
+            errors.push(`Missing required property: ${prop}`);
+          }
+        }
+      }
+    }
+    if (schemaObj.properties && typeof result === "object" && result !== null) {
+      const resultObj = result;
+      const properties = schemaObj.properties;
+      for (const [key, propSchema] of Object.entries(properties)) {
+        if (key in resultObj) {
+          const propValidation = this.validateAgainstSchema(resultObj[key], propSchema);
+          errors.push(...propValidation.errors);
+        }
+      }
+    }
+    const score = errors.length === 0 ? 1 : Math.max(0, 1 - errors.length * 0.2);
+    return { score, errors };
+  }
+}, _class7);
+var EvaluationEngine = (_class8 = class {
+  
+  __init19() {this.evaluators = /* @__PURE__ */ new Map()}
+  __init20() {this.evaluationHistory = []}
+  constructor(config = {}) {;_class8.prototype.__init19.call(this);_class8.prototype.__init20.call(this);
+    this.config = {
+      enabled: _nullishCoalesce(config.enabled, () => ( true)),
+      level: _nullishCoalesce(config.level, () => ( "standard")),
+      strategies: _nullishCoalesce(config.strategies, () => ( ["semantic"])),
+      threshold: _nullishCoalesce(config.threshold, () => ( 0.7)),
+      autoRetry: _nullishCoalesce(config.autoRetry, () => ( false)),
+      maxRetries: _nullishCoalesce(config.maxRetries, () => ( 3)),
+      customValidator: config.customValidator
+    };
+    this.registerBuiltInEvaluators();
+  }
+  registerBuiltInEvaluators() {
+    this.evaluators.set("exact", new ExactMatchEvaluator());
+    this.evaluators.set("semantic", new SemanticEvaluator());
+    this.evaluators.set("schema", new SchemaValidator());
+  }
+  /**
+   * Evaluate execution result
+   */
+  async evaluate(result, context) {
+    if (!this.config.enabled || this.config.level === "none") {
+      return this.createPassThroughResult(result);
+    }
+    const startTime = Date.now();
+    let tokensUsed = 0;
+    const scores = [];
+    for (const strategy of this.config.strategies) {
+      const evaluator = this.evaluators.get(strategy);
+      if (evaluator) {
+        const score = await evaluator.evaluate(result.data, context);
+        scores.push(score);
+        tokensUsed += 50;
+      }
+    }
+    if (this.config.customValidator) {
+      const customScore = this.config.customValidator(result.data, context.expectedOutput);
+      scores.push(customScore);
+    }
+    const finalScore = this.aggregateScores(scores);
+    const passed = this.determinePassFail(finalScore);
+    const evaluationResult = {
+      passed,
+      score: finalScore,
+      feedback: this.generateFeedback(finalScore, passed),
+      suggestions: this.generateSuggestions(finalScore),
+      metadata: {
+        executionTime: Date.now() - startTime,
+        tokensUsed,
+        strategyUsed: this.config.strategies[0]
+      }
+    };
+    this.evaluationHistory.push({
+      timestamp: /* @__PURE__ */ new Date(),
+      result: evaluationResult,
+      context
+    });
+    if (this.evaluationHistory.length > 1e3) {
+      this.evaluationHistory = this.evaluationHistory.slice(-500);
+    }
+    return evaluationResult;
+  }
+  /**
+   * Evaluate full execution result
+   */
+  async evaluateExecution(executionResult, context) {
+    if (!this.config.enabled || this.config.level === "none") {
+      return this.createPassThroughResult(executionResult.finalOutput);
+    }
+    const stepEvaluations = [];
+    for (const stepResult of executionResult.stepResults) {
+      if (stepResult.output !== void 0) {
+        const stepContext = {
+          ...context,
+          executionHistory: executionResult.stepResults.slice(0, -1)
+        };
+        const score = await this.evaluateStep(stepResult, stepContext);
+        stepEvaluations.push(score);
+      }
+    }
+    const finalScore = await this.evaluateFinalOutput(
+      executionResult.finalOutput,
+      context
+    );
+    const allScores = [...stepEvaluations, finalScore];
+    const aggregatedScore = this.aggregateScores(allScores);
+    const passed = this.determinePassFail(aggregatedScore);
+    return {
+      passed,
+      score: aggregatedScore,
+      feedback: this.generateFeedback(aggregatedScore, passed),
+      suggestions: this.generateSuggestions(aggregatedScore),
+      metadata: {
+        executionTime: executionResult.metrics.totalTime,
+        tokensUsed: executionResult.metrics.totalTokens,
+        strategyUsed: this.config.strategies[0]
+      }
+    };
+  }
+  async evaluateStep(stepResult, context) {
+    const evaluator = this.evaluators.get(this.config.strategies[0]);
+    if (!evaluator) {
+      return this.createDefaultScore();
+    }
+    return evaluator.evaluate(stepResult.output, context);
+  }
+  async evaluateFinalOutput(output, context) {
+    const evaluator = this.evaluators.get(this.config.strategies[0]);
+    if (!evaluator) {
+      return this.createDefaultScore();
+    }
+    return evaluator.evaluate(output, context);
+  }
+  aggregateScores(scores) {
+    if (scores.length === 0) {
+      return this.createDefaultScore();
+    }
+    if (scores.length === 1) {
+      return scores[0];
+    }
+    const weights = this.getLevelWeights();
+    const overall = this.weightedAverage(scores.map((s) => s.overall), weights);
+    const correctness = this.weightedAverage(scores.map((s) => s.correctness), weights);
+    const completeness = this.weightedAverage(scores.map((s) => s.completeness), weights);
+    const relevance = this.weightedAverage(scores.map((s) => s.relevance), weights);
+    const allDetails = scores.flatMap((s) => s.details);
+    return {
+      overall,
+      correctness,
+      completeness,
+      relevance,
+      details: allDetails
+    };
+  }
+  getLevelWeights() {
+    switch (this.config.level) {
+      case "basic":
+        return [0.6, 0.4];
+      case "strict":
+        return [0.5, 0.3, 0.2];
+      case "standard":
+      default:
+        return [0.5, 0.5];
+    }
+  }
+  weightedAverage(values, weights) {
+    const sum = values.reduce((acc, val, i) => acc + val * (_nullishCoalesce(weights[i], () => ( 0.5))), 0);
+    const weightSum = weights.slice(0, values.length).reduce((a, b) => a + b, 0);
+    return weightSum > 0 ? sum / weightSum : sum;
+  }
+  determinePassFail(score) {
+    const threshold = _nullishCoalesce(this.config.threshold, () => ( 0.7));
+    switch (this.config.level) {
+      case "basic":
+        return score.overall >= threshold * 0.8;
+      case "strict":
+        return score.overall >= threshold && score.correctness >= threshold && score.completeness >= threshold;
+      case "standard":
+      default:
+        return score.overall >= threshold;
+    }
+  }
+  generateFeedback(score, passed) {
+    if (passed) {
+      if (score.overall >= 0.9) {
+        return "Excellent result! High quality output with strong correctness and completeness.";
+      } else if (score.overall >= 0.8) {
+        return "Good result. Output meets expectations with minor room for improvement.";
+      } else {
+        return "Acceptable result. Output is usable but could be improved.";
+      }
+    } else {
+      if (score.correctness < this.config.threshold) {
+        return "Result failed correctness check. Please review the output for accuracy.";
+      } else if (score.completeness < this.config.threshold) {
+        return "Result appears incomplete. Consider providing more comprehensive output.";
+      } else {
+        return "Result does not meet quality standards. Please review and retry.";
+      }
+    }
+  }
+  generateSuggestions(score) {
+    const suggestions = [];
+    if (score.correctness < 0.7) {
+      suggestions.push("Verify output accuracy against expected results");
+    }
+    if (score.completeness < 0.7) {
+      suggestions.push("Include more details or missing information in the output");
+    }
+    if (score.relevance < 0.7) {
+      suggestions.push("Ensure output directly addresses the input query");
+    }
+    for (const detail of score.details) {
+      if (detail.suggestion && detail.score < 0.7) {
+        suggestions.push(detail.suggestion);
+      }
+    }
+    return [...new Set(suggestions)];
+  }
+  createPassThroughResult(_result) {
+    return {
+      passed: true,
+      score: {
+        overall: 1,
+        correctness: 1,
+        completeness: 1,
+        relevance: 1,
+        details: [{
+          category: "evaluation_disabled",
+          score: 1,
+          message: "Evaluation is disabled, passing through"
+        }]
+      },
+      feedback: "Evaluation disabled. Result passed through without validation.",
+      suggestions: [],
+      metadata: {
+        executionTime: 0,
+        tokensUsed: 0,
+        strategyUsed: this.config.strategies[0]
+      }
+    };
+  }
+  createDefaultScore() {
+    return {
+      overall: 0.5,
+      correctness: 0.5,
+      completeness: 0.5,
+      relevance: 0.5,
+      details: []
+    };
+  }
+  /**
+   * Register custom evaluator
+   */
+  registerEvaluator(strategy, evaluator) {
+    this.evaluators.set(strategy, evaluator);
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get evaluation statistics
+   */
+  getStats() {
+    const total = this.evaluationHistory.length;
+    if (total === 0) {
+      return {
+        totalEvaluations: 0,
+        passRate: 0,
+        averageScore: 0,
+        historySize: 0
+      };
+    }
+    const passed = this.evaluationHistory.filter((h) => h.result.passed).length;
+    const avgScore = this.evaluationHistory.reduce((sum, h) => sum + h.result.score.overall, 0) / total;
+    return {
+      totalEvaluations: total,
+      passRate: passed / total,
+      averageScore: avgScore,
+      historySize: this.evaluationHistory.length
+    };
+  }
+  /**
+   * Clear evaluation history
+   */
+  clearHistory() {
+    this.evaluationHistory = [];
+  }
+  /**
+   * Get recent evaluations
+   */
+  getRecentEvaluations(limit = 10) {
+    return this.evaluationHistory.slice(-limit).map((h) => ({
+      timestamp: h.timestamp,
+      passed: h.result.passed,
+      score: h.result.score.overall,
+      input: h.context.originalInput.substring(0, 100)
+    }));
+  }
+}, _class8);
+
+// src/core/smart-agent.ts
+var SmartAgent = (_class9 = class extends Agent {
+  
+  
+  
+  
+  __init21() {this.executionHistory = []}
+  constructor(config) {
+    super(config);_class9.prototype.__init21.call(this);;
+    this.decisionEngine = new DecisionEngine(config.decisionEngine);
+    this.skillLoader = new DynamicSkillLoader(config.skillLoader);
+    this.tokenOptimizer = new TokenOptimizer(config.tokenOptimizer);
+    this.evaluationEngine = new EvaluationEngine(_nullishCoalesce(config.evaluation, () => ( { enabled: true, level: "standard", strategies: ["semantic"] })));
+    void config.autoDecide;
+    void config.maxAutoIterations;
+    void config.enableStreaming;
+  }
+  /**
+   * Initialize the smart agent
+   */
+  async initialize() {
+    await super.initialize();
+    for (const skill of this.getAllSkills()) {
+      await this.decisionEngine.indexSkill(skill);
+    }
+  }
+  /**
+   * Auto-process user input with smart decision making and evaluation
+   */
+  async process(input, context) {
+    const startTime = Date.now();
+    const tokensUsed = 0;
+    const decision = await this.makeDecision(input, context);
+    const loadedSkills = [];
+    if (decision.skills) {
+      for (const skillName of decision.skills) {
+        if (!this.getSkill(skillName)) {
+          const skill = await this.skillLoader.load(skillName);
+          if (skill) {
+            this.registerSkill(skill);
+            await this.decisionEngine.indexSkill(skill);
+            loadedSkills.push(skillName);
+          }
+        }
+      }
+    }
+    let result;
+    let skillUsed;
+    switch (decision.type) {
+      case "skill":
+        if (_optionalChain([decision, 'access', _40 => _40.skills, 'optionalAccess', _41 => _41.length]) === 1) {
+          const skillName = decision.skills[0];
+          skillUsed = this.getSkill(skillName);
+          const params = await this.extractParameters(input, skillName);
+          const skillResult = await this.executeSkill(skillName, params);
+          result = skillResult.success ? String(_nullishCoalesce(skillResult.data, () => ( "Success"))) : String(_nullishCoalesce(skillResult.error, () => ( "Error")));
+        } else {
+          result = await this.coordinateSkills(input, decision.skills || []);
+        }
+        break;
+      case "tool":
+        if (_optionalChain([decision, 'access', _42 => _42.tools, 'optionalAccess', _43 => _43.length]) === 1) {
+          const toolName = decision.tools[0];
+          const toolResult = await this.executeTool(toolName, input);
+          result = toolResult.isError ? String(_nullishCoalesce(_optionalChain([toolResult, 'access', _44 => _44.content, 'access', _45 => _45[0], 'optionalAccess', _46 => _46.text]), () => ( "Error"))) : String(_nullishCoalesce(_optionalChain([toolResult, 'access', _47 => _47.content, 'access', _48 => _48[0], 'optionalAccess', _49 => _49.text]), () => ( "Success")));
+        } else {
+          result = await this.coordinateTools(input, decision.tools || []);
+        }
+        break;
+      case "multi":
+        result = await this.executeMixed(input, decision);
+        break;
+      case "llm":
+      default:
+        result = await this.directLLMResponse(input, context);
+        break;
+    }
+    let evaluation;
+    const config = this.evaluationEngine.getConfig();
+    if (config.enabled && config.level !== "none") {
+      const skillResult = typeof result === "string" ? { success: true, data: result } : result;
+      const evalContext = {
+        originalInput: input,
+        skill: skillUsed
+      };
+      evaluation = await this.evaluationEngine.evaluate(skillResult, evalContext);
+      if (!evaluation.passed && config.autoRetry && config.maxRetries && config.maxRetries > 0) {
+        const retryResult = await this.attemptRetry(input, context, decision, config.maxRetries);
+        if (retryResult) {
+          result = retryResult.result;
+          evaluation = retryResult.evaluation;
+        }
+      }
+    }
+    this.executionHistory.push({
+      input,
+      decision,
+      timestamp: /* @__PURE__ */ new Date(),
+      evaluation
+    });
+    const executionTime = Date.now() - startTime;
+    return {
+      decision,
+      result,
+      tokensUsed,
+      executionTime,
+      skillsLoaded: loadedSkills.length > 0 ? loadedSkills : void 0,
+      evaluation
+    };
+  }
+  /**
+   * Attempt retry with improved parameters
+   */
+  async attemptRetry(input, context, originalDecision, maxRetries) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const retryDecision = {
+        ...originalDecision,
+        reasoning: `${originalDecision.reasoning} (retry attempt ${attempt})`
+      };
+      let retryResult;
+      switch (retryDecision.type) {
+        case "skill":
+          if (_optionalChain([retryDecision, 'access', _50 => _50.skills, 'optionalAccess', _51 => _51.length]) === 1) {
+            const skillName = retryDecision.skills[0];
+            const params = await this.extractParameters(input, skillName);
+            const skillResult2 = await this.executeSkill(skillName, params);
+            retryResult = skillResult2.success ? String(_nullishCoalesce(skillResult2.data, () => ( "Success"))) : String(_nullishCoalesce(skillResult2.error, () => ( "Error")));
+          } else {
+            retryResult = await this.coordinateSkills(input, retryDecision.skills || []);
+          }
+          break;
+        case "llm":
+        default:
+          retryResult = await this.directLLMResponse(input, context);
+          break;
+      }
+      const skillResult = typeof retryResult === "string" ? { success: true, data: retryResult } : retryResult;
+      const evalContext = {
+        originalInput: input
+      };
+      const evaluation = await this.evaluationEngine.evaluate(skillResult, evalContext);
+      if (evaluation.passed) {
+        return { result: retryResult, evaluation };
+      }
+    }
+    return null;
+  }
+  /**
+   * Stream process user input with evaluation
+   */
+  async *streamProcess(input, context) {
+    const decision = await this.makeDecision(input, context);
+    yield { type: "decision", data: decision };
+    let result = "";
+    let skillUsed;
+    switch (decision.type) {
+      case "skill":
+        for (const skillName of decision.skills || []) {
+          yield { type: "skill", data: { name: skillName, status: "executing" } };
+          skillUsed = this.getSkill(skillName);
+          const params = await this.extractParameters(input, skillName);
+          const skillResult = await this.executeSkill(skillName, params);
+          result = skillResult.success ? String(_nullishCoalesce(skillResult.data, () => ( "Success"))) : String(_nullishCoalesce(skillResult.error, () => ( "Error")));
+          yield { type: "skill", data: { name: skillName, result } };
+        }
+        break;
+      case "tool":
+        for (const toolName of decision.tools || []) {
+          yield { type: "tool", data: { name: toolName, status: "executing" } };
+          const toolResult = await this.executeTool(toolName, input);
+          result = toolResult.isError ? String(_nullishCoalesce(_optionalChain([toolResult, 'access', _52 => _52.content, 'access', _53 => _53[0], 'optionalAccess', _54 => _54.text]), () => ( "Error"))) : String(_nullishCoalesce(_optionalChain([toolResult, 'access', _55 => _55.content, 'access', _56 => _56[0], 'optionalAccess', _57 => _57.text]), () => ( "Success")));
+          yield { type: "tool", data: { name: toolName, result } };
+        }
+        break;
+      case "llm":
+        yield { type: "llm", data: { status: "generating" } };
+        const messages = [{ role: "user", content: input }];
+        let fullResponse = "";
+        for await (const chunk of this.streamChat(messages)) {
+          if (chunk.delta.content) {
+            fullResponse += chunk.delta.content;
+            yield { type: "llm", data: { chunk: chunk.delta.content } };
+          }
+        }
+        result = fullResponse;
+        break;
+    }
+    const config = this.evaluationEngine.getConfig();
+    if (config.enabled && config.level !== "none") {
+      const skillResult = typeof result === "string" ? { success: true, data: result } : result;
+      const evalContext = {
+        originalInput: input,
+        skill: skillUsed
+      };
+      const evaluation = await this.evaluationEngine.evaluate(skillResult, evalContext);
+      yield { type: "evaluation", data: evaluation };
+    }
+    yield { type: "complete" };
+  }
+  /**
+   * Make decision based on input
+   */
+  async makeDecision(input, context) {
+    const decisionContext = {
+      input,
+      history: this.executionHistory.slice(-5).map((h) => h.input),
+      availableSkills: this.getSkillNames(),
+      availableTools: this.getToolNames(),
+      metadata: context ? { context } : void 0
+    };
+    return this.decisionEngine.decide(decisionContext);
+  }
+  /**
+   * Extract parameters from input for a skill
+   */
+  async extractParameters(input, skillName) {
+    const skill = this.getSkill(skillName);
+    if (!skill) return {};
+    if (this.llmProvider) {
+      const prompt = this.buildParameterExtractionPrompt(input, skill);
+      const response = await this.chat([{ role: "user", content: prompt }]);
+      try {
+        const params = JSON.parse(response.content);
+        return params;
+      } catch (e2) {
+        return {};
+      }
+    }
+    return this.simpleParameterExtraction(input, skill);
+  }
+  /**
+   * Coordinate multiple skills
+   */
+  async coordinateSkills(input, skillNames) {
+    const skills = skillNames.map((name) => this.getSkill(name)).filter((s) => s !== void 0);
+    const optimizedSkills = this.tokenOptimizer.optimizeSkills(skills, input);
+    if (!this.llmProvider) {
+      const results = [];
+      for (const skill of optimizedSkills) {
+        const params = await this.extractParameters(input, skill.name);
+        const result = await this.executeSkill(skill.name, params);
+        results.push(`${skill.name}: ${result.success ? result.data : result.error}`);
+      }
+      return results.join("\n");
+    }
+    const prompt = this.tokenOptimizer.buildOptimizedPrompt(
+      input,
+      optimizedSkills,
+      "Coordinate the following skills to answer the user query."
+    );
+    const response = await this.chat([{ role: "user", content: prompt }]);
+    return response.content;
+  }
+  /**
+   * Coordinate multiple tools
+   */
+  async coordinateTools(input, toolNames) {
+    const tools = toolNames.map((name) => this.getTool(name)).filter((t) => t !== void 0);
+    const results = [];
+    for (const tool of tools) {
+      const result = await this.executeTool(tool.name, input);
+      results.push(`${tool.name}: ${_nullishCoalesce(_optionalChain([result, 'access', _58 => _58.content, 'access', _59 => _59[0], 'optionalAccess', _60 => _60.text]), () => ( "No output"))}`);
+    }
+    return results.join("\n");
+  }
+  /**
+   * Execute mixed skills and tools
+   */
+  async executeMixed(input, decision) {
+    const results = [];
+    if (decision.skills) {
+      for (const skillName of decision.skills) {
+        const params = await this.extractParameters(input, skillName);
+        const result = await this.executeSkill(skillName, params);
+        results.push(`Skill ${skillName}: ${result.success ? result.data : result.error}`);
+      }
+    }
+    if (decision.tools) {
+      for (const toolName of decision.tools) {
+        const result = await this.executeTool(toolName, input);
+        results.push(`Tool ${toolName}: ${_nullishCoalesce(_optionalChain([result, 'access', _61 => _61.content, 'access', _62 => _62[0], 'optionalAccess', _63 => _63.text]), () => ( "No output"))}`);
+      }
+    }
+    return results.join("\n");
+  }
+  /**
+   * Direct LLM response
+   */
+  async directLLMResponse(input, context) {
+    if (!this.llmProvider) {
+      return "No LLM provider configured";
+    }
+    const messages = [];
+    if (context) {
+      messages.push({
+        role: "system",
+        content: `Context: ${context}`
+      });
+    }
+    messages.push({ role: "user", content: input });
+    const response = await this.chat(messages);
+    return response.content;
+  }
+  /**
+   * Build parameter extraction prompt
+   */
+  buildParameterExtractionPrompt(input, skill) {
+    const params = Object.entries(skill.parameters.properties).map(([key, prop]) => {
+      const required = _optionalChain([skill, 'access', _64 => _64.parameters, 'access', _65 => _65.required, 'optionalAccess', _66 => _66.includes, 'call', _67 => _67(key)]) ? " (required)" : "";
+      return `- ${key}: ${prop.description}${required}`;
+    }).join("\n");
+    return `Extract parameters for skill "${skill.name}" from the following input.
+
+Skill description: ${skill.description}
+
+Parameters:
+${params}
+
+Input: "${input}"
+
+Return only a JSON object with the parameter names and values. If a parameter cannot be determined, use null or omit it.`;
+  }
+  /**
+   * Simple parameter extraction without LLM
+   */
+  simpleParameterExtraction(input, skill) {
+    const params = {};
+    for (const [key, prop] of Object.entries(skill.parameters.properties)) {
+      const patterns = [
+        new RegExp(`${key}[:=]\\s*([^,\\s]+)`, "i"),
+        new RegExp(`${key}\\s+is\\s+([^,\\s]+)`, "i"),
+        new RegExp(`${key}\\s+([^,\\s]+)`, "i")
+      ];
+      for (const pattern of patterns) {
+        const match = input.match(pattern);
+        if (match) {
+          let value = match[1];
+          if (prop.type === "number") {
+            value = parseFloat(value);
+          } else if (prop.type === "boolean") {
+            value = ["true", "yes", "1"].includes(value.toLowerCase());
+          }
+          params[key] = value;
+          break;
+        }
+      }
+      if (!(key in params) && prop.default !== void 0) {
+        params[key] = prop.default;
+      }
+    }
+    return params;
+  }
+  /**
+   * Register a skill source for dynamic loading
+   */
+  registerSkillSource(name, source, type) {
+    this.skillLoader.registerSource({
+      name,
+      type,
+      source
+    });
+  }
+  /**
+   * Get execution history
+   */
+  getExecutionHistory() {
+    return [...this.executionHistory];
+  }
+  /**
+   * Get decision engine stats
+   */
+  getDecisionStats() {
+    return {
+      cacheSize: this.decisionEngine.getCacheStats().size,
+      loadedSkills: this.skillLoader.getStats().loaded,
+      historySize: this.executionHistory.length
+    };
+  }
+  /**
+   * Get evaluation stats
+   */
+  getEvaluationStats() {
+    const stats = this.evaluationEngine.getStats();
+    const config = this.evaluationEngine.getConfig();
+    return {
+      ...stats,
+      config: {
+        enabled: config.enabled,
+        level: config.level
+      }
+    };
+  }
+  /**
+   * Update evaluation configuration
+   */
+  updateEvaluationConfig(config) {
+    this.evaluationEngine.updateConfig(config);
+  }
+  /**
+   * Get evaluation configuration
+   */
+  getEvaluationConfig() {
+    return this.evaluationEngine.getConfig();
+  }
+  /**
+   * Clear execution history
+   */
+  clearHistory() {
+    this.executionHistory = [];
+    this.decisionEngine.clearCache();
+    this.evaluationEngine.clearHistory();
+  }
+  /**
+   * Get recent evaluations
+   */
+  getRecentEvaluations(limit = 10) {
+    return this.executionHistory.filter((h) => h.evaluation).slice(-limit).map((h) => ({
+      timestamp: h.timestamp,
+      passed: h.evaluation.passed,
+      score: h.evaluation.score.overall,
+      input: h.input.substring(0, 100),
+      feedback: h.evaluation.feedback
+    }));
+  }
+  /**
+   * Generate evaluation report
+   */
+  generateEvaluationReport() {
+    const stats = this.evaluationEngine.getStats();
+    const recent = this.getRecentEvaluations(10);
+    const allSuggestions = this.executionHistory.filter((h) => h.evaluation).flatMap((h) => h.evaluation.suggestions);
+    const uniqueSuggestions = [...new Set(allSuggestions)].slice(0, 10);
+    return {
+      summary: {
+        totalExecutions: this.executionHistory.length,
+        evaluatedExecutions: stats.totalEvaluations,
+        passRate: stats.passRate,
+        averageScore: stats.averageScore
+      },
+      recentEvaluations: recent,
+      suggestions: uniqueSuggestions
+    };
+  }
+}, _class9);
+
+// src/core/advanced-decision-engine.ts
+var AdvancedDecisionEngine = (_class10 = class {
+  __init22() {this.skillEmbeddings = /* @__PURE__ */ new Map()}
+  __init23() {this.intentPatterns = []}
+  
+  __init24() {this.decisionCache = /* @__PURE__ */ new Map()}
+  __init25() {this.executionHistory = []}
+  
+  constructor(config = {}, embeddingProvider) {;_class10.prototype.__init22.call(this);_class10.prototype.__init23.call(this);_class10.prototype.__init24.call(this);_class10.prototype.__init25.call(this);
+    this.config = {
+      threshold: _nullishCoalesce(config.threshold, () => ( 0.6)),
+      maxSkills: _nullishCoalesce(config.maxSkills, () => ( 3)),
+      enableEmbeddings: _nullishCoalesce(config.enableEmbeddings, () => ( true)),
+      enableCaching: _nullishCoalesce(config.enableCaching, () => ( true)),
+      similarityThreshold: _nullishCoalesce(config.similarityThreshold, () => ( 0.5)),
+      enableIntentClassification: _nullishCoalesce(config.enableIntentClassification, () => ( true)),
+      enableContextualMemory: _nullishCoalesce(config.enableContextualMemory, () => ( true)),
+      learningRate: _nullishCoalesce(config.learningRate, () => ( 0.1))
+    };
+    this.embeddingProvider = _nullishCoalesce(embeddingProvider, () => ( new SimpleEmbeddingProvider()));
+    this.initializeIntentPatterns();
+  }
+  /**
+   * Initialize common intent patterns
+   */
+  initializeIntentPatterns() {
+    this.intentPatterns = [
+      {
+        name: "calculation",
+        patterns: [/calculate|compute|sum|add|subtract|multiply|divide/i],
+        keywords: ["math", "calculate", "compute", "number", "sum", "total"],
+        weight: 1,
+        relatedSkills: ["math", "calculator", "arithmetic"]
+      },
+      {
+        name: "data_processing",
+        patterns: [/process|transform|convert|parse|extract/i],
+        keywords: ["data", "process", "transform", "convert", "parse", "extract"],
+        weight: 1,
+        relatedSkills: ["data-processor", "transformer", "parser"]
+      },
+      {
+        name: "document_analysis",
+        patterns: [/analyze|read|extract|summarize.*document|pdf/i],
+        keywords: ["document", "pdf", "analyze", "read", "extract", "text"],
+        weight: 1,
+        relatedSkills: ["pdf-processor", "document-reader", "text-extractor"]
+      },
+      {
+        name: "search_query",
+        patterns: [/search|find|lookup|query/i],
+        keywords: ["search", "find", "lookup", "query", "retrieve"],
+        weight: 0.9,
+        relatedSkills: ["search", "retrieval", "lookup"]
+      },
+      {
+        name: "generation",
+        patterns: [/generate|create|write|compose|draft/i],
+        keywords: ["generate", "create", "write", "compose", "draft", "produce"],
+        weight: 0.9,
+        relatedSkills: ["generator", "writer", "creator"]
+      },
+      {
+        name: "comparison",
+        patterns: [/compare|difference|versus|vs|better|best/i],
+        keywords: ["compare", "difference", "versus", "contrast", "evaluate"],
+        weight: 0.8,
+        relatedSkills: ["comparator", "evaluator"]
+      },
+      {
+        name: "information_retrieval",
+        patterns: [/what is|how to|explain|tell me about|describe/i],
+        keywords: ["information", "explain", "describe", "what", "how", "why"],
+        weight: 0.7,
+        relatedSkills: ["qa", "information-retrieval", "explainer"]
+      }
+    ];
+  }
+  /**
+   * Make advanced decision with full context analysis
+   */
+  async decide(context, executionContext) {
+    const cacheKey = this.generateCacheKey(context, executionContext);
+    if (this.config.enableCaching) {
+      const cached = this.decisionCache.get(cacheKey);
+      if (cached) {
+        return this.enrichDecisionWithContext(cached, executionContext);
+      }
+    }
+    const intentResult = this.config.enableIntentClassification ? this.classifyIntent(context.input) : { intent: "general", confidence: 0.5 };
+    const relevantSkills = await this.findRelevantSkills(context, intentResult);
+    const relevantTools = this.findRelevantTools(context, intentResult);
+    const decision = await this.buildDecision(
+      context,
+      intentResult,
+      relevantSkills,
+      relevantTools,
+      executionContext
+    );
+    if (this.config.enableCaching) {
+      this.decisionCache.set(cacheKey, decision);
+      this.limitCacheSize();
+    }
+    return decision;
+  }
+  /**
+   * Classify user intent from input
+   */
+  classifyIntent(input) {
+    const scores = [];
+    for (const pattern of this.intentPatterns) {
+      let score = 0;
+      for (const regex of pattern.patterns) {
+        if (regex.test(input)) {
+          score += pattern.weight * 0.6;
+        }
+      }
+      const inputLower = input.toLowerCase();
+      const keywordMatches = pattern.keywords.filter((kw) => inputLower.includes(kw));
+      score += keywordMatches.length / pattern.keywords.length * pattern.weight * 0.4;
+      if (score > 0) {
+        scores.push({ intent: pattern.name, score });
+      }
+    }
+    scores.sort((a, b) => b.score - a.score);
+    if (scores.length === 0) {
+      return { intent: "general", confidence: 0.3 };
+    }
+    const topScore = scores[0].score;
+    const normalizedConfidence = Math.min(topScore / 0.8, 1);
+    return {
+      intent: scores[0].intent,
+      confidence: normalizedConfidence
+    };
+  }
+  /**
+   * Find relevant skills with intent boosting
+   */
+  async findRelevantSkills(decisionContext, intentResult) {
+    const results = [];
+    const intentPattern = this.intentPatterns.find((p) => p.name === intentResult.intent);
+    if (this.config.enableEmbeddings && this.skillEmbeddings.size > 0) {
+      const inputEmbedding = await this.embeddingProvider.embed(decisionContext.input);
+      for (const [skillName, skillEmbedding] of this.skillEmbeddings) {
+        const similarity = this.embeddingProvider.similarity(inputEmbedding, skillEmbedding);
+        let confidence = similarity;
+        const reasons = [];
+        if (_optionalChain([intentPattern, 'optionalAccess', _68 => _68.relatedSkills, 'access', _69 => _69.includes, 'call', _70 => _70(skillName)])) {
+          confidence = Math.min(confidence * 1.3, 1);
+          reasons.push(`Matches ${intentResult.intent} intent`);
+        }
+        if (confidence >= this.config.similarityThreshold) {
+          results.push({ name: skillName, confidence, reasons });
+        }
+      }
+    } else {
+      const inputKeywords = this.extractKeywordsFromText(decisionContext.input);
+      for (const skillName of decisionContext.availableSkills) {
+        const skillKeywords = skillName.toLowerCase().split(/[_-]/);
+        const matches = inputKeywords.filter(
+          (kw) => skillKeywords.some((sk) => sk.includes(kw) || kw.includes(sk))
+        );
+        if (matches.length > 0) {
+          let confidence = matches.length / Math.max(inputKeywords.length, skillKeywords.length);
+          const reasons = [`Keyword match: ${matches.join(", ")}`];
+          if (_optionalChain([intentPattern, 'optionalAccess', _71 => _71.relatedSkills, 'access', _72 => _72.includes, 'call', _73 => _73(skillName)])) {
+            confidence = Math.min(confidence * 1.3, 1);
+            reasons.push(`Matches ${intentResult.intent} intent`);
+          }
+          if (confidence >= this.config.threshold) {
+            results.push({ name: skillName, confidence, reasons });
+          }
+        }
+      }
+    }
+    results.sort((a, b) => b.confidence - a.confidence);
+    return results;
+  }
+  /**
+   * Find relevant tools with intent consideration
+   */
+  findRelevantTools(context, intentResult) {
+    const inputKeywords = this.extractKeywordsFromText(context.input);
+    const results = [];
+    for (const toolName of context.availableTools) {
+      const toolKeywords = toolName.toLowerCase().split(/[_-]/);
+      const matches = inputKeywords.filter(
+        (kw) => toolKeywords.some((tk) => tk.includes(kw) || kw.includes(tk))
+      );
+      if (matches.length > 0) {
+        let confidence = matches.length / Math.max(inputKeywords.length, toolKeywords.length);
+        const reasons = [`Keyword match: ${matches.join(", ")}`];
+        if (intentResult.intent !== "general" && matches.some((m) => m.includes(intentResult.intent))) {
+          confidence = Math.min(confidence * 1.2, 1);
+          reasons.push(`Matches ${intentResult.intent} intent`);
+        }
+        if (confidence >= this.config.threshold) {
+          results.push({ name: toolName, confidence, reasons });
+        }
+      }
+    }
+    results.sort((a, b) => b.confidence - a.confidence);
+    return results;
+  }
+  /**
+   * Build comprehensive decision
+   */
+  async buildDecision(_decisionContext, intentResult, relevantSkills, relevantTools, executionContext) {
+    let type = "llm";
+    let skills;
+    let tools;
+    let reasoning;
+    let confidence;
+    let subDecisions;
+    const topSkills = relevantSkills.slice(0, this.config.maxSkills);
+    const topTools = relevantTools.slice(0, 2);
+    if (topSkills.length === 0 && topTools.length === 0) {
+      type = "llm";
+      confidence = 1;
+      reasoning = `No relevant skills/tools found for intent "${intentResult.intent}". Using LLM directly.`;
+    } else if (topSkills.length === 1 && topTools.length === 0) {
+      type = "skill";
+      skills = [topSkills[0].name];
+      confidence = topSkills[0].confidence * intentResult.confidence;
+      reasoning = `Single skill match: ${topSkills[0].name}. ${topSkills[0].reasons.join("; ")}`;
+    } else if (topTools.length === 1 && topSkills.length === 0) {
+      type = "tool";
+      tools = [topTools[0].name];
+      confidence = topTools[0].confidence * intentResult.confidence;
+      reasoning = `Single tool match: ${topTools[0].name}. ${topTools[0].reasons.join("; ")}`;
+    } else {
+      type = "multi";
+      skills = topSkills.map((s) => s.name);
+      tools = topTools.map((t) => t.name);
+      confidence = Math.max(
+        _nullishCoalesce(_optionalChain([topSkills, 'access', _74 => _74[0], 'optionalAccess', _75 => _75.confidence]), () => ( 0)),
+        _nullishCoalesce(_optionalChain([topTools, 'access', _76 => _76[0], 'optionalAccess', _77 => _77.confidence]), () => ( 0))
+      ) * intentResult.confidence;
+      reasoning = `Multiple matches for intent "${intentResult.intent}": Skills [${skills.join(", ")}], Tools [${tools.join(", ")}]`;
+      subDecisions = this.buildSubDecisions(topSkills, topTools);
+    }
+    const estimatedTokens = this.estimateTokenUsage(type, skills, tools);
+    const estimatedTime = this.estimateExecutionTime(type, skills, tools);
+    if (_optionalChain([executionContext, 'optionalAccess', _78 => _78.constraints])) {
+      const { maxTokens, maxTime, allowedSkills, blockedSkills } = executionContext.constraints;
+      if (maxTokens && estimatedTokens > maxTokens) {
+        reasoning += ` (Token limit exceeded: ${estimatedTokens} > ${maxTokens})`;
+        confidence *= 0.8;
+      }
+      if (maxTime && estimatedTime > maxTime) {
+        reasoning += ` (Time limit exceeded: ${estimatedTime}ms > ${maxTime}ms)`;
+        confidence *= 0.8;
+      }
+      if (blockedSkills && skills) {
+        skills = skills.filter((s) => !blockedSkills.includes(s));
+      }
+      if (allowedSkills && skills) {
+        skills = skills.filter((s) => allowedSkills.includes(s));
+      }
+    }
+    return {
+      type,
+      skills,
+      tools,
+      confidence,
+      reasoning,
+      fallback: confidence < 0.5 ? "llm" : void 0,
+      intent: intentResult.intent,
+      intentConfidence: intentResult.confidence,
+      subDecisions,
+      estimatedTokens,
+      estimatedTime
+    };
+  }
+  /**
+   * Build sub-decisions for complex scenarios
+   */
+  buildSubDecisions(skills, tools) {
+    const subDecisions = [];
+    for (const skill of skills) {
+      subDecisions.push({
+        type: "skill",
+        skills: [skill.name],
+        confidence: skill.confidence,
+        reasoning: `Execute skill: ${skill.name}`,
+        intent: "sub-task",
+        intentConfidence: skill.confidence,
+        estimatedTokens: 500,
+        estimatedTime: 1e3
+      });
+    }
+    for (const tool of tools) {
+      subDecisions.push({
+        type: "tool",
+        tools: [tool.name],
+        confidence: tool.confidence,
+        reasoning: `Execute tool: ${tool.name}`,
+        intent: "sub-task",
+        intentConfidence: tool.confidence,
+        estimatedTokens: 200,
+        estimatedTime: 500
+      });
+    }
+    return subDecisions;
+  }
+  /**
+   * Enrich decision with execution context
+   */
+  enrichDecisionWithContext(decision, executionContext) {
+    if (!executionContext || !this.config.enableContextualMemory) {
+      return decision;
+    }
+    const similarDecisions = executionContext.previousDecisions.filter(
+      (d) => d.intent === decision.intent
+    );
+    if (similarDecisions.length > 0) {
+      const avgSuccess = similarDecisions.filter((d) => d.confidence > 0.7).length / similarDecisions.length;
+      decision.confidence = decision.confidence * (0.8 + avgSuccess * 0.2);
+    }
+    return decision;
+  }
+  /**
+   * Estimate token usage
+   */
+  estimateTokenUsage(type, skills, tools) {
+    let tokens = 500;
+    if (type === "skill" || type === "multi") {
+      tokens += (_nullishCoalesce(_optionalChain([skills, 'optionalAccess', _79 => _79.length]), () => ( 0))) * 800;
+    }
+    if (type === "tool" || type === "multi") {
+      tokens += (_nullishCoalesce(_optionalChain([tools, 'optionalAccess', _80 => _80.length]), () => ( 0))) * 300;
+    }
+    if (type === "llm") {
+      tokens += 2e3;
+    }
+    return tokens;
+  }
+  /**
+   * Estimate execution time
+   */
+  estimateExecutionTime(type, skills, tools) {
+    let time = 500;
+    if (type === "skill" || type === "multi") {
+      time += (_nullishCoalesce(_optionalChain([skills, 'optionalAccess', _81 => _81.length]), () => ( 0))) * 2e3;
+    }
+    if (type === "tool" || type === "multi") {
+      time += (_nullishCoalesce(_optionalChain([tools, 'optionalAccess', _82 => _82.length]), () => ( 0))) * 1e3;
+    }
+    if (type === "llm") {
+      time += 3e3;
+    }
+    return time;
+  }
+  /**
+   * Learn from execution result
+   */
+  learn(input, decision, success, executionTime) {
+    this.executionHistory.push({
+      input,
+      decision,
+      success,
+      executionTime
+    });
+    if (this.executionHistory.length > 1e3) {
+      this.executionHistory = this.executionHistory.slice(-500);
+    }
+    if (this.config.enableContextualMemory) {
+      const pattern = this.intentPatterns.find((p) => p.name === decision.intent);
+      if (pattern) {
+        const adjustment = success ? this.config.learningRate : -this.config.learningRate;
+        pattern.weight = Math.max(0.1, Math.min(2, pattern.weight + adjustment));
+      }
+    }
+  }
+  /**
+   * Index skill for retrieval
+   */
+  async indexSkill(skill) {
+    if (!this.config.enableEmbeddings) return;
+    const text = `${skill.name} ${skill.description} ${this.extractKeywords(skill)}`;
+    const embedding = await this.embeddingProvider.embed(text);
+    this.skillEmbeddings.set(skill.name, embedding);
+  }
+  /**
+   * Extract keywords from skill
+   */
+  extractKeywords(skill) {
+    const keywords = [
+      skill.name,
+      skill.description,
+      ..._nullishCoalesce(_optionalChain([skill, 'access', _83 => _83.metadata, 'optionalAccess', _84 => _84.tags]), () => ( [])),
+      _nullishCoalesce(_optionalChain([skill, 'access', _85 => _85.metadata, 'optionalAccess', _86 => _86.category]), () => ( ""))
+    ];
+    for (const [key, prop] of Object.entries(skill.parameters.properties)) {
+      keywords.push(key, prop.description);
+    }
+    return keywords.join(" ");
+  }
+  /**
+   * Extract keywords from text
+   */
+  extractKeywordsFromText(text) {
+    return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+  }
+  /**
+   * Generate cache key
+   */
+  generateCacheKey(context, executionContext) {
+    const base = `${context.input}:${context.availableSkills.join(",")}:${context.availableTools.join(",")}`;
+    if (_optionalChain([executionContext, 'optionalAccess', _87 => _87.constraints, 'access', _88 => _88.allowedSkills])) {
+      return `${base}:${executionContext.constraints.allowedSkills.join(",")}`;
+    }
+    return base;
+  }
+  /**
+   * Limit cache size
+   */
+  limitCacheSize() {
+    if (this.decisionCache.size > 1e3) {
+      const firstKey = this.decisionCache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.decisionCache.delete(firstKey);
+      }
+    }
+  }
+  /**
+   * Get performance statistics
+   */
+  getStats() {
+    const successCount = this.executionHistory.filter((h) => h.success).length;
+    const averageSuccessRate = this.executionHistory.length > 0 ? successCount / this.executionHistory.length : 0;
+    return {
+      cacheSize: this.decisionCache.size,
+      historySize: this.executionHistory.length,
+      intentPatterns: this.intentPatterns.map((p) => ({ name: p.name, weight: p.weight })),
+      averageSuccessRate
+    };
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.decisionCache.clear();
+    this.executionHistory = [];
+    this.skillEmbeddings.clear();
+  }
+}, _class10);
+
+// src/core/parameter-extractor.ts
+var ParameterExtractor = class {
+  
+  constructor(config = {}) {
+    this.config = {
+      useLLM: _nullishCoalesce(config.useLLM, () => ( true)),
+      usePatternMatching: _nullishCoalesce(config.usePatternMatching, () => ( true)),
+      useContextInference: _nullishCoalesce(config.useContextInference, () => ( true)),
+      confidenceThreshold: _nullishCoalesce(config.confidenceThreshold, () => ( 0.7)),
+      maxRetries: _nullishCoalesce(config.maxRetries, () => ( 3))
+    };
+  }
+  /**
+   * Extract parameters from input using multiple strategies
+   */
+  async extract(input, skill, context, llmProvider) {
+    const results = [];
+    if (this.config.usePatternMatching) {
+      const patternResult = this.extractWithPatterns(input, skill);
+      results.push(patternResult);
+    }
+    if (this.config.useContextInference && context) {
+      const contextResult = this.extractFromContext(skill, context);
+      results.push(contextResult);
+    }
+    if (this.config.useLLM && llmProvider) {
+      const llmResult = await this.extractWithLLM(input, skill, llmProvider);
+      results.push(llmResult);
+    }
+    return this.mergeResults(results, skill);
+  }
+  /**
+   * Extract parameters using pattern matching
+   */
+  extractWithPatterns(input, skill) {
+    const params = {};
+    const missing = [];
+    const invalid = [];
+    const suggestions = [];
+    let confidence = 0;
+    for (const [key, prop] of Object.entries(skill.parameters.properties)) {
+      const schema = this.convertPropertyToSchema(prop);
+      const value = this.extractValueWithPatterns(input, key, schema);
+      if (value !== void 0) {
+        const validation = this.validateValue(value, schema);
+        if (validation.valid) {
+          params[key] = value;
+          confidence += 0.3;
+        } else {
+          invalid.push({ param: key, reason: validation.reason || "Invalid value" });
+          suggestions.push({
+            param: key,
+            suggestion: this.generateSuggestion(schema, validation.reason)
+          });
+        }
+      } else if (_optionalChain([skill, 'access', _89 => _89.parameters, 'access', _90 => _90.required, 'optionalAccess', _91 => _91.includes, 'call', _92 => _92(key)])) {
+        missing.push(key);
+        suggestions.push({
+          param: key,
+          suggestion: `Please provide ${prop.description}`
+        });
+      } else if (prop.default !== void 0) {
+        params[key] = prop.default;
+        confidence += 0.1;
+      }
+    }
+    const totalParams = Object.keys(skill.parameters.properties).length;
+    confidence = totalParams > 0 ? confidence / totalParams : 0;
+    return {
+      params,
+      confidence,
+      missing,
+      invalid,
+      suggestions
+    };
+  }
+  /**
+   * Convert ParameterProperty to ParameterSchema
+   */
+  convertPropertyToSchema(prop) {
+    const type = prop.type;
+    return {
+      type,
+      description: prop.description,
+      enum: prop.enum,
+      default: prop.default
+    };
+  }
+  /**
+   * Extract a single value using patterns
+   */
+  extractValueWithPatterns(input, key, schema) {
+    const patterns = [
+      // "key: value" or "key = value"
+      new RegExp(`${key}[:=]\\s*([^,;\\n]+)`, "i"),
+      // "key is value"
+      new RegExp(`${key}\\s+is\\s+([^,;\\n]+)`, "i"),
+      // "with key value" or "using key value"
+      new RegExp(`(?:with|using)\\s+${key}\\s+([^,;\\n]+)`, "i"),
+      // "key value" (positional)
+      new RegExp(`${key}\\s+([^,;\\n]+)`, "i")
+    ];
+    for (const pattern of patterns) {
+      const match = input.match(pattern);
+      if (match) {
+        const rawValue = match[1].trim();
+        return this.coerceValue(rawValue, schema);
+      }
+    }
+    if (schema.type === "array" && schema.items) {
+      return this.extractArrayValue(input, key, schema.items);
+    }
+    if (schema.type === "boolean") {
+      const boolPattern = new RegExp(`\\b${key}\\b`, "i");
+      if (boolPattern.test(input)) {
+        const negativePattern = new RegExp(`(no\\s+${key}|without\\s+${key}|disable\\s+${key})`, "i");
+        return !negativePattern.test(input);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Extract array values
+   */
+  extractArrayValue(input, key, itemSchema) {
+    const patterns = [
+      new RegExp(`${key}[:=]\\s*\\[([^\\]]+)\\]`, "i"),
+      new RegExp(`${key}[:=]\\s*([^,;\\n]+)`, "i")
+    ];
+    for (const pattern of patterns) {
+      const match = input.match(pattern);
+      if (match) {
+        const items = match[1].split(/[,;]/).map((s) => s.trim());
+        return items.map((item) => this.coerceValue(item, itemSchema));
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Coerce value to correct type
+   */
+  coerceValue(rawValue, schema) {
+    switch (schema.type) {
+      case "number": {
+        const num = parseFloat(rawValue);
+        return isNaN(num) ? rawValue : num;
+      }
+      case "boolean":
+        return ["true", "yes", "1", "on"].includes(rawValue.toLowerCase());
+      case "array": {
+        try {
+          const parsed = JSON.parse(rawValue);
+          if (Array.isArray(parsed)) return parsed;
+        } catch (e3) {
+          return rawValue.split(/[,;]/).map((s) => s.trim());
+        }
+        return [rawValue];
+      }
+      case "object":
+        try {
+          return JSON.parse(rawValue);
+        } catch (e4) {
+          return rawValue;
+        }
+      case "string":
+      default:
+        if (schema.enum) {
+          const match = schema.enum.find(
+            (e) => String(e).toLowerCase() === rawValue.toLowerCase()
+          );
+          if (match !== void 0) return match;
+        }
+        return rawValue;
+    }
+  }
+  /**
+   * Validate extracted value
+   */
+  validateValue(value, schema) {
+    if (schema.enum && !schema.enum.includes(value)) {
+      return {
+        valid: false,
+        reason: `Value must be one of: ${schema.enum.join(", ")}`
+      };
+    }
+    if (schema.pattern && typeof value === "string") {
+      const regex = new RegExp(schema.pattern);
+      if (!regex.test(value)) {
+        return {
+          valid: false,
+          reason: `Value does not match required pattern`
+        };
+      }
+    }
+    if (schema.type === "number" && typeof value === "number") {
+      if (schema.min !== void 0 && value < schema.min) {
+        return {
+          valid: false,
+          reason: `Value must be at least ${schema.min}`
+        };
+      }
+      if (schema.max !== void 0 && value > schema.max) {
+        return {
+          valid: false,
+          reason: `Value must be at most ${schema.max}`
+        };
+      }
+    }
+    if (schema.type === "array" && Array.isArray(value)) {
+      if (schema.min !== void 0 && value.length < schema.min) {
+        return {
+          valid: false,
+          reason: `Array must have at least ${schema.min} items`
+        };
+      }
+      if (schema.max !== void 0 && value.length > schema.max) {
+        return {
+          valid: false,
+          reason: `Array must have at most ${schema.max} items`
+        };
+      }
+    }
+    return { valid: true };
+  }
+  /**
+   * Extract parameters from context
+   */
+  extractFromContext(skill, context) {
+    const params = {};
+    const missing = [];
+    const invalid = [];
+    const suggestions = [];
+    let confidence = 0;
+    for (const key of Object.keys(skill.parameters.properties)) {
+      const prop = skill.parameters.properties[key];
+      if (_optionalChain([context, 'access', _93 => _93.previousParams, 'optionalAccess', _94 => _94[key]]) !== void 0) {
+        params[key] = context.previousParams[key];
+        confidence += 0.2;
+        continue;
+      }
+      if (_optionalChain([context, 'access', _95 => _95.userPreferences, 'optionalAccess', _96 => _96[key]]) !== void 0) {
+        params[key] = context.userPreferences[key];
+        confidence += 0.15;
+        continue;
+      }
+      if (_optionalChain([context, 'access', _97 => _97.extractedEntities, 'optionalAccess', _98 => _98[key]]) !== void 0) {
+        params[key] = context.extractedEntities[key];
+        confidence += 0.25;
+        continue;
+      }
+      if (prop.default !== void 0) {
+        params[key] = prop.default;
+        confidence += 0.1;
+      } else if (_optionalChain([skill, 'access', _99 => _99.parameters, 'access', _100 => _100.required, 'optionalAccess', _101 => _101.includes, 'call', _102 => _102(key)])) {
+        missing.push(key);
+        suggestions.push({
+          param: key,
+          suggestion: `Please provide ${prop.description}`
+        });
+      }
+    }
+    const totalParams = Object.keys(skill.parameters.properties).length;
+    confidence = totalParams > 0 ? confidence / totalParams : 0;
+    return {
+      params,
+      confidence,
+      missing,
+      invalid,
+      suggestions
+    };
+  }
+  /**
+   * Extract parameters using LLM
+   */
+  async extractWithLLM(input, skill, llmProvider) {
+    const prompt = this.buildExtractionPrompt(input, skill);
+    try {
+      const response = await llmProvider.complete(prompt);
+      const parsed = JSON.parse(response.content);
+      return {
+        params: parsed.params || {},
+        confidence: parsed.confidence || 0.8,
+        missing: parsed.missing || [],
+        invalid: parsed.invalid || [],
+        suggestions: parsed.suggestions || []
+      };
+    } catch (e5) {
+      return {
+        params: {},
+        confidence: 0,
+        missing: skill.parameters.required || [],
+        invalid: [],
+        suggestions: []
+      };
+    }
+  }
+  /**
+   * Build LLM extraction prompt
+   */
+  buildExtractionPrompt(input, skill) {
+    const params = Object.entries(skill.parameters.properties).map(([key, prop]) => {
+      const required = _optionalChain([skill, 'access', _103 => _103.parameters, 'access', _104 => _104.required, 'optionalAccess', _105 => _105.includes, 'call', _106 => _106(key)]) ? " (required)" : "";
+      const type = prop.type ? ` [${prop.type}]` : "";
+      const enum_ = prop.enum ? ` enum: [${prop.enum.join(", ")}]` : "";
+      return `- ${key}${type}${required}: ${prop.description}${enum_}`;
+    }).join("\n");
+    return `Extract parameters from the user input for the skill "${skill.name}".
+
+Skill description: ${skill.description}
+
+Parameters:
+${params}
+
+User input: "${input}"
+
+Return a JSON object with this structure:
+{
+  "params": { "paramName": "extractedValue", ... },
+  "confidence": 0.0-1.0,
+  "missing": ["paramName", ...],
+  "invalid": [{"param": "name", "reason": "why invalid"}],
+  "suggestions": [{"param": "name", "suggestion": "helpful suggestion"}]
+}`;
+  }
+  /**
+   * Merge extraction results from multiple strategies
+   */
+  mergeResults(results, skill) {
+    const merged = {};
+    const missing = /* @__PURE__ */ new Set();
+    const invalid = [];
+    const suggestions = [];
+    let totalConfidence = 0;
+    const weights = results.map((r) => r.confidence);
+    for (const key of Object.keys(skill.parameters.properties)) {
+      const prop = skill.parameters.properties[key];
+      const values = [];
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (key in result.params) {
+          values.push({ value: result.params[key], weight: weights[i] });
+        }
+      }
+      if (values.length > 0) {
+        values.sort((a, b) => b.weight - a.weight);
+        merged[key] = values[0].value;
+        totalConfidence += values[0].weight;
+      } else if (_optionalChain([skill, 'access', _107 => _107.parameters, 'access', _108 => _108.required, 'optionalAccess', _109 => _109.includes, 'call', _110 => _110(key)])) {
+        missing.add(key);
+      } else if (prop.default !== void 0) {
+        merged[key] = prop.default;
+        totalConfidence += 0.1;
+      }
+    }
+    for (const result of results) {
+      result.missing.forEach((m) => missing.add(m));
+      invalid.push(...result.invalid);
+      suggestions.push(...result.suggestions);
+    }
+    const totalParams = Object.keys(skill.parameters.properties).length;
+    const avgConfidence = totalParams > 0 ? totalConfidence / totalParams : 0;
+    return {
+      params: merged,
+      confidence: avgConfidence,
+      missing: Array.from(missing),
+      invalid,
+      suggestions
+    };
+  }
+  /**
+   * Generate helpful suggestion for invalid parameter
+   */
+  generateSuggestion(schema, reason) {
+    if (schema.enum) {
+      return `Please use one of: ${schema.enum.join(", ")}`;
+    }
+    if (schema.pattern) {
+      return `Value must match pattern: ${schema.pattern}`;
+    }
+    if (schema.min !== void 0 || schema.max !== void 0) {
+      const range = `${_nullishCoalesce(schema.min, () => ( "min"))} to ${_nullishCoalesce(schema.max, () => ( "max"))}`;
+      return `Value must be within range ${range}`;
+    }
+    return reason || `Please provide valid ${schema.type}`;
+  }
+  /**
+   * Validate all parameters against schema
+   */
+  validate(params, skill) {
+    const missing = [];
+    const invalid = [];
+    for (const key of Object.keys(skill.parameters.properties)) {
+      const prop = skill.parameters.properties[key];
+      if (!(key in params)) {
+        if (_optionalChain([skill, 'access', _111 => _111.parameters, 'access', _112 => _112.required, 'optionalAccess', _113 => _113.includes, 'call', _114 => _114(key)])) {
+          missing.push(key);
+        }
+        continue;
+      }
+      const schema = this.convertPropertyToSchema(prop);
+      const validation = this.validateValue(params[key], schema);
+      if (!validation.valid) {
+        invalid.push({ param: key, reason: validation.reason || "Invalid value" });
+      }
+    }
+    return {
+      params,
+      confidence: 1,
+      missing,
+      invalid,
+      suggestions: invalid.map((inv) => ({
+        param: inv.param,
+        suggestion: this.generateSuggestion(
+          this.convertPropertyToSchema(skill.parameters.properties[inv.param]),
+          inv.reason
+        )
+      }))
+    };
+  }
+};
+
+// src/core/execution-engine.ts
+var ExecutionEngine = (_class11 = class {
+  
+  __init26() {this.activeExecutions = /* @__PURE__ */ new Map()}
+  __init27() {this.circuitBreakers = /* @__PURE__ */ new Map()}
+  __init28() {this.metrics = {
+    totalTime: 0,
+    totalTokens: 0,
+    llmCalls: 0,
+    skillCalls: 0,
+    toolCalls: 0,
+    cacheHits: 0,
+    cacheMisses: 0,
+    retryCount: 0
+  }}
+  constructor(config = {}) {;_class11.prototype.__init26.call(this);_class11.prototype.__init27.call(this);_class11.prototype.__init28.call(this);
+    this.config = {
+      defaultTimeout: _nullishCoalesce(config.defaultTimeout, () => ( 3e4)),
+      defaultRetryPolicy: _nullishCoalesce(config.defaultRetryPolicy, () => ( {
+        maxRetries: 3,
+        backoffStrategy: "exponential",
+        baseDelay: 1e3,
+        maxDelay: 3e4,
+        retryableErrors: ["ETIMEDOUT", "ECONNRESET", "EAI_AGAIN"]
+      })),
+      enableTracing: _nullishCoalesce(config.enableTracing, () => ( true)),
+      enableMetrics: _nullishCoalesce(config.enableMetrics, () => ( true)),
+      maxConcurrentExecutions: _nullishCoalesce(config.maxConcurrentExecutions, () => ( 10)),
+      observers: _nullishCoalesce(config.observers, () => ( []))
+    };
+  }
+  async execute(plan, context = {}, resilience) {
+    const executionId = this.generateId();
+    const fullContext = {
+      executionId,
+      sessionId: _nullishCoalesce(context.sessionId, () => ( this.generateId())),
+      timestamp: /* @__PURE__ */ new Date(),
+      metadata: _nullishCoalesce(context.metadata, () => ( {})),
+      ...context
+    };
+    if (this.activeExecutions.size >= this.config.maxConcurrentExecutions) {
+      throw new Error("Maximum concurrent executions reached");
+    }
+    const abortController = new AbortController();
+    this.activeExecutions.set(executionId, abortController);
+    const startTime = Date.now();
+    const trace = {
+      phases: [],
+      decisions: [],
+      llmCalls: []
+    };
+    try {
+      this.notifyObservers("onExecutionStart", fullContext);
+      await this.executePhase("initialization", fullContext, trace, async () => {
+        this.validatePlan(plan);
+      });
+      const stepResults = await this.executePhase("execution", fullContext, trace, async () => {
+        return this.executeSteps(plan.steps, fullContext, abortController.signal, resilience);
+      });
+      const finalOutput = await this.executePhase(
+        "result_processing",
+        fullContext,
+        trace,
+        async () => {
+          return this.processResults(stepResults);
+        }
+      );
+      const result = {
+        executionId,
+        status: this.determineFinalStatus(stepResults),
+        plan,
+        stepResults,
+        finalOutput,
+        metrics: { ...this.metrics },
+        errors: stepResults.filter((s) => s.error).map((s) => s.error),
+        trace
+      };
+      this.metrics.totalTime = Date.now() - startTime;
+      this.notifyObservers("onExecutionEnd", result, fullContext);
+      return result;
+    } catch (error) {
+      const executionError = {
+        stepId: "engine",
+        code: "EXECUTION_FAILED",
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        recoverable: false
+      };
+      this.notifyObservers("onError", executionError, fullContext);
+      return {
+        executionId,
+        status: "failed",
+        plan,
+        stepResults: [],
+        finalOutput: null,
+        metrics: { ...this.metrics },
+        errors: [executionError],
+        trace
+      };
+    } finally {
+      this.activeExecutions.delete(executionId);
+    }
+  }
+  async executeSteps(steps, context, signal, resilience) {
+    const results = [];
+    const executedSteps = /* @__PURE__ */ new Set();
+    while (executedSteps.size < steps.length) {
+      const readySteps = steps.filter(
+        (step) => !executedSteps.has(step.id) && (_nullishCoalesce(step.dependencies, () => ( []))).every((dep) => executedSteps.has(dep))
+      );
+      if (readySteps.length === 0) {
+        const remainingSteps = steps.filter((s) => !executedSteps.has(s.id));
+        if (remainingSteps.length > 0) {
+          throw new Error(
+            `Circular dependency detected: ${remainingSteps.map((s) => s.id).join(", ")}`
+          );
+        }
+        break;
+      }
+      const stepPromises = readySteps.map(
+        (step) => this.executeStepWithResilience(step, context, signal, resilience)
+      );
+      const stepResults = await Promise.all(stepPromises);
+      for (const result of stepResults) {
+        results.push(result);
+        executedSteps.add(result.stepId);
+        if (result.status === "failed" && result.error) {
+          const step = steps.find((s) => s.id === result.stepId);
+          if (_optionalChain([step, 'optionalAccess', _115 => _115.onError]) === "fail") {
+            return results;
+          }
+        }
+      }
+    }
+    return results;
+  }
+  async executeStepWithResilience(step, context, signal, resilience) {
+    const startTime = Date.now();
+    const retryPolicy = _nullishCoalesce(_optionalChain([resilience, 'optionalAccess', _116 => _116.retryPolicy]), () => ( this.config.defaultRetryPolicy));
+    const timeout = _nullishCoalesce(_nullishCoalesce(step.timeout, () => ( _optionalChain([resilience, 'optionalAccess', _117 => _117.timeout]))), () => ( this.config.defaultTimeout));
+    this.notifyObservers("onStepStart", step, context);
+    let lastError;
+    for (let attempt = 0; attempt <= retryPolicy.maxRetries; attempt++) {
+      try {
+        if (signal.aborted) {
+          throw new Error("Execution aborted");
+        }
+        if (_optionalChain([resilience, 'optionalAccess', _118 => _118.circuitBreaker])) {
+          const cb = this.getCircuitBreaker(step.target, resilience.circuitBreaker);
+          if (!cb.canExecute()) {
+            throw new Error(`Circuit breaker open for ${step.target}`);
+          }
+        }
+        const result = await this.executeWithTimeout(
+          () => this.executeStep(step, context),
+          timeout
+        );
+        if (_optionalChain([resilience, 'optionalAccess', _119 => _119.circuitBreaker])) {
+          const cb = this.getCircuitBreaker(step.target, resilience.circuitBreaker);
+          cb.recordSuccess();
+        }
+        const stepResult2 = {
+          stepId: step.id,
+          status: "completed",
+          output: result,
+          executionTime: Date.now() - startTime,
+          tokensUsed: 0,
+          startTime: new Date(startTime),
+          endTime: /* @__PURE__ */ new Date()
+        };
+        this.notifyObservers("onStepEnd", step, stepResult2, context);
+        return stepResult2;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (_optionalChain([resilience, 'optionalAccess', _120 => _120.circuitBreaker])) {
+          const cb = this.getCircuitBreaker(step.target, resilience.circuitBreaker);
+          cb.recordFailure();
+        }
+        const isRetryable = this.isRetryableError(lastError, retryPolicy);
+        if (!isRetryable || attempt === retryPolicy.maxRetries) {
+          break;
+        }
+        const delay = this.calculateBackoff(attempt, retryPolicy);
+        _optionalChain([retryPolicy, 'access', _121 => _121.onRetry, 'optionalCall', _122 => _122(attempt + 1, lastError, delay)]);
+        this.metrics.retryCount++;
+        await this.sleep(delay);
+      }
+    }
+    const stepResult = {
+      stepId: step.id,
+      status: "failed",
+      error: {
+        stepId: step.id,
+        code: "STEP_EXECUTION_FAILED",
+        message: _nullishCoalesce(_optionalChain([lastError, 'optionalAccess', _123 => _123.message]), () => ( "Unknown error")),
+        stack: _optionalChain([lastError, 'optionalAccess', _124 => _124.stack]),
+        recoverable: false
+      },
+      executionTime: Date.now() - startTime,
+      tokensUsed: 0,
+      startTime: new Date(startTime),
+      endTime: /* @__PURE__ */ new Date()
+    };
+    this.notifyObservers("onStepEnd", step, stepResult, context);
+    return stepResult;
+  }
+  async executeStep(step, _context) {
+    return {
+      stepId: step.id,
+      type: step.type,
+      target: step.target,
+      parameters: step.parameters
+    };
+  }
+  async executeWithTimeout(fn, timeout) {
+    return Promise.race([
+      fn(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Timeout after ${timeout}ms`)), timeout)
+      )
+    ]);
+  }
+  async executePhase(phase, context, trace, fn) {
+    this.notifyObservers("onPhaseStart", phase, context);
+    const startTime = Date.now();
+    try {
+      const result = await fn();
+      const duration = Date.now() - startTime;
+      trace.phases.push({
+        phase,
+        startTime: new Date(startTime),
+        endTime: /* @__PURE__ */ new Date(),
+        duration
+      });
+      this.notifyObservers("onPhaseEnd", phase, duration, context);
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      trace.phases.push({
+        phase,
+        startTime: new Date(startTime),
+        endTime: /* @__PURE__ */ new Date(),
+        duration,
+        metadata: { error: error instanceof Error ? error.message : String(error) }
+      });
+      this.notifyObservers("onPhaseEnd", phase, duration, context);
+      throw error;
+    }
+  }
+  validatePlan(plan) {
+    const stepIds = new Set(plan.steps.map((s) => s.id));
+    if (stepIds.size !== plan.steps.length) {
+      throw new Error("Duplicate step IDs in plan");
+    }
+    for (const step of plan.steps) {
+      for (const dep of _nullishCoalesce(step.dependencies, () => ( []))) {
+        if (!stepIds.has(dep)) {
+          throw new Error(`Step ${step.id} depends on unknown step ${dep}`);
+        }
+      }
+    }
+  }
+  processResults(stepResults) {
+    const successfulResults = stepResults.filter((r) => r.status === "completed");
+    if (successfulResults.length === 0) {
+      return null;
+    }
+    if (successfulResults.length === 1) {
+      return successfulResults[0].output;
+    }
+    return successfulResults.map((r) => r.output);
+  }
+  determineFinalStatus(stepResults) {
+    if (stepResults.every((r) => r.status === "completed")) {
+      return "completed";
+    }
+    if (stepResults.some((r) => r.status === "failed")) {
+      return "failed";
+    }
+    return "completed";
+  }
+  calculateBackoff(attempt, policy) {
+    const { backoffStrategy, baseDelay, maxDelay } = policy;
+    let delay;
+    switch (backoffStrategy) {
+      case "fixed":
+        delay = baseDelay;
+        break;
+      case "linear":
+        delay = baseDelay * (attempt + 1);
+        break;
+      case "exponential":
+      default:
+        delay = baseDelay * Math.pow(2, attempt);
+        break;
+    }
+    const jitter = Math.random() * 0.1 * delay;
+    delay += jitter;
+    return Math.min(delay, maxDelay);
+  }
+  isRetryableError(error, policy) {
+    const errorCode = error.code;
+    if (errorCode && policy.retryableErrors.includes(errorCode)) {
+      return true;
+    }
+    if (error.message.includes("timeout") || error.message.includes("Timeout")) {
+      return true;
+    }
+    return false;
+  }
+  getCircuitBreaker(name, config) {
+    if (!this.circuitBreakers.has(name)) {
+      this.circuitBreakers.set(name, new CircuitBreaker(config));
+    }
+    return this.circuitBreakers.get(name);
+  }
+  cancelExecution(executionId) {
+    const controller = this.activeExecutions.get(executionId);
+    if (controller) {
+      controller.abort();
+      this.activeExecutions.delete(executionId);
+      return true;
+    }
+    return false;
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  resetMetrics() {
+    this.metrics = {
+      totalTime: 0,
+      totalTokens: 0,
+      llmCalls: 0,
+      skillCalls: 0,
+      toolCalls: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      retryCount: 0
+    };
+  }
+  addObserver(observer) {
+    this.config.observers.push(observer);
+  }
+  removeObserver(observer) {
+    const index = this.config.observers.indexOf(observer);
+    if (index > -1) {
+      this.config.observers.splice(index, 1);
+    }
+  }
+  notifyObservers(event, ...args) {
+    for (const observer of this.config.observers) {
+      try {
+        const handler = observer[event];
+        if (typeof handler === "function") {
+          handler.apply(observer, args);
+        }
+      } catch (e6) {
+      }
+    }
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}, _class11);
+var CircuitBreaker = (_class12 = class {
+  constructor(config) {;_class12.prototype.__init29.call(this);_class12.prototype.__init30.call(this);_class12.prototype.__init31.call(this);
+    this.config = config;
+  }
+  __init29() {this.state = "closed"}
+  __init30() {this.failureCount = 0}
+  __init31() {this.successCount = 0}
+  
+  canExecute() {
+    if (this.state === "closed") {
+      return true;
+    }
+    if (this.state === "open") {
+      if (Date.now() - (_nullishCoalesce(this.lastFailureTime, () => ( 0))) > this.config.resetTimeout) {
+        this.state = "half-open";
+        this.successCount = 0;
+        return true;
+      }
+      return false;
+    }
+    return this.successCount < this.config.halfOpenMaxCalls;
+  }
+  recordSuccess() {
+    if (this.state === "half-open") {
+      this.successCount++;
+      if (this.successCount >= this.config.halfOpenMaxCalls) {
+        this.state = "closed";
+        this.failureCount = 0;
+      }
+    } else {
+      this.failureCount = 0;
+    }
+  }
+  recordFailure() {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+    if (this.state === "half-open" || this.failureCount >= this.config.failureThreshold) {
+      this.state = "open";
+    }
+  }
+}, _class12);
+
+// src/plugins/manager.ts
+var PluginManager = (_class13 = class {
+  constructor(agent, config = {}) {;_class13.prototype.__init32.call(this);_class13.prototype.__init33.call(this);
+    this.agent = agent;
+    this.config = config;
+  }
+  __init32() {this.plugins = /* @__PURE__ */ new Map()}
+  __init33() {this.contexts = /* @__PURE__ */ new Map()}
+  async load(plugin, config = {}) {
+    if (this.config.allowedPlugins && !this.config.allowedPlugins.includes(plugin.name)) {
+      throw new Error(`Plugin '${plugin.name}' is not in the allowed list`);
+    }
+    const context = {
+      agent: this.agent,
+      registerSkill: (skill) => this.agent.registerSkill(skill),
+      registerTool: (tool) => this.agent.registerTool(tool),
+      registerMCPResource: (resource) => this.agent.registerMCPResource(resource),
+      registerMCPTool: (tool) => this.agent.registerMCPTool(tool),
+      getLLMProvider: () => this.agent.llmProvider,
+      config
+    };
+    await plugin.initialize(context);
+    this.plugins.set(plugin.name, plugin);
+    this.contexts.set(plugin.name, context);
+  }
+  async unload(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      throw new Error(`Plugin '${name}' not found`);
+    }
+    await _optionalChain([plugin, 'access', _125 => _125.destroy, 'optionalCall', _126 => _126()]);
+    this.plugins.delete(name);
+    this.contexts.delete(name);
+  }
+  get(name) {
+    return this.plugins.get(name);
+  }
+  getContext(name) {
+    return this.contexts.get(name);
+  }
+  list() {
+    return Array.from(this.plugins.values());
+  }
+  listNames() {
+    return Array.from(this.plugins.keys());
+  }
+  isLoaded(name) {
+    return this.plugins.has(name);
+  }
+  async reload(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      throw new Error(`Plugin '${name}' not found`);
+    }
+    const context = this.contexts.get(name);
+    if (!context) {
+      throw new Error(`Context for plugin '${name}' not found`);
+    }
+    await _optionalChain([plugin, 'access', _127 => _127.destroy, 'optionalCall', _128 => _128()]);
+    await plugin.initialize(context);
+  }
+  async unloadAll() {
+    for (const [name] of this.plugins) {
+      await this.unload(name);
+    }
+  }
+  getStats() {
+    return {
+      total: this.plugins.size,
+      withDestroy: this.list().filter((p) => p.destroy !== void 0).length
+    };
+  }
+}, _class13);
+var PluginLoader = (_class14 = class {constructor() { _class14.prototype.__init34.call(this); }
+  __init34() {this.factories = /* @__PURE__ */ new Map()}
+  registerFactory(type, factory) {
+    this.factories.set(type, factory);
+  }
+  async loadFromSource(type, source, config = {}) {
+    const factory = this.factories.get(type);
+    if (!factory) {
+      throw new Error(`Unknown plugin type: ${type}`);
+    }
+    const pluginConfig = await this.loadConfig(source);
+    return factory.create({ ...pluginConfig, ...config });
+  }
+  async loadConfig(source) {
+    if (source.startsWith("http")) {
+      const response = await fetch(source);
+      return response.json();
+    }
+    throw new Error(
+      "Loading config from file path is not supported. Use a URL (http/https) or pass config object directly."
+    );
+  }
+}, _class14);
+
+// src/index.ts
+var VERSION = "1.0.0";
+var isBrowser = typeof window !== "undefined";
+var isNode = typeof window === "undefined";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AdvancedDecisionEngine = AdvancedDecisionEngine; exports.Agent = Agent; exports.AnthropicProvider = _chunkMTFOABGCcjs.AnthropicProvider; exports.BrowserStorageAdapter = _chunkJF33ZOMBcjs.BrowserStorageAdapter; exports.DecisionEngine = DecisionEngine; exports.DeepSeekProvider = _chunkMTFOABGCcjs.DeepSeekProvider; exports.DoubaoProvider = _chunkMTFOABGCcjs.DoubaoProvider; exports.DynamicSkillLoader = DynamicSkillLoader; exports.EnhancedSkillExecutor = _chunkYDHQCPSNcjs.EnhancedSkillExecutor; exports.EvaluationEngine = EvaluationEngine; exports.ExactMatchEvaluator = ExactMatchEvaluator; exports.ExecutionEngine = ExecutionEngine; exports.GeminiProvider = _chunkMTFOABGCcjs.GeminiProvider; exports.LLMManager = _chunkMTFOABGCcjs.LLMManager; exports.LLMProviderRegistry = _chunkMTFOABGCcjs.LLMProviderRegistry; exports.MCPClient = _chunkIYG37UN3cjs.MCPClient; exports.MCPServer = _chunkIYG37UN3cjs.MCPServer; exports.MiniMaxProvider = _chunkMTFOABGCcjs.MiniMaxProvider; exports.MoonshotProvider = _chunkMTFOABGCcjs.MoonshotProvider; exports.NodeStorageAdapter = _chunkJF33ZOMBcjs.NodeStorageAdapter; exports.OpenAIProvider = _chunkMTFOABGCcjs.OpenAIProvider; exports.ParameterExtractor = ParameterExtractor; exports.PluginLoader = PluginLoader; exports.PluginManager = PluginManager; exports.QwenProvider = _chunkMTFOABGCcjs.QwenProvider; exports.SchemaValidator = SchemaValidator; exports.SemanticEvaluator = SemanticEvaluator; exports.SimpleEmbeddingProvider = SimpleEmbeddingProvider; exports.SkillRegistry = _chunkYDHQCPSNcjs.SkillRegistry; exports.SkillResourceManager = _chunkYDHQCPSNcjs.SkillResourceManager; exports.SkillScriptExecutor = _chunkYDHQCPSNcjs.SkillScriptExecutor; exports.SmartAgent = SmartAgent; exports.TokenOptimizer = TokenOptimizer; exports.ToolRegistry = _chunkKXXS33G3cjs.ToolRegistry; exports.VERSION = VERSION; exports.ZhipuProvider = _chunkMTFOABGCcjs.ZhipuProvider; exports.builtInSkills = _chunkYDHQCPSNcjs.builtInSkills; exports.builtInSkillsMap = _chunkYDHQCPSNcjs.builtInSkillsMap; exports.builtInTools = _chunkKXXS33G3cjs.builtInTools; exports.createSkillFromManifest = _chunkYDHQCPSNcjs.createSkillFromManifest; exports.createStorage = _chunkJF33ZOMBcjs.createStorage; exports.echoSkill = _chunkYDHQCPSNcjs.echoSkill; exports.fileReadTool = _chunkKXXS33G3cjs.fileReadTool; exports.fileWriteTool = _chunkKXXS33G3cjs.fileWriteTool; exports.getDefaultStorage = _chunkJF33ZOMBcjs.getDefaultStorage; exports.globalProviderRegistry = _chunkMTFOABGCcjs.globalProviderRegistry; exports.httpRequestTool = _chunkKXXS33G3cjs.httpRequestTool; exports.isBrowser = isBrowser; exports.isNode = isNode; exports.listSkillsSkill = _chunkYDHQCPSNcjs.listSkillsSkill; exports.loadSkillFromDirectory = _chunkYDHQCPSNcjs.loadSkillFromDirectory; exports.mathSkill = _chunkYDHQCPSNcjs.mathSkill; exports.parseSkillMd = _chunkYDHQCPSNcjs.parseSkillMd; exports.resetDefaultStorage = _chunkJF33ZOMBcjs.resetDefaultStorage; exports.validateManifest = _chunkYDHQCPSNcjs.validateManifest;
+//# sourceMappingURL=index.cjs.map