@bluefly/openstandardagents 0.5.0 → 0.5.3

package/dist/messenger/EventSubscriber/FailedMessageSubscriber.js

@@ -1,64 +0,0 @@
-/**
- * Event subscriber for failed messages
- *
- * This subscriber listens for message failure events and handles
- * logging, notification, and storage of failed messages.
- *
- * @package @bluefly/openstandardagents
- * @since 0.5.0
- */
-export class FailedMessageSubscriber {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    /**
-     * Handle message failed event
-     */
-    async onMessageFailed(event) {
-        const { message, error, envelope, willRetry, retryCount } = event;
-        // Log the failure
-        if (willRetry) {
-            this.deps.logger.warning('Message failed, will retry', {
-                messageId: envelope.messageId,
-                retryCount,
-                error: error.message,
-            });
-        }
-        else {
-            this.deps.logger.error('Message permanently failed', error, {
-                messageId: envelope.messageId,
-                retryCount,
-            });
-        }
-        // Store in failed_jobs table (even for retries, for tracking)
-        try {
-            await this.deps.failedJobStorage.store(envelope.messageId, message, error, retryCount);
-        }
-        catch (storageError) {
-            this.deps.logger.error('Failed to store failed message', storageError, {
-                messageId: envelope.messageId,
-            });
-        }
-        // Send notification only for permanent failures
-        if (!willRetry) {
-            try {
-                await this.deps.notifier.notifyFailure(message, error, retryCount);
-            }
-            catch (notificationError) {
-                this.deps.logger.error('Failed to send failure notification', notificationError, {
-                    messageId: envelope.messageId,
-                });
-            }
-        }
-    }
-    /**
-     * Get subscribed events
-     */
-    static getSubscribedEvents() {
-        return {
-            'messenger.message_failed': 'onMessageFailed',
-        };
-    }
-}
-//# sourceMappingURL=FailedMessageSubscriber.js.map

package/dist/messenger/Handler/AgentBatchHandler.d.ts

@@ -1,80 +0,0 @@
-/**
- * Message handler for batch agent execution
- *
- * This handler processes AgentBatchMessage messages and executes
- * multiple OSSA agents either in parallel or sequentially.
- *
- * @package @bluefly/openstandardagents
- * @since 0.5.0
- */
-import type { AgentBatchMessage } from '../Message/AgentBatchMessage.js';
-import type { AgentExecutionResult } from './AgentExecutionHandler.js';
-import type { OssaAgent } from '../../types/index.js';
-export interface BatchExecutionResult {
-    success: boolean;
-    results: Record<string, AgentExecutionResult>;
-    metadata: {
-        totalAgents: number;
-        successCount: number;
-        failureCount: number;
-        startTime: string;
-        endTime: string;
-        duration: number;
-    };
-}
-export interface AgentBatchHandlerDependencies {
-    /**
-     * Agent runtime for executing OSSA agents
-     */
-    agentRuntime: {
-        loadAgent(agentId: string): Promise<OssaAgent>;
-        executeAgent(agent: OssaAgent, input: Record<string, unknown>): Promise<unknown>;
-    };
-    /**
-     * Result storage for persisting batch results
-     */
-    resultStorage: {
-        store(batchId: string, result: BatchExecutionResult): Promise<void>;
-    };
-    /**
-     * Event dispatcher for triggering events
-     */
-    eventDispatcher: {
-        dispatch(eventName: string, data: unknown): Promise<void>;
-    };
-    /**
-     * Logger for batch tracking
-     */
-    logger: {
-        info(message: string, context?: Record<string, unknown>): void;
-        error(message: string, error?: Error, context?: Record<string, unknown>): void;
-        debug(message: string, context?: Record<string, unknown>): void;
-    };
-    /**
-     * Optional callback handler for batch notifications
-     */
-    callbackHandler?: {
-        notify(url: string, result: BatchExecutionResult): Promise<void>;
-    };
-}
-export declare class AgentBatchHandler {
-    private readonly deps;
-    constructor(deps: AgentBatchHandlerDependencies);
-    /**
-     * Handle batch execution message
-     */
-    handle(message: AgentBatchMessage): Promise<void>;
-    /**
-     * Execute agents in parallel
-     */
-    private executeParallel;
-    /**
-     * Execute agents sequentially
-     */
-    private executeSequential;
-    /**
-     * Execute a single agent
-     */
-    private executeSingleAgent;
-}
-//# sourceMappingURL=AgentBatchHandler.d.ts.map

