sdkwork-browser-agent 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1311 @@
+"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 _chunkXPGICLEJcjs = require('./chunk-XPGICLEJ.cjs');
+
+
+
+
+
+
+var _chunkHOZQ445Wcjs = require('./chunk-HOZQ445W.cjs');
+
+
+
+
+
+
+var _chunkC2EYJHXWcjs = require('./chunk-C2EYJHXW.cjs');
+
+
+
+var _chunkKZNZ6CGDcjs = require('./chunk-KZNZ6CGD.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', _ => _.config, 'access', _2 => _2.skills, 'optionalAccess', _3 => _3.forEach, 'call', _4 => _4((skill) => this.registerSkill(skill))]);
+    _optionalChain([this, 'access', _5 => _5.config, 'access', _6 => _6.tools, 'optionalAccess', _7 => _7.forEach, 'call', _8 => _8((tool) => this.registerTool(tool))]);
+    _optionalChain([this, 'access', _9 => _9.config, 'access', _10 => _10.mcpResources, 'optionalAccess', _11 => _11.forEach, 'call', _12 => _12((resource) => this.registerMCPResource(resource))]);
+    _optionalChain([this, 'access', _13 => _13.config, 'access', _14 => _14.mcpTools, 'optionalAccess', _15 => _15.forEach, 'call', _16 => _16((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', _17 => _17.hooks, 'optionalAccess', _18 => _18.beforeSkillExecution, 'optionalCall', _19 => _19(name, params)]);
+    const execute = async () => {
+      try {
+        const result = await skill.handler(params, context);
+        await _optionalChain([this, 'access', _20 => _20.hooks, 'optionalAccess', _21 => _21.afterSkillExecution, 'optionalCall', _22 => _22(name, result)]);
+        return result;
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        await _optionalChain([this, 'access', _23 => _23.hooks, 'optionalAccess', _24 => _24.onError, 'optionalCall', _25 => _25(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', _26 => _26.hooks, 'optionalAccess', _27 => _27.onToolCall, 'optionalCall', _28 => _28(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', _29 => _29.destroy, 'optionalCall', _30 => _30()]);
+    }
+    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', _31 => _31[0], 'optionalAccess', _32 => _32.confidence]), () => ( 0)), _nullishCoalesce(_optionalChain([topTools, 'access', _33 => _33[0], 'optionalAccess', _34 => _34.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', _35 => _35.metadata, 'optionalAccess', _36 => _36.tags]), () => ( [])),
+      _nullishCoalesce(_optionalChain([skill, 'access', _37 => _37.metadata, 'optionalAccess', _38 => _38.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/smart-agent.ts
+var SmartAgent = (_class5 = class extends Agent {
+  
+  
+  
+  __init16() {this.executionHistory = []}
+  constructor(config) {
+    super(config);_class5.prototype.__init16.call(this);;
+    this.decisionEngine = new DecisionEngine(config.decisionEngine);
+    this.skillLoader = new DynamicSkillLoader(config.skillLoader);
+    this.tokenOptimizer = new TokenOptimizer(config.tokenOptimizer);
+    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
+   */
+  async process(input, context) {
+    const startTime = Date.now();
+    let 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;
+    switch (decision.type) {
+      case "skill":
+        if (_optionalChain([decision, 'access', _39 => _39.skills, 'optionalAccess', _40 => _40.length]) === 1) {
+          const skillName = decision.skills[0];
+          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', _41 => _41.tools, 'optionalAccess', _42 => _42.length]) === 1) {
+          const toolName = decision.tools[0];
+          const toolResult = await this.executeTool(toolName, input);
+          result = toolResult.isError ? String(_nullishCoalesce(_optionalChain([toolResult, 'access', _43 => _43.content, 'access', _44 => _44[0], 'optionalAccess', _45 => _45.text]), () => ( "Error"))) : String(_nullishCoalesce(_optionalChain([toolResult, 'access', _46 => _46.content, 'access', _47 => _47[0], 'optionalAccess', _48 => _48.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;
+    }
+    this.executionHistory.push({
+      input,
+      decision,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    const executionTime = Date.now() - startTime;
+    return {
+      decision,
+      result,
+      tokensUsed,
+      executionTime,
+      skillsLoaded: loadedSkills.length > 0 ? loadedSkills : void 0
+    };
+  }
+  /**
+   * Stream process user input
+   */
+  async *streamProcess(input, context) {
+    const decision = await this.makeDecision(input, context);
+    yield { type: "decision", data: decision };
+    switch (decision.type) {
+      case "skill":
+        for (const skillName of decision.skills || []) {
+          yield { type: "skill", data: { name: skillName, status: "executing" } };
+          const params = await this.extractParameters(input, skillName);
+          const result = await this.executeSkill(skillName, params);
+          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 result = await this.executeTool(toolName, input);
+          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 } };
+          }
+        }
+        break;
+    }
+    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 (e) {
+        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', _49 => _49.content, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.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', _52 => _52.content, 'access', _53 => _53[0], 'optionalAccess', _54 => _54.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', _55 => _55.parameters, 'access', _56 => _56.required, 'optionalAccess', _57 => _57.includes, 'call', _58 => _58(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
+    };
+  }
+  /**
+   * Clear execution history
+   */
+  clearHistory() {
+    this.executionHistory = [];
+    this.decisionEngine.clearCache();
+  }
+}, _class5);
+
+// src/plugins/manager.ts
+var PluginManager = (_class6 = class {
+  constructor(agent, config = {}) {;_class6.prototype.__init17.call(this);_class6.prototype.__init18.call(this);
+    this.agent = agent;
+    this.config = config;
+  }
+  __init17() {this.plugins = /* @__PURE__ */ new Map()}
+  __init18() {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', _59 => _59.destroy, 'optionalCall', _60 => _60()]);
+    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', _61 => _61.destroy, 'optionalCall', _62 => _62()]);
+    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
+    };
+  }
+}, _class6);
+var PluginLoader = (_class7 = class {constructor() { _class7.prototype.__init19.call(this); }
+  __init19() {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."
+    );
+  }
+}, _class7);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Agent = Agent; exports.AnthropicProvider = _chunkXPGICLEJcjs.AnthropicProvider; exports.DecisionEngine = DecisionEngine; exports.DeepSeekProvider = _chunkXPGICLEJcjs.DeepSeekProvider; exports.DoubaoProvider = _chunkXPGICLEJcjs.DoubaoProvider; exports.DynamicSkillLoader = DynamicSkillLoader; exports.GeminiProvider = _chunkXPGICLEJcjs.GeminiProvider; exports.LLMManager = _chunkXPGICLEJcjs.LLMManager; exports.LLMProviderRegistry = _chunkXPGICLEJcjs.LLMProviderRegistry; exports.MCPClient = _chunkKZNZ6CGDcjs.MCPClient; exports.MCPServer = _chunkKZNZ6CGDcjs.MCPServer; exports.MiniMaxProvider = _chunkXPGICLEJcjs.MiniMaxProvider; exports.MoonshotProvider = _chunkXPGICLEJcjs.MoonshotProvider; exports.OpenAIProvider = _chunkXPGICLEJcjs.OpenAIProvider; exports.PluginLoader = PluginLoader; exports.PluginManager = PluginManager; exports.QwenProvider = _chunkXPGICLEJcjs.QwenProvider; exports.SimpleEmbeddingProvider = SimpleEmbeddingProvider; exports.SkillRegistry = _chunkHOZQ445Wcjs.SkillRegistry; exports.SmartAgent = SmartAgent; exports.TokenOptimizer = TokenOptimizer; exports.ToolRegistry = _chunkC2EYJHXWcjs.ToolRegistry; exports.ZhipuProvider = _chunkXPGICLEJcjs.ZhipuProvider; exports.builtInSkills = _chunkHOZQ445Wcjs.builtInSkills; exports.builtInTools = _chunkC2EYJHXWcjs.builtInTools; exports.echoSkill = _chunkHOZQ445Wcjs.echoSkill; exports.fileReadTool = _chunkC2EYJHXWcjs.fileReadTool; exports.fileWriteTool = _chunkC2EYJHXWcjs.fileWriteTool; exports.globalProviderRegistry = _chunkXPGICLEJcjs.globalProviderRegistry; exports.httpRequestTool = _chunkC2EYJHXWcjs.httpRequestTool; exports.listSkillsSkill = _chunkHOZQ445Wcjs.listSkillsSkill; exports.mathSkill = _chunkHOZQ445Wcjs.mathSkill;
+//# sourceMappingURL=index.cjs.map