sdkwork-browser-agent 1.0.0

package/dist/index.js

@@ -0,0 +1,1311 @@
+import {
+  AnthropicProvider,
+  DeepSeekProvider,
+  DoubaoProvider,
+  GeminiProvider,
+  LLMManager,
+  LLMProviderRegistry,
+  MiniMaxProvider,
+  MoonshotProvider,
+  OpenAIProvider,
+  QwenProvider,
+  ZhipuProvider,
+  globalProviderRegistry
+} from "./chunk-5XTVS5MB.js";
+import {
+  SkillRegistry,
+  builtInSkills,
+  echoSkill,
+  listSkillsSkill,
+  mathSkill
+} from "./chunk-6AYIRBGI.js";
+import {
+  ToolRegistry,
+  builtInTools,
+  fileReadTool,
+  fileWriteTool,
+  httpRequestTool
+} from "./chunk-XFMT5ZA4.js";
+import {
+  MCPClient,
+  MCPServer
+} from "./chunk-56J3IBXZ.js";
+
+// src/core/agent.ts
+var Agent = class {
+  constructor(config) {
+    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 || [];
+  }
+  _skills = /* @__PURE__ */ new Map();
+  _tools = /* @__PURE__ */ new Map();
+  _plugins = /* @__PURE__ */ new Map();
+  _mcpResources = /* @__PURE__ */ new Map();
+  _mcpTools = /* @__PURE__ */ new Map();
+  _middlewares = [];
+  _initialized = false;
+  name;
+  description;
+  version;
+  llmProvider;
+  systemPrompt;
+  maxIterations;
+  hooks;
+  async initialize() {
+    if (this._initialized) return;
+    this.config.skills?.forEach((skill) => this.registerSkill(skill));
+    this.config.tools?.forEach((tool) => this.registerTool(tool));
+    this.config.mcpResources?.forEach((resource) => this.registerMCPResource(resource));
+    this.config.mcpTools?.forEach((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 this.hooks?.beforeSkillExecution?.(name, params);
+    const execute = async () => {
+      try {
+        const result = await skill.handler(params, context);
+        await this.hooks?.afterSkillExecution?.(name, result);
+        return result;
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        await this.hooks?.onError?.(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 this.hooks?.onToolCall?.(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 plugin.destroy?.();
+    }
+    this._skills.clear();
+    this._tools.clear();
+    this._plugins.clear();
+    this._mcpResources.clear();
+    this._mcpTools.clear();
+    this._middlewares = [];
+    this._initialized = false;
+  }
+};
+
+// src/core/decision-engine.ts
+var SimpleEmbeddingProvider = class {
+  vocabulary = /* @__PURE__ */ new Map();
+  vocabSize = 0;
+  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);
+  }
+};
+var DecisionEngine = class {
+  skillEmbeddings = /* @__PURE__ */ new Map();
+  embeddingProvider;
+  decisionCache = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}, embeddingProvider) {
+    this.config = {
+      threshold: config.threshold ?? 0.6,
+      maxSkills: config.maxSkills ?? 3,
+      enableEmbeddings: config.enableEmbeddings ?? true,
+      enableCaching: config.enableCaching ?? true,
+      similarityThreshold: config.similarityThreshold ?? 0.5
+    };
+    this.embeddingProvider = 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(topSkills[0]?.confidence ?? 0, topTools[0]?.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,
+      ...skill.metadata?.tags ?? [],
+      skill.metadata?.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 };
+  }
+};
+
+// src/core/skill-loader.ts
+var DynamicSkillLoader = class {
+  loadedSkills = /* @__PURE__ */ new Map();
+  skillCache = /* @__PURE__ */ new Map();
+  skillSources = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}) {
+    this.config = {
+      skillDirectory: config.skillDirectory ?? "./skills",
+      enableLazyLoading: config.enableLazyLoading ?? true,
+      enableCaching: config.enableCaching ?? true,
+      cacheSize: config.cacheSize ?? 100,
+      hotReload: 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 + (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 import("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 import(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);
+      }
+    }
+  }
+};
+
+// src/core/token-optimizer.ts
+var TokenOptimizer = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      maxContextTokens: config.maxContextTokens ?? 4e3,
+      maxSkillDescriptionLength: config.maxSkillDescriptionLength ?? 200,
+      enableCompression: config.enableCompression ?? true,
+      preserveSystemPrompt: 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 = 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 = 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 = class extends Agent {
+  decisionEngine;
+  skillLoader;
+  tokenOptimizer;
+  executionHistory = [];
+  constructor(config) {
+    super(config);
+    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 (decision.skills?.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(skillResult.data ?? "Success") : String(skillResult.error ?? "Error");
+        } else {
+          result = await this.coordinateSkills(input, decision.skills || []);
+        }
+        break;
+      case "tool":
+        if (decision.tools?.length === 1) {
+          const toolName = decision.tools[0];
+          const toolResult = await this.executeTool(toolName, input);
+          result = toolResult.isError ? String(toolResult.content[0]?.text ?? "Error") : String(toolResult.content[0]?.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 {
+        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}: ${result.content[0]?.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}: ${result.content[0]?.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 = skill.parameters.required?.includes(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();
+  }
+};
+
+// src/plugins/manager.ts
+var PluginManager = class {
+  constructor(agent, config = {}) {
+    this.agent = agent;
+    this.config = config;
+  }
+  plugins = /* @__PURE__ */ new Map();
+  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 plugin.destroy?.();
+    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 plugin.destroy?.();
+    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
+    };
+  }
+};
+var PluginLoader = class {
+  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."
+    );
+  }
+};
+export {
+  Agent,
+  AnthropicProvider,
+  DecisionEngine,
+  DeepSeekProvider,
+  DoubaoProvider,
+  DynamicSkillLoader,
+  GeminiProvider,
+  LLMManager,
+  LLMProviderRegistry,
+  MCPClient,
+  MCPServer,
+  MiniMaxProvider,
+  MoonshotProvider,
+  OpenAIProvider,
+  PluginLoader,
+  PluginManager,
+  QwenProvider,
+  SimpleEmbeddingProvider,
+  SkillRegistry,
+  SmartAgent,
+  TokenOptimizer,
+  ToolRegistry,
+  ZhipuProvider,
+  builtInSkills,
+  builtInTools,
+  echoSkill,
+  fileReadTool,
+  fileWriteTool,
+  globalProviderRegistry,
+  httpRequestTool,
+  listSkillsSkill,
+  mathSkill
+};
+//# sourceMappingURL=index.js.map