@smythos/sre 1.6.8 → 1.6.10

package/dist/types/Components/Triggers/Gmail.trigger.d.ts

@@ -0,0 +1,58 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Trigger } from './Trigger.class';
+export type GmailTriggerAttachment = {
+    filename: string;
+    mimeType: string;
+    size: number;
+    attachmentId: string;
+};
+export type GmailTriggerMessage = {
+    id: string;
+    threadId: string;
+    labelIds: string[];
+    snippet: string;
+    sizeEstimate: number;
+    internalDate: string;
+    headers: {
+        from: string;
+        to: string;
+        cc: string;
+        bcc: string;
+        subject: string;
+        date: string;
+        messageId: string;
+    };
+    body: {
+        text: string;
+        html: string;
+    };
+    attachments: GmailTriggerAttachment[];
+    isUnread: true;
+};
+export declare class GmailTrigger extends Trigger {
+    collectPayload(input: any, config: any, agent: Agent): Promise<{
+        email: {
+            id: any;
+            threadId: any;
+            labelIds: any;
+            snippet: any;
+            sizeEstimate: any;
+            internalDate: string;
+            headers: {
+                from: any;
+                to: any;
+                cc: any;
+                bcc: any;
+                subject: any;
+                date: any;
+                messageId: any;
+            };
+            body: {
+                text: string;
+                html: string;
+            };
+            attachments: any[];
+            isUnread: any;
+        };
+    }[]>;
+}

package/dist/types/Components/Triggers/GmailTrigger.class.d.ts

@@ -0,0 +1,44 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Trigger } from './Trigger.class';
+export type GmailTriggerAttachment = {
+    filename: string;
+    mimeType: string;
+    size: number;
+    attachmentId: string;
+};
+export type GmailTriggerMessage = {
+    id: string;
+    threadId: string;
+    labelIds: string[];
+    snippet: string;
+    sizeEstimate: number;
+    internalDate: string;
+    headers: {
+        from: string;
+        to: string;
+        cc: string;
+        bcc: string;
+        subject: string;
+        date: string;
+        messageId: string;
+    };
+    body: {
+        text: string;
+        html: string;
+    };
+    attachments: GmailTriggerAttachment[];
+    isUnread: true;
+};
+export declare class GmailTrigger extends Trigger {
+    collectPayload(input: any, config: any, agent: Agent): Promise<{
+        message: {
+            id: string;
+            subject: string;
+            body: string;
+            from: string;
+            to: string;
+            date: string;
+            threadId: string;
+        };
+    }[]>;
+}

package/dist/types/Components/Triggers/Trigger.class.d.ts

@@ -0,0 +1,21 @@
+import { Agent } from '@sre/AgentManager/Agent.class';
+import { Component } from '../Component.class';
+import { LogHelper } from '@sre/helpers/Log.helper';
+export declare class Trigger extends Component {
+    protected logger: LogHelper;
+    process(input: any, settings: any, agent: Agent): Promise<any>;
+    protected collectPayload(input: any, settings: any, agent: Agent): Promise<any[]>;
+    requestHandler(input: any, settings: any, agent: Agent): Promise<any>;
+    protected processIteration(inputArray: any, settings: any, agent: any): Promise<{
+        Payload: {};
+        Result: any;
+        _temp_result: any;
+        _error: any;
+        _in_progress: boolean;
+        _debug: string;
+    }>;
+    postProcess(output: any, settings: any, agent: Agent): Promise<any>;
+    register(componentId: string, componentSettings: any, payload: {
+        triggerUrl: string;
+    }): Promise<void>;
+}

package/dist/types/Components/Triggers/WhatsApp.trigger.d.ts

@@ -0,0 +1,22 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Trigger } from './Trigger.class';
+type WhatsAppIncomingMessage = {
+    id?: string;
+    from?: string;
+    profileName?: string;
+    text?: string;
+    type?: string;
+    timestamp?: string;
+    phoneNumberId?: string;
+};
+export declare class WhatsAppTrigger extends Trigger {
+    collectPayload(input: any, settings: any, agent: Agent): Promise<{
+        message: WhatsAppIncomingMessage;
+    }[]>;
+    requestHandler(input: any, settings: any, agent: Agent): Promise<boolean>;
+    register(componentId: string, componentSettings: any, payload?: {
+        triggerUrl: string;
+    }): Promise<void>;
+    unregister(componentId: string, agent: Agent, payload?: any): Promise<void>;
+}
+export {};

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/subsystems/IO/Storage.service/connectors/AzureBlobStorage.class.d.ts

