@smythos/sre 1.5.74 → 1.6.0

package/dist/types/Components/Component.class.d.ts

@@ -1,16 +1,30 @@
 import { IAgent as Agent } from '@sre/types/Agent.types';
-export type ComponentSchema = {
+export type TComponentSchema = {
     name: string;
     settings?: Record<string, any>;
     inputs?: Record<string, any>;
     outputs?: Record<string, any>;
 };
+export declare enum ComponentInputType {
+    Any = "Any",
+    Binary = "Binary",
+    String = "Text",
+    Text = "Text",
+    Image = "Image",
+    Video = "Video",
+    Number = "Number",
+    Integer = "Integer",
+    Boolean = "Boolean",
+    Date = "Date",
+    Array = "Array",
+    Object = "Object"
+}
 export declare class Component {
     hasReadOutput: boolean;
     hasPostProcess: boolean;
     alwaysActive: boolean;
     exclusive: boolean;
-    protected schema: ComponentSchema;
+    protected schema: TComponentSchema;
     protected configSchema: any;
     constructor();
     init(): void;

package/dist/types/helpers/AIPerformanceAnalyzer.helper.d.ts

@@ -0,0 +1,45 @@
+import { AIComponentMetrics, AIAgentPerformanceReport, AIPerformanceBottleneck } from '@sre/types/Performance.types';
+/**
+ * Advanced AI Performance Analyzer
+ */
+export declare class AIPerformanceAnalyzer {
+    private behaviorAnalyzer;
+    private logger;
+    /**
+     * Generate comprehensive AI agent performance report
+     */
+    analyzeAgentPerformance(agentId: string, agentName: string, metrics: AIComponentMetrics[], timeWindow?: {
+        start: number;
+        end: number;
+    }): Promise<AIAgentPerformanceReport>;
+    /**
+     * Real-time bottleneck detection
+     */
+    detectRealTimeBottleneck(metric: AIComponentMetrics): Promise<AIPerformanceBottleneck | null>;
+    private calculateSummaryStats;
+    private analyzeComponentPerformance;
+    private detectBottlenecks;
+    private generateOptimizationRecommendations;
+    private analyzeAISpecificPatterns;
+    private analyzeTrends;
+    private calculatePerformanceGrade;
+    private findCriticalPath;
+    private findParallelizationOpportunities;
+    private classifyBottleneckType;
+    private generateBottleneckDescription;
+    private identifyRootCause;
+    private calculatePerformanceImpact;
+    private generateFixSuggestion;
+    private assessImplementationComplexity;
+    private estimateResolutionTime;
+    private estimatePerformanceGain;
+    private estimateCostReduction;
+    private getPrerequisites;
+    private analyzeComponentSequences;
+    private findDuplicatePrompts;
+    private findModelDowngradeOpportunities;
+    private findCachingOpportunities;
+    private findBatchingOpportunities;
+    private calculateDataFlowEfficiency;
+    private calculateInformationLossRate;
+}

package/dist/types/helpers/AIPerformanceCollector.helper.d.ts

@@ -0,0 +1,111 @@
+import { AIComponentMetrics, AIPerformanceConfig, MetricWindow } from '@sre/types/Performance.types';
+import { EventEmitter } from 'events';
+/**
+ * Zero-overhead performance timer with AI-specific tracking
+ */
+export declare class AIPerformanceTimer {
+    private componentName;
+    private agentId;
+    private configHash;
+    private startTime;
+    private startMemory;
+    private checkpoints;
+    private llmMetrics;
+    constructor(componentName: string, agentId: string, configHash: string);
+    /**
+     * Add checkpoint for detailed timing analysis
+     */
+    checkpoint(name: string): void;
+    /**
+     * Track LLM-specific metrics
+     */
+    trackLLM(llmData: {
+        model: string;
+        promptTokens: number;
+        completionTokens: number;
+        estimatedCost: number;
+        contextUtilization?: number;
+        qualityScore?: number;
+    }): void;
+    /**
+     * Complete timing and generate comprehensive metrics
+     */
+    finish(inputData?: any, outputData?: any, success?: boolean, errorType?: string, retryCount?: number): AIComponentMetrics;
+    private calculateDataSize;
+    private calculateComplexityScore;
+    private getObjectComplexity;
+    private calculateMemoryPressure;
+    private estimateCPUUsage;
+}
+/**
+ * Main AI Performance Collector - Enterprise-grade monitoring system
+ */
+export declare class AIPerformanceCollector extends EventEmitter {
+    private static instance;
+    private metricsBuffer;
+    private config;
+    private logger;
+    private activeTimers;
+    private eventSequence;
+    private batchBuffer;
+    private flushTimer?;
+    private constructor();
+    /**
+     * Get singleton instance with configuration
+     */
+    static getInstance(config?: AIPerformanceConfig): AIPerformanceCollector;
+    /**
+     * Start monitoring a component execution
+     */
+    startComponentExecution(componentName: string, agentId: string, config?: any): AIPerformanceTimer | null;
+    /**
+     * Record completed component execution
+     */
+    recordMetrics(agentId: string, metrics: AIComponentMetrics): void;
+    /**
+     * Get metrics for specific agent within time window
+     */
+    getAgentMetrics(agentId: string, window?: MetricWindow): AIComponentMetrics[];
+    /**
+     * Get aggregated metrics across all agents
+     */
+    getGlobalMetrics(window?: MetricWindow): AIComponentMetrics[];
+    /**
+     * Clear metrics for specific agent
+     */
+    clearAgentMetrics(agentId: string): void;
+    /**
+     * Get current system statistics
+     */
+    getSystemStats(): {
+        activeTimers: number;
+        totalMetrics: number;
+        memoryUsage: number;
+        eventBufferSize: number;
+    };
+    /**
+     * Update configuration at runtime
+     */
+    updateConfig(newConfig: Partial<AIPerformanceConfig>): void;
+    /**
+     * Export metrics for external monitoring systems
+     */
+    exportMetrics(format?: 'json' | 'prometheus' | 'csv'): string;
+    private shouldMonitorComponent;
+    private shouldSample;
+    private generateConfigHash;
+    private emitEvent;
+    private setupFlushTimer;
+    private checkPerformanceThresholds;
+    private formatPrometheusMetrics;
+    private formatCSVMetrics;
+    /**
+     * Graceful shutdown
+     */
+    private flushBatch;
+    shutdown(): Promise<void>;
+}
+/**
+ * Default configuration for development
+ */
+export declare const DEFAULT_AI_PERFORMANCE_CONFIG: AIPerformanceConfig;

package/dist/types/helpers/Conversation.helper.d.ts

@@ -45,6 +45,7 @@ export declare class Conversation extends EventEmitter {
         toolsStrategy?: (toolsConfig: any) => any;
         agentId?: string;
         agentVersion?: string;
+        baseUrl?: string;
     });
     get ready(): any;
     prompt(message?: string | any, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<string>;

package/dist/types/index.d.ts

@@ -176,9 +176,9 @@ export * from './subsystems/MemoryManager/Cache.service/connectors/LocalStorageC
 export * from './subsystems/MemoryManager/Cache.service/connectors/RAMCache.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/RedisCache.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/S3Cache.class';
-export * from './subsystems/Security/Account.service/connectors/AWSAccount.class';
 export * from './subsystems/Security/Account.service/connectors/DummyAccount.class';
 export * from './subsystems/Security/Account.service/connectors/JSONFileAccount.class';
+export * from './subsystems/Security/Account.service/connectors/MySQLAccount.class';
 export * from './subsystems/Security/ManagedVault.service/connectors/NullManagedVault.class';
 export * from './subsystems/Security/ManagedVault.service/connectors/SecretManagerManagedVault';
 export * from './subsystems/Security/Vault.service/connectors/HashicorpVault.class';

package/dist/types/subsystems/IO/VectorDB.service/connectors/MilvusVectorDB.class.d.ts

@@ -15,8 +15,14 @@ export type IMilvusCredentials = {
     token?: string;
 };
 export type MilvusConfig = {
+    /**
+     * The Milvus connection credentials
+     */
     credentials: IMilvusCredentials;
-    embeddings: TEmbeddings;
+    /**
+     * The embeddings model to use
+     */
+    embeddings?: TEmbeddings;
 };
 export declare class MilvusVectorDB extends VectorDBConnector {
     protected _settings: MilvusConfig;

package/dist/types/subsystems/IO/VectorDB.service/connectors/PineconeVectorDB.class.d.ts

@@ -17,7 +17,7 @@ export type PineconeConfig = {
     /**
      * The embeddings model to use
      */
-    embeddings: TEmbeddings;
+    embeddings?: TEmbeddings;
 };
 export declare class PineconeVectorDB extends VectorDBConnector {
     protected _settings: PineconeConfig;

package/dist/types/subsystems/IO/VectorDB.service/connectors/RAMVecrtorDB.class.d.ts

@@ -5,7 +5,10 @@ import { VectorDBConnector, DeleteTarget } from '../VectorDBConnector';
 import { DatasourceDto, IStorageVectorDataSource, IStorageVectorNamespace, IVectorDataSourceDto, QueryOptions, VectorsResultData } from '@sre/types/VectorDB.types';
 import { BaseEmbedding, TEmbeddings } from '../embed/BaseEmbedding';
 export type RAMVectorDBConfig = {
-    embeddings: TEmbeddings;
+    /**
+     * The embeddings model to use
+     */
+    embeddings?: TEmbeddings;
 };
 /**
  * RAM Vector Database - stores everything in memory
@@ -20,10 +23,10 @@ export declare class RAMVectorDB extends VectorDBConnector {
     name: string;
     id: string;
     private accountConnector;
-    private vectors;
-    private namespaces;
-    private datasources;
-    private acls;
+    private static vectors;
+    private static namespaces;
+    private static datasources;
+    private static acls;
     embedder: BaseEmbedding;
     constructor(_settings: RAMVectorDBConfig);
     getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;

package/dist/types/subsystems/IO/VectorDB.service/connectors/WeaviateVectorDB.class.d.ts

@@ -0,0 +1,187 @@
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { VectorDBConnector, DeleteTarget } from '../VectorDBConnector';
+import { DatasourceDto, IStorageVectorDataSource, IVectorDataSourceDto, QueryOptions, VectorsResultData } from '@sre/types/VectorDB.types';
+import { TEmbeddings } from '../embed/BaseEmbedding';
+export type WeaviateConfig = {
+    /**
+     * The Weaviate instance URL
+     */
+    url: string;
+    /**
+     * The Weaviate API key (optional for open source)
+     */
+    apiKey?: string;
+    /**
+     * The class name to use for storing vectors
+     */
+    className?: string;
+    /**
+     * The embeddings model to use
+     */
+    embeddings: TEmbeddings;
+    /**
+     * Additional Weaviate client options
+     */
+    clientOptions?: {
+        timeout?: number;
+        headers?: Record<string, string>;
+    };
+};
+export declare class WeaviateVectorDB extends VectorDBConnector {
+    protected _settings: WeaviateConfig;
+    name: string;
+    id: string;
+    private client;
+    private className;
+    private cache;
+    private accountConnector;
+    private nkvConnector;
+    embedder: any;
+    constructor(_settings: WeaviateConfig);
+    /**
+     * @async
+     * @method getResourceACL
+     * @description Gets the ACL for a specific resource in Weaviate
+     * @param {string} resourceId - The resource identifier
+     * @param {IAccessCandidate} candidate - The access candidate
+     * @returns {Promise<ACL>} The ACL for the resource
+     * @throws {Error} If there's an error retrieving the ACL
+     */
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    /**
+     * @async
+     * @method getACL
+     * @description Gets the ACL for a specific namespace in Weaviate
+     * @param {AccessCandidate} candidate - The access candidate
+     * @param {string} preparedNs - The prepared namespace name
+     * @returns {Promise<IACL | null>} The ACL for the namespace or null if not found
+     * @throws {Error} If there's an error retrieving the ACL
+     */
+    private getACL;
+    /**
+     * @async
+     * @method createNamespace
+     * @description Creates a namespace in Weaviate by creating a class
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace name
+     * @param {object} metadata - Optional metadata
+     * @returns {Promise<void>}
+     * @throws {Error} If there's an error creating the namespace
+     */
+    protected createNamespace(acRequest: AccessRequest, namespace: string, metadata?: {
+        [key: string]: any;
+    }): Promise<void>;
+    /**
+     * @async
+     * @method deleteNamespace
+     * @description Deletes a namespace by removing the class
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace name
+     * @returns {Promise<void>}
+     * @throws {Error} If there's an error deleting the namespace
+     */
+    protected deleteNamespace(acRequest: AccessRequest, namespace: string): Promise<void>;
+    /**
+     * @async
+     * @method namespaceExists
+     * @description Checks if a namespace exists in Weaviate
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace name
+     * @returns {Promise<boolean>} True if namespace exists
+     * @throws {Error} If there's an error checking namespace existence
+     */
+    protected namespaceExists(acRequest: AccessRequest, namespace: string): Promise<boolean>;
+    /**
+     * @async
+     * @method search
+     * @description Performs vector search in Weaviate
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace to search in
+     * @param {string | number[]} query - The search query (text or vector)
+     * @param {QueryOptions} options - Search options
+     * @returns {Promise<VectorsResultData>} Search results
+     * @throws {Error} If there's an error performing the search
+     */
+    protected search(acRequest: AccessRequest, namespace: string, query: string | number[], options: QueryOptions): Promise<VectorsResultData>;
+    /**
+     * @async
+     * @method insert
+     * @description Inserts vectors into Weaviate
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace to insert into
+     * @param {IVectorDataSourceDto | IVectorDataSourceDto[]} source - The data to insert
+     * @returns {Promise<string[]>} Array of inserted IDs
+     * @throws {Error} If there's an error inserting data
+     */
+    protected insert(acRequest: AccessRequest, namespace: string, source: IVectorDataSourceDto | IVectorDataSourceDto[]): Promise<string[]>;
+    /**
+     * @async
+     * @method delete
+     * @description Deletes vectors from Weaviate
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace to delete from
+     * @param {DeleteTarget} deleteTarget - What to delete
+     * @returns {Promise<void>}
+     * @throws {Error} If there's an error deleting data
+     */
+    protected delete(acRequest: AccessRequest, namespace: string, deleteTarget: DeleteTarget): Promise<void>;
+    /**
+     * @async
+     * @method createDatasource
+     * @description Creates a datasource in Weaviate
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace
+     * @param {DatasourceDto} datasource - The datasource data
+     * @returns {Promise<IStorageVectorDataSource>} The created datasource
+     * @throws {Error} If there's an error creating the datasource
+     */
+    protected createDatasource(acRequest: AccessRequest, namespace: string, datasource: DatasourceDto): Promise<IStorageVectorDataSource>;
+    /**
+     * @async
+     * @method deleteDatasource
+     * @description Deletes a datasource from Weaviate
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace
+     * @param {string} datasourceId - The datasource ID
+     * @returns {Promise<void>}
+     * @throws {Error} If there's an error deleting the datasource
+     */
+    protected deleteDatasource(acRequest: AccessRequest, namespace: string, datasourceId: string): Promise<void>;
+    /**
+     * @async
+     * @method listDatasources
+     * @description Lists all datasources in a namespace
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace
+     * @returns {Promise<IStorageVectorDataSource[]>} Array of datasources
+     * @throws {Error} If there's an error listing datasources
+     */
+    protected listDatasources(acRequest: AccessRequest, namespace: string): Promise<IStorageVectorDataSource[]>;
+    /**
+     * @async
+     * @method getDatasource
+     * @description Gets a specific datasource
+     * @param {AccessRequest} acRequest - The access request
+     * @param {string} namespace - The namespace
+     * @param {string} datasourceId - The datasource ID
+     * @returns {Promise<IStorageVectorDataSource | undefined>} The datasource or undefined
+     * @throws {Error} If there's an error getting the datasource
+     */
+    protected getDatasource(acRequest: AccessRequest, namespace: string, datasourceId: string): Promise<IStorageVectorDataSource | undefined>;
+    /**
+     * @method buildWhereClause
+     * @description Builds a Weaviate where clause from filter options
+     * @param {any} filter - The filter object
+     * @returns {object} Weaviate where clause
+     */
+    private buildWhereClause;
+    /**
+     * @async
+     * @method stop
+     * @description Stops the Weaviate connector
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+}

package/dist/types/subsystems/MemoryManager/RuntimeContext.d.ts

@@ -35,6 +35,7 @@ export declare class RuntimeContext extends EventEmitter {
     private _runtimeFileReady;
     private _cacheConnector;
     private _readyPromise;
+    private _lastCtxLength;
     constructor(runtime: AgentRuntime);
     private serialize;
     private deserialize;

package/dist/types/subsystems/PerformanceManager/Performance.service/PerformanceConnector.d.ts

@@ -0,0 +1,102 @@
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { AIComponentMetrics, AIAgentPerformanceReport, AIPerformanceEvent, AIPerformanceConfig, MetricWindow, ComponentBaseline, ExternalMonitoringExport } from '@sre/types/Performance.types';
+/**
+ * Performance request interface for secure access
+ */
+export interface IPerformanceRequest {
+    /** Store performance metrics for an agent */
+    storeMetrics(metrics: AIComponentMetrics[]): Promise<void>;
+    /** Retrieve metrics within a time window */
+    getMetrics(timeWindow?: MetricWindow): Promise<AIComponentMetrics[]>;
+    /** Generate comprehensive performance report */
+    generateReport(): Promise<AIAgentPerformanceReport>;
+    /** Clear stored metrics */
+    clearMetrics(): Promise<void>;
+    /** Get real-time performance events */
+    getEvents(since?: number): Promise<AIPerformanceEvent[]>;
+    /** Update performance monitoring configuration */
+    updateConfig(config: Partial<AIPerformanceConfig>): Promise<void>;
+    /** Export metrics in various formats */
+    exportMetrics(format: 'json' | 'prometheus' | 'csv'): Promise<string>;
+    /** Get component performance baselines */
+    getBaselines(): Promise<ComponentBaseline[]>;
+    /** Establish baseline for specific component */
+    establishBaseline(componentName: string): Promise<ComponentBaseline>;
+}
+/**
+ * Abstract base class for performance connectors
+ */
+export declare abstract class PerformanceConnector extends SecureConnector {
+    abstract id: string;
+    /**
+     * Get ACL for performance resources
+     */
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    /**
+     * Create secure requester interface scoped to access candidate
+     */
+    requester(candidate: AccessCandidate): IPerformanceRequest;
+    /**
+     * Store performance metrics with access control
+     */
+    protected abstract storeMetrics(accessRequest: AccessRequest, metrics: AIComponentMetrics[]): Promise<void>;
+    /**
+     * Retrieve metrics with time window filtering
+     */
+    protected abstract getMetrics(accessRequest: AccessRequest, timeWindow?: MetricWindow): Promise<AIComponentMetrics[]>;
+    /**
+     * Generate comprehensive performance report
+     */
+    protected abstract generateReport(accessRequest: AccessRequest): Promise<AIAgentPerformanceReport>;
+    /**
+     * Clear stored metrics
+     */
+    protected abstract clearMetrics(accessRequest: AccessRequest): Promise<void>;
+    /**
+     * Get performance events
+     */
+    protected abstract getEvents(accessRequest: AccessRequest, since?: number): Promise<AIPerformanceEvent[]>;
+    /**
+     * Update monitoring configuration
+     */
+    protected abstract updateConfig(accessRequest: AccessRequest, config: Partial<AIPerformanceConfig>): Promise<void>;
+    /**
+     * Export metrics in various formats
+     */
+    protected abstract exportMetrics(accessRequest: AccessRequest, format: 'json' | 'prometheus' | 'csv'): Promise<string>;
+    /**
+     * Get component baselines
+     */
+    protected abstract getBaselines(accessRequest: AccessRequest): Promise<ComponentBaseline[]>;
+    /**
+     * Establish baseline for component
+     */
+    protected abstract establishBaseline(accessRequest: AccessRequest, componentName: string): Promise<ComponentBaseline>;
+    /**
+     * Export to external monitoring systems
+     */
+    protected exportToExternal(accessRequest: AccessRequest, exportConfig: ExternalMonitoringExport): Promise<void>;
+    /**
+     * Perform health check on the connector
+     */
+    healthCheck(): Promise<{
+        status: 'healthy' | 'degraded' | 'unhealthy';
+        details: Record<string, any>;
+    }>;
+    /**
+     * Get connector statistics
+     */
+    getStats(): Promise<{
+        totalMetrics: number;
+        agentCount: number;
+        timeRange: {
+            start: number;
+            end: number;
+        };
+        storageSize: number;
+    }>;
+}

package/dist/types/subsystems/PerformanceManager/Performance.service/connectors/LocalPerformanceConnector.class.d.ts

@@ -0,0 +1,100 @@
+import { PerformanceConnector, IPerformanceRequest } from '../PerformanceConnector';
+import { AIComponentMetrics, AIAgentPerformanceReport, AIPerformanceEvent, AIPerformanceConfig, MetricWindow, ComponentBaseline } from '@sre/types/Performance.types';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+/**
+ * Local Performance Connector Implementation
+ */
+export declare class LocalPerformanceConnector extends PerformanceConnector {
+    name: string;
+    id: string;
+    private metricsIndex;
+    private config;
+    private analyzer;
+    private collector;
+    private logger;
+    private dataDir;
+    private isInitialized;
+    constructor(settings?: any);
+    /**
+     * Initialize the connector
+     */
+    start(): Promise<void>;
+    /**
+     * Shutdown the connector
+     */
+    stop(): Promise<void>;
+    /**
+     * Get resource ACL
+     */
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    /**
+     * Override requester method to implement proper access control
+     * Create secure requester interface scoped to access candidate
+     */
+    requester(candidate: AccessCandidate): IPerformanceRequest;
+    /**
+     * Store performance metrics
+     */
+    protected storeMetrics(accessRequest: AccessRequest, metrics: AIComponentMetrics[]): Promise<void>;
+    /**
+     * Retrieve metrics with filtering
+     */
+    protected getMetrics(accessRequest: AccessRequest, timeWindow?: MetricWindow): Promise<AIComponentMetrics[]>;
+    /**
+     * Generate comprehensive performance report
+     */
+    protected generateReport(accessRequest: AccessRequest): Promise<AIAgentPerformanceReport>;
+    /**
+     * Clear stored metrics
+     */
+    protected clearMetrics(accessRequest: AccessRequest): Promise<void>;
+    /**
+     * Get performance events
+     */
+    protected getEvents(accessRequest: AccessRequest, since?: number): Promise<AIPerformanceEvent[]>;
+    /**
+     * Update monitoring configuration
+     */
+    protected updateConfig(accessRequest: AccessRequest, config: Partial<AIPerformanceConfig>): Promise<void>;
+    /**
+     * Export metrics in various formats
+     */
+    protected exportMetrics(accessRequest: AccessRequest, format: 'json' | 'prometheus' | 'csv'): Promise<string>;
+    /**
+     * Get component baselines
+     */
+    protected getBaselines(accessRequest: AccessRequest): Promise<ComponentBaseline[]>;
+    /**
+     * Establish baseline for component
+     */
+    protected establishBaseline(accessRequest: AccessRequest, componentName: string): Promise<ComponentBaseline>;
+    /**
+     * Get connector statistics
+     */
+    getStats(): Promise<{
+        totalMetrics: number;
+        agentCount: number;
+        timeRange: {
+            start: number;
+            end: number;
+        };
+        storageSize: number;
+    }>;
+    private addToIndex;
+    private enforceSizeLimits;
+    private checkRealTimeBottleneck;
+    private setupEventListeners;
+    private loadPersistedData;
+    private setupPersistence;
+    private persistData;
+    private aggregateMetrics;
+    private aggregate;
+    private percentile;
+    private mean;
+    private formatPrometheusMetrics;
+    private formatCSVMetrics;
+    private estimateStorageSize;
+}