@smythos/sre 1.6.8 → 1.6.9

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/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;
+}

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

@@ -0,0 +1,22 @@
+import { ConnectorServiceProvider } from '../../../Core/ConnectorsService';
+/**
+ * Performance Service Provider
+ */
+export declare class PerformanceService extends ConnectorServiceProvider {
+    private logger;
+    /**
+     * Register all available performance connectors
+     */
+    register(): void;
+    /**
+     * Initialize performance service
+     */
+    init(): void;
+    /**
+     * Auto-configure performance monitoring based on environment
+     */
+    private autoConfigurePerformanceMonitoring;
+}
+export { LocalPerformanceConnector } from './connectors/LocalPerformanceConnector.class';
+export { PerformanceConnector } from './PerformanceConnector';
+export type { IPerformanceRequest } from './PerformanceConnector';

package/dist/types/subsystems/Security/Credentials/Credentials.class.d.ts

@@ -0,0 +1,2 @@
+export declare class Credentials {
+}

package/dist/types/subsystems/Security/Credentials/ManagedOAuth2Credentials.class.d.ts

@@ -0,0 +1,18 @@
+import { Credentials } from './Credentials.class';
+import { AccessCandidate } from '../AccessControl/AccessCandidate.class';
+export declare class ManagedOAuth2Credentials extends Credentials {
+    #private;
+    get accessToken(): string;
+    get refreshToken(): string;
+    get expiresIn(): number;
+    get scope(): string;
+    get tokenUrl(): string;
+    get service(): string;
+    private constructor();
+    static load(keyId: string, candidate: AccessCandidate): Promise<ManagedOAuth2Credentials>;
+    private parseData;
+    /**
+     * Get a fresh access token using the refresh token
+     */
+    refreshAccessToken(): Promise<string>;
+}

package/dist/types/subsystems/Security/Credentials/OAuth2Credentials.class.d.ts

@@ -0,0 +1,14 @@
+import { Credentials } from './Credentials.class';
+import { AccessCandidate } from '../AccessControl/AccessCandidate.class';
+export declare class OAuth2Credentials extends Credentials {
+    #private;
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    scope: string;
+    tokenUrl: string;
+    service: string;
+    constructor(data: any);
+    static fromManagedVault(keyId: string, candidate: AccessCandidate): Promise<OAuth2Credentials>;
+    private parseData;
+}