sdkwork-browser-agent 1.0.0

package/dist/node/index.d.ts

@@ -0,0 +1,842 @@
+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 { AssetFile, DisclosureLevel, EnhancedSkillExecutor, EnhancedSkillExecutorConfig, ParsedSkill, ReferenceFile, RegistryConfig, LoadedSkill as ResourceLoadedSkill, ScriptExecutionResult, ScriptExecutorConfig, ScriptFile, SkillManagerConfig, SkillManifest, SkillRegistry, SkillResourceManager, SkillScriptExecutor, builtInSkills, builtInSkillsMap, createSkillFromManifest, echoSkill, listSkillsSkill, loadSkillFromDirectory, mathSkill, parseSkillMd, validateManifest } from './skills/index.js';
+export { ToolRegistry, ToolRegistryConfig, builtInTools, fileReadTool, fileWriteTool, httpRequestTool } from './tools/index.js';
+export { MCPClient, MCPClientConfig, MCPServer, MCPServerConfig } from './mcp/index.js';
+export { BrowserStorageAdapter, NodeStorageAdapter, createStorage, getDefaultStorage, resetDefaultStorage } from './storage/index.js';
+export { F as FileMetadata, S as StorageAdapter, b as StorageAdapterFactory, a as StorageConfig } from './types-CG5I-byI.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;
+}
+
+/**
+ * Advanced Decision Engine
+ *
+ * Features:
+ * - Multi-stage decision making with confidence scoring
+ * - Intent classification with hierarchical matching
+ * - Context-aware skill selection
+ * - Adaptive learning from execution history
+ */
+
+interface AdvancedDecision extends Decision {
+    intent: string;
+    intentConfidence: number;
+    subDecisions?: AdvancedDecision[];
+    estimatedTokens: number;
+    estimatedTime: number;
+    prerequisites?: string[];
+    postProcessing?: string[];
+}
+interface IntentPattern {
+    name: string;
+    patterns: RegExp[];
+    keywords: string[];
+    weight: number;
+    relatedSkills: string[];
+}
+interface ExecutionContext$1 {
+    previousDecisions: AdvancedDecision[];
+    userPreferences: Record<string, unknown>;
+    sessionContext: Record<string, unknown>;
+    constraints: {
+        maxTokens?: number;
+        maxTime?: number;
+        allowedSkills?: string[];
+        blockedSkills?: string[];
+    };
+}
+declare class AdvancedDecisionEngine {
+    private skillEmbeddings;
+    private intentPatterns;
+    private embeddingProvider;
+    private decisionCache;
+    private executionHistory;
+    private config;
+    constructor(config?: DecisionEngineConfig & {
+        enableIntentClassification?: boolean;
+        enableContextualMemory?: boolean;
+        learningRate?: number;
+    }, embeddingProvider?: EmbeddingProvider);
+    /**
+     * Initialize common intent patterns
+     */
+    private initializeIntentPatterns;
+    /**
+     * Make advanced decision with full context analysis
+     */
+    decide(context: DecisionContext, executionContext?: ExecutionContext$1): Promise<AdvancedDecision>;
+    /**
+     * Classify user intent from input
+     */
+    private classifyIntent;
+    /**
+     * Find relevant skills with intent boosting
+     */
+    private findRelevantSkills;
+    /**
+     * Find relevant tools with intent consideration
+     */
+    private findRelevantTools;
+    /**
+     * Build comprehensive decision
+     */
+    private buildDecision;
+    /**
+     * Build sub-decisions for complex scenarios
+     */
+    private buildSubDecisions;
+    /**
+     * Enrich decision with execution context
+     */
+    private enrichDecisionWithContext;
+    /**
+     * Estimate token usage
+     */
+    private estimateTokenUsage;
+    /**
+     * Estimate execution time
+     */
+    private estimateExecutionTime;
+    /**
+     * Learn from execution result
+     */
+    learn(input: string, decision: AdvancedDecision, success: boolean, executionTime: number): void;
+    /**
+     * Index skill for retrieval
+     */
+    indexSkill(skill: Skill): Promise<void>;
+    /**
+     * Extract keywords from skill
+     */
+    private extractKeywords;
+    /**
+     * Extract keywords from text
+     */
+    private extractKeywordsFromText;
+    /**
+     * Generate cache key
+     */
+    private generateCacheKey;
+    /**
+     * Limit cache size
+     */
+    private limitCacheSize;
+    /**
+     * Get performance statistics
+     */
+    getStats(): {
+        cacheSize: number;
+        historySize: number;
+        intentPatterns: Array<{
+            name: string;
+            weight: number;
+        }>;
+        averageSuccessRate: number;
+    };
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+
+/**
+ * Advanced Parameter Extractor
+ *
+ * Features:
+ * - Multi-strategy parameter extraction (LLM, pattern, context)
+ * - Type coercion and validation
+ * - Required/optional parameter handling
+ * - Context-aware extraction
+ */
+
+interface ParameterSchema {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    description: string;
+    required?: boolean;
+    default?: unknown;
+    enum?: unknown[];
+    pattern?: string;
+    min?: number;
+    max?: number;
+    items?: ParameterSchema;
+    properties?: Record<string, ParameterSchema>;
+}
+interface ExtractionResult {
+    params: Record<string, unknown>;
+    confidence: number;
+    missing: string[];
+    invalid: Array<{
+        param: string;
+        reason: string;
+    }>;
+    suggestions: Array<{
+        param: string;
+        suggestion: string;
+    }>;
+}
+interface ExtractionContext {
+    previousParams?: Record<string, unknown>;
+    userPreferences?: Record<string, unknown>;
+    conversationHistory?: string[];
+    extractedEntities?: Record<string, unknown>;
+}
+interface ExtractorConfig {
+    useLLM?: boolean;
+    usePatternMatching?: boolean;
+    useContextInference?: boolean;
+    confidenceThreshold?: number;
+    maxRetries?: number;
+}
+declare class ParameterExtractor {
+    private config;
+    constructor(config?: ExtractorConfig);
+    /**
+     * Extract parameters from input using multiple strategies
+     */
+    extract(input: string, skill: Skill, context?: ExtractionContext, llmProvider?: {
+        complete(prompt: string): Promise<{
+            content: string;
+        }>;
+    }): Promise<ExtractionResult>;
+    /**
+     * Extract parameters using pattern matching
+     */
+    private extractWithPatterns;
+    /**
+     * Convert ParameterProperty to ParameterSchema
+     */
+    private convertPropertyToSchema;
+    /**
+     * Extract a single value using patterns
+     */
+    private extractValueWithPatterns;
+    /**
+     * Extract array values
+     */
+    private extractArrayValue;
+    /**
+     * Coerce value to correct type
+     */
+    private coerceValue;
+    /**
+     * Validate extracted value
+     */
+    private validateValue;
+    /**
+     * Extract parameters from context
+     */
+    private extractFromContext;
+    /**
+     * Extract parameters using LLM
+     */
+    private extractWithLLM;
+    /**
+     * Build LLM extraction prompt
+     */
+    private buildExtractionPrompt;
+    /**
+     * Merge extraction results from multiple strategies
+     */
+    private mergeResults;
+    /**
+     * Generate helpful suggestion for invalid parameter
+     */
+    private generateSuggestion;
+    /**
+     * Validate all parameters against schema
+     */
+    validate(params: Record<string, unknown>, skill: Skill): ExtractionResult;
+}
+
+/**
+ * Perfect Agent Execution Architecture
+ *
+ * Design Principles:
+ * 1. **Deterministic Execution**: Every decision is traceable and reproducible
+ * 2. **Graceful Degradation**: Fallback chains ensure robustness
+ * 3. **Token Efficiency**: Minimal LLM calls with maximum context utilization
+ * 4. **Observability**: Full execution tracing and metrics
+ * 5. **Extensibility**: Plugin-based architecture for custom behaviors
+ * 6. **Type Safety**: Full TypeScript coverage with runtime validation
+ *
+ * Architecture Layers:
+ * - Execution Layer: Orchestrates skill/tool/LLM execution
+ * - Decision Layer: Intelligent routing and planning
+ * - Optimization Layer: Token and performance optimization
+ * - Observability Layer: Metrics, tracing, and logging
+ */
+type ExecutionStatus = 'pending' | 'planning' | 'executing' | 'waiting_for_input' | 'retrying' | 'completed' | 'failed' | 'cancelled';
+type ExecutionPhase = 'initialization' | 'decision' | 'parameter_extraction' | 'execution' | 'result_processing' | 'completion';
+interface ExecutionContext {
+    executionId: string;
+    parentExecutionId?: string;
+    sessionId: string;
+    userId?: string;
+    timestamp: Date;
+    metadata: Record<string, unknown>;
+}
+interface ExecutionPlan {
+    id: string;
+    steps: ExecutionStep[];
+    strategy: ExecutionStrategy;
+    estimatedTokens: number;
+    estimatedTime: number;
+    fallbackPlan?: ExecutionPlan;
+}
+interface ExecutionStep {
+    id: string;
+    type: 'skill' | 'tool' | 'llm' | 'condition' | 'parallel' | 'sequence';
+    target: string;
+    parameters?: Record<string, unknown>;
+    dependencies?: string[];
+    timeout?: number;
+    retries?: number;
+    onError?: 'fail' | 'skip' | 'fallback';
+    condition?: StepCondition;
+}
+interface StepCondition {
+    operator: 'and' | 'or' | 'not';
+    conditions?: StepCondition[];
+    stepId?: string;
+    expectedResult?: unknown;
+}
+type ExecutionStrategy = 'sequential' | 'parallel' | 'adaptive' | 'retry_with_backoff';
+interface ExecutionResult {
+    executionId: string;
+    status: ExecutionStatus;
+    plan: ExecutionPlan;
+    stepResults: StepResult[];
+    finalOutput: unknown;
+    metrics: ExecutionMetrics;
+    errors: ExecutionError[];
+    trace: ExecutionTrace;
+}
+interface StepResult {
+    stepId: string;
+    status: ExecutionStatus;
+    output?: unknown;
+    error?: ExecutionError;
+    executionTime: number;
+    tokensUsed: number;
+    startTime: Date;
+    endTime: Date;
+}
+interface ExecutionError {
+    stepId: string;
+    code: string;
+    message: string;
+    stack?: string;
+    recoverable: boolean;
+    suggestedAction?: string;
+}
+interface ExecutionMetrics {
+    totalTime: number;
+    totalTokens: number;
+    llmCalls: number;
+    skillCalls: number;
+    toolCalls: number;
+    cacheHits: number;
+    cacheMisses: number;
+    retryCount: number;
+}
+interface ExecutionTrace {
+    phases: PhaseTrace[];
+    decisions: DecisionTrace[];
+    llmCalls: LLMCallTrace[];
+}
+interface PhaseTrace {
+    phase: ExecutionPhase;
+    startTime: Date;
+    endTime: Date;
+    duration: number;
+    metadata?: Record<string, unknown>;
+}
+interface DecisionTrace {
+    timestamp: Date;
+    input: string;
+    decision: string;
+    confidence: number;
+    alternatives: string[];
+    reasoning: string;
+}
+interface LLMCallTrace {
+    timestamp: Date;
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    duration: number;
+    purpose: string;
+}
+interface RetryPolicy {
+    maxRetries: number;
+    backoffStrategy: 'fixed' | 'linear' | 'exponential';
+    baseDelay: number;
+    maxDelay: number;
+    retryableErrors: string[];
+    onRetry?: (attempt: number, error: Error, delay: number) => void;
+}
+interface CircuitBreakerConfig {
+    failureThreshold: number;
+    resetTimeout: number;
+    halfOpenMaxCalls: number;
+}
+interface ResilienceContext {
+    retryPolicy: RetryPolicy;
+    circuitBreaker?: CircuitBreakerConfig;
+    timeout?: number;
+}
+interface ExecutionObserver {
+    onExecutionStart?(context: ExecutionContext): void;
+    onPhaseStart?(phase: ExecutionPhase, context: ExecutionContext): void;
+    onPhaseEnd?(phase: ExecutionPhase, duration: number, context: ExecutionContext): void;
+    onStepStart?(step: ExecutionStep, context: ExecutionContext): void;
+    onStepEnd?(step: ExecutionStep, result: StepResult, context: ExecutionContext): void;
+    onDecision?(decision: DecisionTrace, context: ExecutionContext): void;
+    onLLMCall?(call: LLMCallTrace, context: ExecutionContext): void;
+    onError?(error: ExecutionError, context: ExecutionContext): void;
+    onExecutionEnd?(result: ExecutionResult, context: ExecutionContext): void;
+}
+
+/**
+ * Perfect Execution Engine - Part 1: Core Engine
+ *
+ * Features:
+ * - Deterministic execution with full traceability
+ * - Multi-strategy execution (sequential, parallel, adaptive)
+ * - Comprehensive retry and circuit breaker patterns
+ * - Real-time execution monitoring
+ */
+
+interface ExecutionEngineConfig {
+    defaultTimeout?: number;
+    defaultRetryPolicy?: RetryPolicy;
+    enableTracing?: boolean;
+    enableMetrics?: boolean;
+    maxConcurrentExecutions?: number;
+    observers?: ExecutionObserver[];
+}
+declare class ExecutionEngine {
+    private config;
+    private activeExecutions;
+    private circuitBreakers;
+    private metrics;
+    constructor(config?: ExecutionEngineConfig);
+    execute(plan: ExecutionPlan, context?: Partial<ExecutionContext>, resilience?: ResilienceContext): Promise<ExecutionResult>;
+    private executeSteps;
+    private executeStepWithResilience;
+    private executeStep;
+    private executeWithTimeout;
+    private executePhase;
+    private validatePlan;
+    private processResults;
+    private determineFinalStatus;
+    private calculateBackoff;
+    private isRetryableError;
+    private getCircuitBreaker;
+    cancelExecution(executionId: string): boolean;
+    getMetrics(): ExecutionMetrics;
+    resetMetrics(): void;
+    addObserver(observer: ExecutionObserver): void;
+    removeObserver(observer: ExecutionObserver): void;
+    private notifyObservers;
+    private generateId;
+    private sleep;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Main exports for sdkwork-browser-agent
+ * Browser and Node.js compatible agent architecture
+ */
+
+declare const VERSION = "1.0.0";
+declare const isBrowser: boolean;
+declare const isNode: boolean;
+
+export { type AdvancedDecision, AdvancedDecisionEngine, type ExecutionContext$1 as AdvancedExecutionContext, Agent, AgentConfig, type AutoExecutionResult, type Decision, type DecisionContext, DecisionEngine, type DecisionEngineConfig, DynamicSkillLoader, type EmbeddingProvider, ExecutionEngine, type ExecutionEngineConfig, type ExtractionContext, type ExtractionResult, type ExtractorConfig, type ParameterSchema as ExtractorParameterSchema, type IntentPattern, LLMMessage, type LoadedSkill, ParameterExtractor, Plugin, PluginContext, type PluginFactory, PluginLoader, PluginManager, type PluginManagerConfig, SimpleEmbeddingProvider, Skill, type SkillLoaderConfig, SkillResult, type SkillSource, SmartAgent, type SmartAgentConfig, type TokenEstimate, TokenOptimizer, type TokenOptimizerConfig, Tool, VERSION, isBrowser, isNode };