package/dist/messenger/Handler/AgentBatchHandler.js

@@ -1,211 +0,0 @@
-/**
- * Message handler for batch agent execution
- *
- * This handler processes AgentBatchMessage messages and executes
- * multiple OSSA agents either in parallel or sequentially.
- *
- * @package @bluefly/openstandardagents
- * @since 0.5.0
- */
-export class AgentBatchHandler {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    /**
-     * Handle batch execution message
-     */
-    async handle(message) {
-        const startTime = new Date().toISOString();
-        const agentIds = message.getAgentIds();
-        const context = message.getContext();
-        this.deps.logger.info('Starting batch agent execution', {
-            agentCount: agentIds.length,
-            mode: message.getOptions().mode,
-            userId: context.userId,
-            sessionId: context.sessionId,
-        });
-        try {
-            let results;
-            if (message.isParallel()) {
-                results = await this.executeParallel(message);
-            }
-            else {
-                results = await this.executeSequential(message);
-            }
-            const endTime = new Date().toISOString();
-            const duration = new Date(endTime).getTime() - new Date(startTime).getTime();
-            // Count successes and failures
-            const successCount = Object.values(results).filter((r) => r.success).length;
-            const failureCount = agentIds.length - successCount;
-            const batchResult = {
-                success: failureCount === 0,
-                results,
-                metadata: {
-                    totalAgents: agentIds.length,
-                    successCount,
-                    failureCount,
-                    startTime,
-                    endTime,
-                    duration,
-                },
-            };
-            // Store batch result
-            const batchId = context.requestId ?? `batch-${Date.now()}`;
-            await this.deps.resultStorage.store(batchId, batchResult);
-            // Dispatch completion event
-            await this.deps.eventDispatcher.dispatch('agent.batch.complete', {
-                batchResult,
-                context,
-            });
-            // Send callback if specified
-            const callbackUrl = message.getCallbackUrl();
-            if (callbackUrl && this.deps.callbackHandler) {
-                await this.deps.callbackHandler.notify(callbackUrl, batchResult);
-            }
-            this.deps.logger.info('Batch execution completed', {
-                totalAgents: agentIds.length,
-                successCount,
-                failureCount,
-                duration,
-            });
-            // Throw if any failures and stopOnError is true
-            if (failureCount > 0 && message.shouldStopOnError()) {
-                throw new Error(`Batch execution failed: ${failureCount} agent(s) failed`);
-            }
-        }
-        catch (error) {
-            this.deps.logger.error('Batch execution failed', error, {
-                agentCount: agentIds.length,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Execute agents in parallel
-     */
-    async executeParallel(message) {
-        const agentIds = message.getAgentIds();
-        const maxParallel = message.getOptions().maxParallel ?? agentIds.length;
-        this.deps.logger.debug('Executing agents in parallel', {
-            total: agentIds.length,
-            maxParallel,
-        });
-        const results = {};
-        // Execute in chunks
-        for (let i = 0; i < agentIds.length; i += maxParallel) {
-            const chunk = agentIds.slice(i, i + maxParallel);
-            const chunkPromises = chunk.map((agentId) => this.executeSingleAgent(agentId, message.getInputForAgent(agentId)));
-            const chunkResults = await Promise.allSettled(chunkPromises);
-            chunk.forEach((agentId, index) => {
-                const result = chunkResults[index];
-                if (result.status === 'fulfilled') {
-                    results[agentId] = result.value;
-                }
-                else {
-                    results[agentId] = {
-                        success: false,
-                        error: {
-                            message: result.reason?.message ?? 'Unknown error',
-                            code: 'EXECUTION_FAILED',
-                        },
-                        metadata: {
-                            agentId,
-                            startTime: new Date().toISOString(),
-                            endTime: new Date().toISOString(),
-                            duration: 0,
-                        },
-                    };
-                }
-            });
-        }
-        return results;
-    }
-    /**
-     * Execute agents sequentially
-     */
-    async executeSequential(message) {
-        const agentIds = message.getAgentIds();
-        const results = {};
-        this.deps.logger.debug('Executing agents sequentially', {
-            total: agentIds.length,
-        });
-        for (const agentId of agentIds) {
-            try {
-                const result = await this.executeSingleAgent(agentId, message.getInputForAgent(agentId));
-                results[agentId] = result;
-                // Stop on error if requested
-                if (!result.success && message.shouldStopOnError()) {
-                    this.deps.logger.info('Stopping batch execution due to error', {
-                        agentId,
-                    });
-                    break;
-                }
-            }
-            catch (error) {
-                results[agentId] = {
-                    success: false,
-                    error: {
-                        message: error instanceof Error ? error.message : String(error),
-                        code: 'EXECUTION_FAILED',
-                    },
-                    metadata: {
-                        agentId,
-                        startTime: new Date().toISOString(),
-                        endTime: new Date().toISOString(),
-                        duration: 0,
-                    },
-                };
-                // Stop on error if requested
-                if (message.shouldStopOnError()) {
-                    this.deps.logger.info('Stopping batch execution due to error', {
-                        agentId,
-                    });
-                    break;
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Execute a single agent
-     */
-    async executeSingleAgent(agentId, input) {
-        const startTime = new Date().toISOString();
-        try {
-            const agent = await this.deps.agentRuntime.loadAgent(agentId);
-            const output = await this.deps.agentRuntime.executeAgent(agent, input);
-            const endTime = new Date().toISOString();
-            const duration = new Date(endTime).getTime() - new Date(startTime).getTime();
-            return {
-                success: true,
-                output,
-                metadata: {
-                    agentId,
-                    startTime,
-                    endTime,
-                    duration,
-                },
-            };
-        }
-        catch (error) {
-            const endTime = new Date().toISOString();
-            const duration = new Date(endTime).getTime() - new Date(startTime).getTime();
-            return {
-                success: false,
-                error: {
-                    message: error instanceof Error ? error.message : String(error),
-                    code: 'EXECUTION_FAILED',
-                    stack: error instanceof Error ? error.stack : undefined,
-                },
-                metadata: {
-                    agentId,
-                    startTime,
-                    endTime,
-                    duration,
-                },
-            };
-        }
-    }
-}
-//# sourceMappingURL=AgentBatchHandler.js.map

package/dist/messenger/Handler/AgentExecutionHandler.d.ts

@@ -1,76 +0,0 @@
-/**
- * Message handler for agent execution
- *
- * This handler processes AgentExecutionMessage messages and executes
- * OSSA agents asynchronously. It integrates with the agent runtime,
- * handles errors, stores results, and triggers events.
- *
- * @package @bluefly/openstandardagents
- * @since 0.5.0
- */
-import type { AgentExecutionMessage } from '../Message/AgentExecutionMessage.js';
-import type { OssaAgent } from '../../types/index.js';
-export interface AgentExecutionResult {
-    success: boolean;
-    output?: unknown;
-    error?: {
-        message: string;
-        code: string;
-        stack?: string;
-    };
-    metadata: {
-        agentId: string;
-        startTime: string;
-        endTime: string;
-        duration: number;
-        tokenUsage?: {
-            input: number;
-            output: number;
-            total: number;
-        };
-    };
-}
-export interface AgentExecutionHandlerDependencies {
-    /**
-     * Agent runtime for executing OSSA agents
-     */
-    agentRuntime: {
-        loadAgent(agentId: string): Promise<OssaAgent>;
-        executeAgent(agent: OssaAgent, input: Record<string, unknown>): Promise<unknown>;
-    };
-    /**
-     * Result storage for persisting execution results
-     */
-    resultStorage: {
-        store(messageId: string, result: AgentExecutionResult): Promise<void>;
-    };
-    /**
-     * Event dispatcher for triggering events
-     */
-    eventDispatcher: {
-        dispatch(eventName: string, data: unknown): Promise<void>;
-    };
-    /**
-     * Logger for execution tracking
-     */
-    logger: {
-        info(message: string, context?: Record<string, unknown>): void;
-        error(message: string, error?: Error, context?: Record<string, unknown>): void;
-        debug(message: string, context?: Record<string, unknown>): void;
-    };
-    /**
-     * Optional callback handler for async notifications
-     */
-    callbackHandler?: {
-        notify(url: string, result: AgentExecutionResult): Promise<void>;
-    };
-}
-export declare class AgentExecutionHandler {
-    private readonly deps;
-    constructor(deps: AgentExecutionHandlerDependencies);
-    /**
-     * Handle agent execution message
-     */
-    handle(message: AgentExecutionMessage): Promise<void>;
-}
-//# sourceMappingURL=AgentExecutionHandler.d.ts.map

package/dist/messenger/Handler/AgentExecutionHandler.js

@@ -1,131 +0,0 @@
-/**
- * Message handler for agent execution
- *
- * This handler processes AgentExecutionMessage messages and executes
- * OSSA agents asynchronously. It integrates with the agent runtime,
- * handles errors, stores results, and triggers events.
- *
- * @package @bluefly/openstandardagents
- * @since 0.5.0
- */
-export class AgentExecutionHandler {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    /**
-     * Handle agent execution message
-     */
-    async handle(message) {
-        const startTime = new Date().toISOString();
-        const agentId = message.getAgentId();
-        const input = message.getInput();
-        const context = message.getContext();
-        this.deps.logger.info('Starting agent execution', {
-            agentId,
-            userId: context.userId,
-            sessionId: context.sessionId,
-            requestId: context.requestId,
-        });
-        try {
-            // Load agent manifest
-            const agent = await this.deps.agentRuntime.loadAgent(agentId);
-            this.deps.logger.debug('Agent loaded successfully', {
-                agentId,
-                agentName: agent.metadata?.name,
-            });
-            // Execute agent
-            const output = await this.deps.agentRuntime.executeAgent(agent, input);
-            const endTime = new Date().toISOString();
-            const duration = new Date(endTime).getTime() - new Date(startTime).getTime();
-            // Build success result
-            const result = {
-                success: true,
-                output,
-                metadata: {
-                    agentId,
-                    startTime,
-                    endTime,
-                    duration,
-                },
-            };
-            // Store result
-            await this.deps.resultStorage.store(context.requestId ?? agentId, result);
-            // Dispatch success event
-            await this.deps.eventDispatcher.dispatch('agent.execution.success', {
-                agentId,
-                result,
-                context,
-            });
-            // Send callback if specified
-            const callbackUrl = message.getCallbackUrl();
-            if (callbackUrl && this.deps.callbackHandler) {
-                await this.deps.callbackHandler.notify(callbackUrl, result);
-            }
-            this.deps.logger.info('Agent execution completed successfully', {
-                agentId,
-                duration,
-                hasOutput: !!output,
-            });
-        }
-        catch (error) {
-            const endTime = new Date().toISOString();
-            const duration = new Date(endTime).getTime() - new Date(startTime).getTime();
-            const errorResult = {
-                success: false,
-                error: {
-                    message: error instanceof Error ? error.message : String(error),
-                    code: 'EXECUTION_FAILED',
-                    stack: error instanceof Error ? error.stack : undefined,
-                },
-                metadata: {
-                    agentId,
-                    startTime,
-                    endTime,
-                    duration,
-                },
-            };
-            // Store error result
-            try {
-                await this.deps.resultStorage.store(context.requestId ?? agentId, errorResult);
-            }
-            catch (storageError) {
-                this.deps.logger.error('Failed to store error result', storageError, {
-                    agentId,
-                });
-            }
-            // Dispatch failure event
-            try {
-                await this.deps.eventDispatcher.dispatch('agent.execution.failure', {
-                    agentId,
-                    error: errorResult.error,
-                    context,
-                });
-            }
-            catch (eventError) {
-                this.deps.logger.error('Failed to dispatch failure event', eventError, {
-                    agentId,
-                });
-            }
-            // Send callback with error if specified
-            const callbackUrl = message.getCallbackUrl();
-            if (callbackUrl && this.deps.callbackHandler) {
-                try {
-                    await this.deps.callbackHandler.notify(callbackUrl || '', errorResult);
-                }
-                catch (callbackError) {
-                    this.deps.logger.error('Failed to send error callback', callbackError, {
-                        agentId,
-                    });
-                }
-            }
-            this.deps.logger.error('Agent execution failed', error, {
-                agentId,
-                duration,
-            });
-            // Re-throw to mark message as failed (will trigger retry)
-            throw error;
-        }
-    }
-}
-//# sourceMappingURL=AgentExecutionHandler.js.map

package/dist/messenger/Handler/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Messenger handlers
- *
- * @package @bluefly/openstandardagents
- * @since 0.5.0
- */
-export { AgentExecutionHandler, type AgentExecutionHandlerDependencies, type AgentExecutionResult, } from './AgentExecutionHandler.js';
-export { AgentBatchHandler, type AgentBatchHandlerDependencies, type BatchExecutionResult, } from './AgentBatchHandler.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/messenger/Handler/index.js

@@ -1,9 +0,0 @@
-/**
- * Messenger handlers
- *
- * @package @bluefly/openstandardagents
- * @since 0.5.0
- */
-export { AgentExecutionHandler, } from './AgentExecutionHandler.js';
-export { AgentBatchHandler, } from './AgentBatchHandler.js';
-//# sourceMappingURL=index.js.map

package/dist/messenger/Message/AgentBatchMessage.d.ts

@@ -1,115 +0,0 @@
-/**
- * Message for batch agent execution
- *
- * This message is dispatched to execute multiple agents in parallel or sequence.
- * It supports batch processing with optional ordering and dependency management.
- *
- * @package @bluefly/openstandardagents
- * @since 0.5.0
- */
-export interface AgentBatchMessageData {
-    /**
-     * List of agent IDs to execute
-     */
-    agentIds: string[];
-    /**
-     * Input data for each agent (indexed by agent ID)
-     * If not specified, same input will be used for all agents
-     */
-    inputs: Record<string, Record<string, unknown>>;
-    /**
-     * Batch execution options
-     */
-    options: {
-        /**
-         * Execution mode: parallel or sequential
-         */
-        mode: 'parallel' | 'sequential';
-        /**
-         * Maximum parallel executions (for parallel mode)
-         */
-        maxParallel?: number;
-        /**
-         * Stop on first error
-         */
-        stopOnError?: boolean;
-        /**
-         * Aggregate results
-         */
-        aggregateResults?: boolean;
-        /**
-         * Timeout for entire batch in milliseconds
-         */
-        batchTimeout?: number;
-    };
-    /**
-     * Shared context for all agents
-     */
-    context: {
-        userId?: string;
-        sessionId?: string;
-        requestId?: string;
-        metadata?: Record<string, unknown>;
-    };
-    /**
-     * Optional callback URL for batch completion
-     */
-    callbackUrl?: string;
-    /**
-     * Timestamp when message was created
-     */
-    timestamp: string;
-}
-export declare class AgentBatchMessage {
-    private readonly agentIds;
-    private readonly inputs;
-    private readonly options;
-    private readonly context;
-    private readonly callbackUrl?;
-    constructor(agentIds: string[], inputs: Record<string, Record<string, unknown>>, options?: AgentBatchMessageData['options'], context?: AgentBatchMessageData['context'], callbackUrl?: string | undefined);
-    /**
-     * Get the agent IDs
-     */
-    getAgentIds(): string[];
-    /**
-     * Get inputs for a specific agent
-     */
-    getInputForAgent(agentId: string): Record<string, unknown>;
-    /**
-     * Get all inputs
-     */
-    getInputs(): Record<string, Record<string, unknown>>;
-    /**
-     * Get batch options
-     */
-    getOptions(): AgentBatchMessageData['options'];
-    /**
-     * Get execution context
-     */
-    getContext(): AgentBatchMessageData['context'];
-    /**
-     * Get callback URL
-     */
-    getCallbackUrl(): string | undefined;
-    /**
-     * Check if execution should be parallel
-     */
-    isParallel(): boolean;
-    /**
-     * Check if execution should stop on error
-     */
-    shouldStopOnError(): boolean;
-    /**
-     * Get number of agents in batch
-     */
-    getCount(): number;
-    /**
-     * Serialize to JSON
-     */
-    toJSON(): AgentBatchMessageData;
-    /**
-     * Deserialize from JSON
-     */
-    static fromJSON(data: AgentBatchMessageData): AgentBatchMessage;
-}
-//# sourceMappingURL=AgentBatchMessage.d.ts.map