@polybiouslabs/polybious/dist/core/skill-loader.d.ts

Polybius is a next-generation intelligent agent framework built for adaptability across diverse domains. It merges contextual awareness, multi-agent collaboration, and predictive reasoning to deliver dynamic, self-optimizing performance.

export interface Tool {
    id: string;
    name: string;
    type: string;
    config: any;
    status: 'loading' | 'ready' | 'failed' | 'unloading';
    attachedAt: Date;
    loadedAt?: Date;
    usageCount: number;
    successRate: number;
    averageExecutionTime: number;
    dependencies: Dependency[];
    error?: string;
}

export interface Dependency {
    type: string;
    name: string;
    critical: boolean;
}

export interface ToolStats {
    totalUses: number;
    successfulUses: number;
    failedUses: number;
    avgExecutionTime: number;
    lastUsed: Date | null;
    performanceHistory: PerformanceEntry[];
}

export interface PerformanceEntry {
    timestamp: Date;
    executionTime: number;
    success: boolean;
}

export interface SkillCategory {
    name: string;
    tools: string[];
    createdAt: Date;
}

export interface ToolRecommendation {
    toolName: string;
    capability: string;
    confidence: number;
    reason: string;
    config: any;
}

export interface ToolExecutionResult {
    executionId: string;
    success: boolean;
    result: any;
    executionTime: number;
    toolName: string;
    timestamp: Date;
}

export interface AdaptiveLoadResult {
    loadedTools: Array<{
        toolId: string;
        toolName: string;
        confidence: number;
        reason: string;
    }>;
    totalRecommendations: number;
    successfulLoads: number;
    context: any;
    timestamp: Date;
}

export interface SkillStats {
    totalTools: number;
    toolsByType: Record<string, number>;
    averageSuccessRate: number;
    totalExecutions: number;
    mostUsedTools: Array<{ name: string; uses: number }>;
}

export declare class AdaptiveSkillLoader {
    skills: Map<string, any>;
    loadedTools: Map<string, Tool>;
    skillCategories: Map<string, SkillCategory>;
    usageStats: Map<string, ToolStats>;
    dependencies: Map<string, any>;
    skillPath: string;

    constructor();
    attachTool(toolName: string, toolConfig?: any): Promise<string>;
    removeTool(toolName: string): Promise<void>;
    getAvailableTools(category?: string | null): Promise<Array<{
        name: string;
        type: string;
        status: string;
        attachedAt: Date;
        usageCount: number;
        successRate: number;
        averageExecutionTime: number;
        dependencies: Dependency[];
        description: string;
    }>>;
    executeTool(toolName: string, parameters?: any): Promise<ToolExecutionResult>;
    adaptivelyLoadTools(requiredCapabilities: string[], context?: any): Promise<AdaptiveLoadResult>;
    recommendTools(requiredCapabilities: string[], context: any): ToolRecommendation[];
    getToolMappings(): Map<string, Array<{ name: string; reason: string; confidence: number }>>;
    calculateToolConfidence(toolInfo: any, context: any): number;
    inferToolType(toolName: string): string;
    analyzeDependencies(toolName: string, config: any): Dependency[];
    validateDependencies(tool: Tool): Promise<void>;
    findDependentTools(toolName: string): Tool[];
    loadTool(tool: Tool): Promise<void>;
    unloadTool(tool: Tool): Promise<void>;
    runTool(tool: Tool, parameters: any): Promise<any>;
    generateMockResult(tool: Tool, parameters: any): any;
    updateToolStats(tool: Tool, stats: ToolStats, executionTime: number, success: boolean): void;
    getToolDescription(toolName: string): string;
    addToCategory(categoryType: string, toolName: string): void;
    initializeCategories(): void;
    getSkillStats(): SkillStats;
    loadSkillRegistry(): Promise<void>;
    saveSkillRegistry(): Promise<void>;
}