@codai/memorai-core/dist/ai/CrossAgentCollaborationManager.d.ts

Simplified advanced memory engine - no tiers, just powerful semantic search with persistence

/**
 * Cross-Agent Memory Collaboration System
 * Enables intelligent memory sharing and coordination between multiple AI agents
 */
import { MemoryMetadata } from '../types/index.js';
export interface AgentProfile {
    id: string;
    name: string;
    type: AgentType;
    capabilities: string[];
    specializations: string[];
    trustLevel: number;
    collaborationHistory: {
        totalInteractions: number;
        successfulShares: number;
        lastInteraction: Date;
    };
    memoryAccessLevel: AccessLevel;
    preferences: {
        shareOwnMemories: boolean;
        acceptSharedMemories: boolean;
        autoCollaborate: boolean;
        privacyMode: 'open' | 'selective' | 'restricted';
    };
}
export type AgentType = 'assistant' | 'specialist' | 'coordinator' | 'analyst' | 'creative' | 'technical' | 'research';
export type AccessLevel = 'public' | 'shared' | 'private' | 'restricted';
export interface MemoryShareRequest {
    id: string;
    fromAgent: string;
    toAgent: string;
    memories: string[];
    purpose: SharePurpose;
    context: string;
    expiresAt: Date;
    status: 'pending' | 'approved' | 'denied' | 'expired';
    priority: 'low' | 'medium' | 'high' | 'urgent';
    metadata: {
        requestedAt: Date;
        reason: string;
        expectedValue: number;
        sensitivityLevel: 'low' | 'medium' | 'high';
    };
}
export type SharePurpose = 'task_collaboration' | 'knowledge_sharing' | 'problem_solving' | 'context_enrichment' | 'skill_transfer' | 'quality_improvement';
export interface CollaborationSession {
    id: string;
    participants: string[];
    purpose: SharePurpose;
    startTime: Date;
    endTime?: Date;
    sharedMemories: Array<{
        memoryId: string;
        sharedBy: string;
        accessLevel: AccessLevel;
        shareTime: Date;
    }>;
    insights: Array<{
        insight: string;
        confidence: number;
        contributingAgents: string[];
        timestamp: Date;
    }>;
    outcomes: {
        tasksCompleted: string[];
        knowledgeGained: string[];
        problemsSolved: string[];
        efficiency: number;
    };
    isActive: boolean;
}
export interface CollaborationConfig {
    enabled: boolean;
    autoApproveThreshold: number;
    maxSharesPerHour: number;
    defaultShareExpiration: number;
    enableCrossTypeCollaboration: boolean;
    enableSkillBasedMatching: boolean;
    privacyProtection: boolean;
    auditLogging: boolean;
}
export declare class CrossAgentCollaborationManager {
    private config;
    private agentProfiles;
    private shareRequests;
    private activeSessions;
    private collaborationHistory;
    constructor(config?: Partial<CollaborationConfig>);
    /**
     * Register an agent for collaboration
     */
    registerAgent(profile: AgentProfile): void;
    /**
     * Request memory sharing between agents
     */
    requestMemoryShare(fromAgent: string, toAgent: string, memoryIds: string[], purpose: SharePurpose, context: string, priority?: 'low' | 'medium' | 'high' | 'urgent'): Promise<MemoryShareRequest>;
    /**
     * Approve a memory share request
     */
    approveShareRequest(requestId: string): Promise<boolean>;
    /**
     * Deny a memory share request
     */
    denyShareRequest(requestId: string, reason: string): Promise<boolean>;
    /**
     * Find optimal collaboration partners for an agent
     */
    findCollaborationPartners(agentId: string, task: string, requiredSkills?: string[]): Promise<Array<{
        agent: AgentProfile;
        compatibilityScore: number;
        recommendationReason: string;
    }>>;
    /**
     * Create collaborative memory insights from shared memories
     */
    generateCollaborativeInsights(sessionId: string, sharedMemories: MemoryMetadata[]): Promise<Array<{
        insight: string;
        confidence: number;
        contributingAgents: string[];
        supportingMemories: string[];
    }>>;
    /**
     * Start a collaborative problem-solving session
     */
    startCollaborativeSession(initiatingAgent: string, participants: string[], purpose: SharePurpose, problemDescription: string): Promise<string>;
    /**
     * End a collaborative session and generate outcomes
     */
    endCollaborativeSession(sessionId: string): Promise<{
        summary: string;
        achievements: string[];
        learnings: string[];
        efficiency: number;
        recommendations: string[];
    }>;
    private shouldAutoApprove;
    private calculateExpectedValue;
    private assessSensitivity;
    private determineAccessLevel;
    private getOrCreateCollaborationSession;
    private updateCollaborationHistory;
    private calculateCompatibilityScore;
    private getTypeCompatibility;
    private detectCrossAgentPatterns;
    private identifyKnowledgeGaps;
    private analyzeComplementaryCapabilities;
    private suggestMemoriesForCollaboration;
    private calculateSessionEfficiency;
    private generateSessionSummary;
    /**
     * Get collaboration analytics
     */
    getCollaborationAnalytics(): {
        totalSessions: number;
        activeSessions: number;
        averageEfficiency: number;
        topCollaborators: Array<{
            agentId: string;
            collaborations: number;
        }>;
        collaborationTrends: Array<{
            purpose: SharePurpose;
            count: number;
        }>;
    };
    private extractKeywords;
    private getPurposeWeight;
    private getAgentMemories;
    private calculateSemanticRelevance;
    private getTypeRelevanceForPurpose;
    private calculateRecencyScore;
    private generateSuggestionReason;
    private calculateParticipantEfficiency;
    private calculateCommunicationEfficiency;
    private calculateOutcomeQuality;
}
//# sourceMappingURL=CrossAgentCollaborationManager.d.ts.map