@@ -0,0 +1,211 @@
+import { StorageConnector } from '@sre/IO/Storage.service/StorageConnector';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { StorageData, StorageMetadata } from '@sre/types/Storage.types';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+export type AzureBlobConfig = {
+    storageAccountName: string;
+    storageAccountAccessKey: string;
+    blobContainerName: string;
+};
+export declare class AzureBlobStorage extends StorageConnector {
+    protected _settings: AzureBlobConfig;
+    name: string;
+    private blobServiceClient;
+    private containerClient;
+    private isInitialized;
+    private initializationPromise;
+    constructor(_settings: AzureBlobConfig);
+    private ensureInitialized;
+    private initialize;
+    /**
+     * Reads a blob's content from the Azure Storage container.
+     * This method fetches the entire blob content into a Buffer. If the specified
+     * blob does not exist, it gracefully returns undefined.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to be read from the container.
+     * @returns {Promise<StorageData | undefined>} A promise that resolves with the blob's content as a Buffer (`StorageData`), or undefined if the blob is not found.
+     * @throws Throws an error if any other issue occurs during the download process (e.g., network issues, permissions problems).
+     */
+    read(acRequest: AccessRequest, resourceId: string): Promise<StorageData | undefined>;
+    /**
+     * Writes or overwrites a blob in the Azure Storage container.
+     *
+     * This method uploads data to a specified blob. It automatically handles the SmythOS
+     * Access Control List (ACL) by ensuring the writer is made the owner of the object.
+     * Any provided metadata is merged with this ACL and stored with the blob.
+     * If a blob with the same `resourceId` already exists, this operation will completely replace its content and metadata.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to be written or overwritten.
+     * @param {StorageData} value - The content to be written to the blob, typically a Buffer.
+     * @param {IACL} [acl] - An optional Access Control List to apply to the blob. If not provided, a default ACL is generated.
+     * @param {StorageMetadata} [metadata] - Optional key-value metadata to associate with the blob, including properties like `ContentType`.
+     * @returns {Promise<void>} A promise that resolves when the upload operation is complete.
+     * @throws Throws an error if the upload fails due to network issues, invalid credentials, or other storage-related problems.
+     */
+    write(acRequest: AccessRequest, resourceId: string, value: StorageData, acl?: IACL, metadata?: StorageMetadata): Promise<void>;
+    /**
+     * Deletes a blob from the Azure Storage container.
+     *
+     * This method permanently removes the specified blob. The operation is idempotent,
+     * meaning it will complete successfully without error even if the blob does not
+     * already exist. This is useful for ensuring a resource is gone without needing to
+     * check for its existence first.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to be deleted.
+     * @returns {Promise<void>} A promise that resolves when the delete operation is complete.
+     * @throws Throws an error if the deletion fails for reasons other than the blob not existing (e.g., network issues, permissions problems).
+     */
+    delete(acRequest: AccessRequest, resourceId: string): Promise<void>;
+    /**
+     * Checks for the existence of a blob in the Azure Storage container.
+     *
+     * This method efficiently verifies if a blob with the specified `resourceId` is
+     * present without downloading its content. It's the most performant way to
+     * check for a blob's presence before performing other operations.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to check.
+     * @returns {Promise<boolean>} A promise that resolves with `true` if the blob exists, and `false` otherwise.
+     * @throws Throws an error for any issue other than the blob not being found (e.g., network issues, invalid credentials).
+     */
+    exists(acRequest: AccessRequest, resourceId: string): Promise<boolean>;
+    /**
+     * Retrieves the user-defined metadata for a specific blob.
+     *
+     * This method fetches the key-value metadata associated with a blob without
+     * downloading the blob's content. It's an efficient way to read custom
+     * information stored with an object. If the blob is not found, it returns undefined.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob whose metadata is to be retrieved.
+     * @returns {Promise<StorageMetadata | undefined>} A promise that resolves with the blob's metadata object, or undefined if the blob does not exist.
+     * @throws Throws an error for any issue other than the blob not being found (e.g., network issues, invalid credentials).
+     */
+    getMetadata(acRequest: AccessRequest, resourceId: string): Promise<StorageMetadata | undefined>;
+    /**
+     * Sets or updates the user-defined metadata for a specific blob.
+     *
+     * This method applies new metadata to an existing blob. It performs a "merge and
+     * update" operation: it first reads the blob's current metadata, then merges
+     * the provided metadata with it (new values overwrite existing ones).
+     * This operation does not affect the blob's content.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob whose metadata is to be updated.
+     * @param {StorageMetadata} metadata - An object containing the key-value pairs to set. These will be merged with any existing metadata.
+     * @returns {Promise<void>} A promise that resolves when the metadata has been successfully updated.
+     * @throws Throws an error if the blob does not exist, or if the update fails for other reasons (e.g., network issues).
+     */
+    setMetadata(acRequest: AccessRequest, resourceId: string, metadata: StorageMetadata): Promise<void>;
+    /**
+     * Retrieves the Access Control List (ACL) for a specific blob.
+     *
+     * This method fetches the blob's metadata and specifically extracts the
+     * SmythOS-native ACL object. It provides a direct way to inspect the
+     * permissions of a blob without downloading its content.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob whose ACL is to be retrieved.
+     * @returns {Promise<ACL | undefined>} A promise that resolves with the `ACL` object for the blob. Returns undefined if the blob does not exist or has no ACL.
+     * @throws Throws an error for any issue other than the blob not being found (e.g., network issues, invalid credentials).
+     */
+    getACL(acRequest: AccessRequest, resourceId: string): Promise<ACL | undefined>;
+    /**
+     * Sets or updates the Access Control List (ACL) for a specific blob.
+     *
+     * This method applies a new SmythOS ACL to an existing blob. It reads the blob's
+     * full metadata, replaces the ACL portion, and writes the updated metadata back.
+     * A crucial security feature of this method is that it automatically ensures the
+     * user/agent making the request always retains ownership of the blob.
+     *
+     * @param {AccessRequest} acRequest - The access request object, used to identify the user/agent to ensure they retain ownership.
+     * @param {string} resourceId - The unique identifier (name) of the blob whose ACL is to be updated.
+     * @param {IACL} acl - The new Access Control List object to apply to the blob.
+     * @returns {Promise<void>} A promise that resolves when the ACL has been successfully updated.
+     * @throws Throws an error if the blob does not exist or if the update fails for other reasons.
+     */
+    setACL(acRequest: AccessRequest, resourceId: string, acl: IACL): Promise<void>;
+    /**
+     * Determines the effective Access Control List (ACL) for a given resource.
+     *
+     * This crucial security method is called by the access control system to fetch a
+     * resource's ACL before making an authorization decision. If the resource does
+     * not exist (and thus has no ACL), this method dynamically generates a new ACL
+     * that grants 'Owner' access to the requesting candidate. This is the mechanism
+     * that allows authorized users to create new resources.
+     *
+     * @param {string} resourceId - The unique identifier (name) of the blob whose ACL is to be determined.
+     * @param {IAccessCandidate} candidate - The user or agent attempting to access the resource, used to grant ownership if the resource is new.
+     * @returns {Promise<ACL>} A promise that resolves with the existing ACL object if the blob is found, or a new ACL object granting ownership if the blob does not exist.
+     * @throws Throws an error if there is an unexpected issue fetching the blob's metadata (e.g., network issues).
+     */
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    /**
+     * Schedules a blob for automatic deletion after a specified time-to-live (TTL).
+     *
+     * This method applies a Blob Index Tag ('deleteAfterDays') to an existing blob.
+     * It does not delete the blob immediately. Instead, it relies on a pre-configured
+     * Lifecycle Management rule on the Azure Storage Account to automatically delete the
+     * blob after the specified number of days.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to schedule for deletion.
+     * @param {number} ttl - The time-to-live for the blob, in seconds. Must be a positive number.
+     * @returns {Promise<void>} A promise that resolves when the expiration tag has been successfully applied.
+     * @throws Throws an error if the blob does not exist, if the TTL is invalid, or if applying the tag fails.
+     */
+    expire(acRequest: AccessRequest, resourceId: string, ttl: number): Promise<void>;
+    /**
+     * Migrates legacy ACL metadata to the new structured format.
+     *
+     * This internal helper function checks for an outdated ACL format where permissions
+     * were stored in separate keys like `userid`, `teamid`, or `agentid`. If found,
+     * it converts them into the modern, structured `azure-acl` object, granting full
+     * ownership. This ensures seamless backward compatibility with older data.
+     *
+     * @param {Record<string, string>} metadata - The raw metadata object which may contain legacy ACL keys.
+     * @returns {Record<string, any>} The metadata object, with legacy keys converted into a new `azure-acl` property.
+     * @private
+     */
+    private _migrateMetadata;
+    /**
+     * Serializes the internal metadata object into a format compatible with Azure Blob Storage.
+     *
+     * This internal helper prepares the metadata for upload. It converts the `ACL` object
+     * into its serialized string representation and stringifies any other non-string
+     * metadata values. The `ContentType` property is intentionally excluded as it's
+     * handled separately in the blob's HTTP headers.
+     *
+     * @param {Record<string, any>} metadata - The internal metadata object, containing mixed-type values.
+     * @returns {Record<string, string>} A flat key-value object where all values are strings.
+     * @private
+     */
+    private _serializeAzureMetadata;
+    /**
+     * Deserializes a flat metadata object from Azure into the rich internal format.
+     *
+     * This internal helper processes the raw string-based metadata retrieved from a blob.
+     * It reconstructs the `ACL` object from its string representation and parses any
+     * other JSON-stringified values back into their original object/data types. It then
+     * calls the migration helper to ensure backward compatibility with legacy ACL formats.
+     *
+     * @param {Record<string, string>} metadata - The flat, string-only key-value metadata from the Azure SDK.
+     * @returns {Record<string, any>} The rich internal metadata object with complex data types restored.
+     * @private
+     */
+    private _deserializeAzureMetadata;
+    /**
+     * Private helper to fetch and deserialize metadata from Azure.
+     * @private
+     */
+    private _getAzureMetadata;
+    /**
+     * Private helper to serialize and write metadata to Azure.
+     * @private
+     */
+    private _setAzureMetadata;
+}