sdkwork-browser-agent 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,395 @@
+import { S as Skill, T as Tool, a as SkillResult, A as Agent, b as AgentConfig, P as Plugin, c as PluginContext } from './agent-Bpxmkz8W.js';
+export { d as AgentHooks, e as AgentMiddleware, E as ExecutionContext, M as MCPResource, f as MCPResourceContent, g as MCPResourceMetadata, h as MCPTool, i as MCPToolResult, j as ParameterProperty, k as ParameterSchema, l as PluginMetadata, m as SkillHandler, n as SkillMetadata, o as ToolExecutor, p as ToolMetadata, q as ToolOutput } from './agent-Bpxmkz8W.js';
+import { a as LLMMessage } from './provider-Dna36xA-.js';
+export { e as LLMManager, L as LLMProvider, f as LLMProviderConfig, g as LLMProviderFactory, h as LLMProviderRegistry, b as LLMRequest, c as LLMResponse, d as LLMStreamChunk, i as ToolCall, T as ToolDefinition, j as globalProviderRegistry } from './provider-Dna36xA-.js';
+export { AnthropicConfig, AnthropicProvider, DeepSeekConfig, DeepSeekProvider, DoubaoConfig, DoubaoProvider, GeminiConfig, GeminiProvider, MiniMaxConfig, MiniMaxProvider, MoonshotConfig, MoonshotProvider, OpenAIConfig, OpenAIProvider, QwenConfig, QwenProvider, ZhipuConfig, ZhipuProvider } from './llm/index.js';
+export { SkillRegistry, SkillRegistryConfig, builtInSkills, echoSkill, listSkillsSkill, mathSkill } from './skills/index.js';
+export { ToolRegistry, ToolRegistryConfig, builtInTools, fileReadTool, fileWriteTool, httpRequestTool } from './tools/index.js';
+export { MCPClient, MCPClientConfig, MCPServer, MCPServerConfig } from './mcp/index.js';
+
+/**
+ * Decision Engine for automatic skill selection
+ * Optimized for minimal token consumption
+ */
+
+interface Decision {
+    type: 'skill' | 'tool' | 'llm' | 'multi';
+    skills?: string[];
+    tools?: string[];
+    reasoning?: string;
+    confidence: number;
+    fallback?: string;
+}
+interface DecisionContext {
+    input: string;
+    history?: string[];
+    availableSkills: string[];
+    availableTools: string[];
+    metadata?: Record<string, unknown>;
+}
+interface DecisionEngineConfig {
+    threshold?: number;
+    maxSkills?: number;
+    enableEmbeddings?: boolean;
+    enableCaching?: boolean;
+    similarityThreshold?: number;
+}
+interface EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+    similarity(a: number[], b: number[]): number;
+}
+declare class SimpleEmbeddingProvider implements EmbeddingProvider {
+    private vocabulary;
+    private vocabSize;
+    private readonly maxVocabSize;
+    embed(text: string): Promise<number[]>;
+    similarity(a: number[], b: number[]): number;
+    private tokenize;
+}
+declare class DecisionEngine {
+    private skillEmbeddings;
+    private embeddingProvider;
+    private decisionCache;
+    private config;
+    constructor(config?: DecisionEngineConfig, embeddingProvider?: EmbeddingProvider);
+    /**
+     * Index skills for fast retrieval
+     */
+    indexSkill(skill: Skill): Promise<void>;
+    /**
+     * Make decision based on input
+     */
+    decide(context: DecisionContext): Promise<Decision>;
+    /**
+     * Find relevant skills using similarity matching
+     */
+    private findRelevantSkills;
+    /**
+     * Fallback matching using keyword extraction
+     */
+    private fallbackSkillMatching;
+    /**
+     * Find relevant tools
+     */
+    private findRelevantTools;
+    /**
+     * Extract keywords from skill
+     */
+    private extractKeywords;
+    /**
+     * Extract keywords from text
+     */
+    private extractKeywordsFromText;
+    /**
+     * Generate cache key
+     */
+    private generateCacheKey;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache stats
+     */
+    getCacheStats(): {
+        size: number;
+        hitRate?: number;
+    };
+}
+
+/**
+ * Dynamic Skill Loader
+ * Lazy loading and caching of skills
+ */
+
+interface SkillLoaderConfig {
+    skillDirectory?: string;
+    enableLazyLoading?: boolean;
+    enableCaching?: boolean;
+    cacheSize?: number;
+    hotReload?: boolean;
+}
+interface SkillSource {
+    name: string;
+    type: 'builtin' | 'file' | 'url' | 'module';
+    source: string;
+    metadata?: Record<string, unknown>;
+}
+interface LoadedSkill extends Skill {
+    loadedAt: Date;
+    source: SkillSource;
+    size?: number;
+}
+declare class DynamicSkillLoader {
+    private loadedSkills;
+    private skillCache;
+    private skillSources;
+    private config;
+    constructor(config?: SkillLoaderConfig);
+    /**
+     * Register a skill source for lazy loading
+     */
+    registerSource(source: SkillSource): void;
+    /**
+     * Load a skill dynamically
+     */
+    load(name: string): Promise<Skill | null>;
+    /**
+     * Load multiple skills
+     */
+    loadMultiple(names: string[]): Promise<Map<string, Skill>>;
+    /**
+     * Unload a skill
+     */
+    unload(name: string): boolean;
+    /**
+     * Check if skill is loaded
+     */
+    isLoaded(name: string): boolean;
+    /**
+     * Get loaded skill info
+     */
+    getLoadedSkill(name: string): LoadedSkill | undefined;
+    /**
+     * List all loaded skills
+     */
+    listLoaded(): LoadedSkill[];
+    /**
+     * List available skill sources
+     */
+    listSources(): SkillSource[];
+    /**
+     * Preload skills (eager loading)
+     */
+    preload(names: string[]): Promise<void>;
+    /**
+     * Get memory usage stats
+     */
+    getStats(): {
+        loaded: number;
+        cached: number;
+        sources: number;
+        totalSize: number;
+    };
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Clear all loaded skills
+     */
+    clear(): void;
+    private loadBuiltin;
+    private loadFromFile;
+    private loadFromUrl;
+    private loadFromModule;
+    private validateSkill;
+    private enforceCacheLimit;
+}
+
+/**
+ * Token Optimizer
+ * Minimize token consumption for LLM calls
+ */
+
+interface TokenOptimizerConfig {
+    maxContextTokens?: number;
+    maxSkillDescriptionLength?: number;
+    enableCompression?: boolean;
+    preserveSystemPrompt?: boolean;
+}
+interface TokenEstimate {
+    prompt: number;
+    completion: number;
+    total: number;
+}
+declare class TokenOptimizer {
+    private config;
+    constructor(config?: TokenOptimizerConfig);
+    /**
+     * Optimize skills for minimal token usage
+     */
+    optimizeSkills(skills: Skill[], forQuery?: string): Skill[];
+    /**
+     * Compress a single skill
+     */
+    private compressSkill;
+    /**
+     * Optimize tools for minimal token usage
+     */
+    optimizeTools(tools: Tool[]): Tool[];
+    /**
+     * Optimize messages for context window
+     */
+    optimizeMessages(messages: LLMMessage[], maxTokens?: number): LLMMessage[];
+    /**
+     * Build optimized prompt with skills
+     */
+    buildOptimizedPrompt(userInput: string, availableSkills: Skill[], context?: string): string;
+    /**
+     * Estimate tokens for text
+     */
+    estimateTokens(text: string): number;
+    /**
+     * Estimate tokens for messages
+     */
+    estimateMessagesTokens(messages: LLMMessage[]): number;
+    /**
+     * Estimate tokens for skills
+     */
+    estimateSkillsTokens(skills: Skill[]): number;
+    /**
+     * Get optimization stats
+     */
+    getOptimizationStats(original: Skill[], optimized: Skill[]): {
+        originalTokens: number;
+        optimizedTokens: number;
+        savings: number;
+        savingsPercent: number;
+    };
+    private truncateDescription;
+    private compressParameters;
+    private isMetadataRelevant;
+    private formatSkillForPrompt;
+}
+
+/**
+ * Smart Agent with automatic skill selection
+ * Token-optimized decision making
+ */
+
+interface SmartAgentConfig extends AgentConfig {
+    decisionEngine?: DecisionEngineConfig;
+    skillLoader?: SkillLoaderConfig;
+    tokenOptimizer?: TokenOptimizerConfig;
+    autoDecide?: boolean;
+    maxAutoIterations?: number;
+    enableStreaming?: boolean;
+}
+interface AutoExecutionResult {
+    decision: Decision;
+    result: SkillResult | string;
+    tokensUsed: number;
+    executionTime: number;
+    skillsLoaded?: string[];
+}
+declare class SmartAgent extends Agent {
+    private decisionEngine;
+    private skillLoader;
+    private tokenOptimizer;
+    private executionHistory;
+    constructor(config: SmartAgentConfig);
+    /**
+     * Initialize the smart agent
+     */
+    initialize(): Promise<void>;
+    /**
+     * Auto-process user input with smart decision making
+     */
+    process(input: string, context?: string): Promise<AutoExecutionResult>;
+    /**
+     * Stream process user input
+     */
+    streamProcess(input: string, context?: string): AsyncIterableIterator<{
+        type: 'decision' | 'skill' | 'tool' | 'llm' | 'complete';
+        data?: unknown;
+    }>;
+    /**
+     * Make decision based on input
+     */
+    private makeDecision;
+    /**
+     * Extract parameters from input for a skill
+     */
+    private extractParameters;
+    /**
+     * Coordinate multiple skills
+     */
+    private coordinateSkills;
+    /**
+     * Coordinate multiple tools
+     */
+    private coordinateTools;
+    /**
+     * Execute mixed skills and tools
+     */
+    private executeMixed;
+    /**
+     * Direct LLM response
+     */
+    private directLLMResponse;
+    /**
+     * Build parameter extraction prompt
+     */
+    private buildParameterExtractionPrompt;
+    /**
+     * Simple parameter extraction without LLM
+     */
+    private simpleParameterExtraction;
+    /**
+     * Register a skill source for dynamic loading
+     */
+    registerSkillSource(name: string, source: string, type: 'file' | 'url' | 'module'): void;
+    /**
+     * Get execution history
+     */
+    getExecutionHistory(): Array<{
+        input: string;
+        decision: Decision;
+        timestamp: Date;
+    }>;
+    /**
+     * Get decision engine stats
+     */
+    getDecisionStats(): {
+        cacheSize: number;
+        loadedSkills: number;
+        historySize: number;
+    };
+    /**
+     * Clear execution history
+     */
+    clearHistory(): void;
+}
+
+/**
+ * Plugin System
+ * Extensible architecture for adding capabilities
+ */
+
+interface PluginManagerConfig {
+    autoLoad?: boolean;
+    pluginDirectory?: string;
+    allowedPlugins?: string[];
+}
+declare class PluginManager {
+    private agent;
+    private config;
+    private plugins;
+    private contexts;
+    constructor(agent: Agent, config?: PluginManagerConfig);
+    load(plugin: Plugin, config?: Record<string, unknown>): Promise<void>;
+    unload(name: string): Promise<void>;
+    get(name: string): Plugin | undefined;
+    getContext(name: string): PluginContext | undefined;
+    list(): Plugin[];
+    listNames(): string[];
+    isLoaded(name: string): boolean;
+    reload(name: string): Promise<void>;
+    unloadAll(): Promise<void>;
+    getStats(): {
+        total: number;
+        withDestroy: number;
+    };
+}
+interface PluginFactory {
+    create(config: Record<string, unknown>): Plugin | Promise<Plugin>;
+}
+declare class PluginLoader {
+    private factories;
+    registerFactory(type: string, factory: PluginFactory): void;
+    loadFromSource(type: string, source: string, config?: Record<string, unknown>): Promise<Plugin>;
+    private loadConfig;
+}
+
+export { Agent, AgentConfig, type AutoExecutionResult, type Decision, type DecisionContext, DecisionEngine, type DecisionEngineConfig, DynamicSkillLoader, type EmbeddingProvider, LLMMessage, type LoadedSkill, Plugin, PluginContext, type PluginFactory, PluginLoader, PluginManager, type PluginManagerConfig, SimpleEmbeddingProvider, Skill, type SkillLoaderConfig, SkillResult, type SkillSource, SmartAgent, type SmartAgentConfig, type TokenEstimate, TokenOptimizer, type TokenOptimizerConfig, Tool };