@bluefly/openstandardagents 0.5.1 → 0.5.3

package/dist/adapters/a2a/delegation.js

@@ -1,236 +0,0 @@
-/**
- * Task Delegation Service
- *
- * Intelligent task delegation between agents with SLA negotiation
- * and execution monitoring
- *
- * @module adapters/a2a/delegation
- */
-/**
- * Delegation Service
- * Handles intelligent task delegation between agents
- */
-export class DelegationService {
-    delegations = new Map();
-    slas = new Map();
-    executions = new Map();
-    violations = new Map();
-    /**
-     * Delegate task to most capable agent
-     */
-    async delegate(task, constraints, agents) {
-        // Find suitable agents
-        const suitableAgents = this.findSuitableAgents(task, constraints, agents);
-        if (suitableAgents.length === 0) {
-            throw new Error('No suitable agents found for task delegation');
-        }
-        // Score each agent
-        const scoredAgents = suitableAgents.map((agent) => ({
-            agent,
-            score: this.scoreAgent(agent, task, constraints),
-        }));
-        // Sort by score (descending)
-        scoredAgents.sort((a, b) => b.score - a.score);
-        // Select best agent
-        const bestAgent = scoredAgents[0].agent;
-        // Negotiate SLA
-        const sla = await this.negotiateSLA(task, bestAgent);
-        // Create delegation
-        const delegation = {
-            id: crypto.randomUUID(),
-            taskId: task.id,
-            agent: bestAgent,
-            sla,
-            score: scoredAgents[0].score,
-            estimatedCompletion: this.calculateEstimatedCompletion(task, bestAgent),
-            status: 'pending',
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        };
-        this.delegations.set(delegation.id, delegation);
-        this.slas.set(sla.id, sla);
-        // Initialize execution status
-        const execution = {
-            delegationId: delegation.id,
-            taskId: task.id,
-            state: 'queued',
-            progress: 0,
-        };
-        this.executions.set(delegation.id, execution);
-        return delegation;
-    }
-    /**
-     * Negotiate SLA between agents
-     */
-    async negotiateSLA(task, agent) {
-        const slaId = crypto.randomUUID();
-        // Calculate SLA terms based on agent capabilities and task requirements
-        const availability = Math.min(agent.metrics.successRate, 0.999);
-        const responseTime = agent.metrics.avgCompletionTime * 1.2; // 20% buffer
-        const throughput = 1 / (agent.metrics.avgCompletionTime / 1000); // tasks per second
-        const errorRate = 1 - agent.metrics.successRate;
-        const cost = this.calculateCost(task, agent);
-        const sla = {
-            id: slaId,
-            taskId: task.id,
-            provider: agent.identity,
-            consumer: {
-                id: 'consumer',
-                namespace: 'default',
-                name: 'consumer',
-                uri: 'uadp://default/consumer',
-                capabilities: [],
-                version: '1.0.0',
-            },
-            availability,
-            responseTime,
-            throughput,
-            errorRate,
-            cost,
-            startTime: new Date().toISOString(),
-            endTime: new Date(Date.now() + 86400000).toISOString(), // 24 hours
-            penalties: {
-                availabilityPenalty: cost * 0.1,
-                responseTimePenalty: cost * 0.05,
-                errorRatePenalty: cost * 0.15,
-            },
-            status: 'active',
-        };
-        return sla;
-    }
-    /**
-     * Monitor delegated task execution
-     */
-    monitor(delegationId) {
-        const execution = this.executions.get(delegationId);
-        if (!execution) {
-            throw new Error(`Execution not found: ${delegationId}`);
-        }
-        // Check for SLA violations
-        this.checkSLAViolations(delegationId);
-        return execution;
-    }
-    /**
-     * Update execution status
-     */
-    updateExecution(delegationId, updates) {
-        const execution = this.executions.get(delegationId);
-        if (!execution) {
-            throw new Error(`Execution not found: ${delegationId}`);
-        }
-        Object.assign(execution, updates);
-        // Update delegation status
-        const delegation = this.delegations.get(delegationId);
-        if (delegation) {
-            if (execution.state === 'completed') {
-                delegation.status = 'completed';
-            }
-            else if (execution.state === 'failed') {
-                delegation.status = 'failed';
-            }
-            else if (execution.state === 'running') {
-                delegation.status = 'executing';
-            }
-            delegation.updatedAt = new Date().toISOString();
-        }
-        // Check for SLA violations
-        this.checkSLAViolations(delegationId);
-    }
-    /**
-     * Get delegation by ID
-     */
-    getDelegation(delegationId) {
-        return this.delegations.get(delegationId);
-    }
-    /**
-     * Get all delegations
-     */
-    getAllDelegations() {
-        return Array.from(this.delegations.values());
-    }
-    /**
-     * Get SLA violations
-     */
-    getViolations(slaId) {
-        return this.violations.get(slaId) || [];
-    }
-    // Private helper methods
-    findSuitableAgents(task, constraints, agents) {
-        return agents.filter((agent) => {
-            // Check capabilities
-            const hasCapabilities = task.capabilities.every((cap) => agent.capabilities.includes(cap));
-            // Check availability
-            const isAvailable = agent.status === 'available';
-            // Check SLA requirement
-            const meetsSLA = !constraints.minSLA || agent.metrics.successRate >= constraints.minSLA;
-            // Check capacity
-            const hasCapacity = agent.capacity > 0.1;
-            return hasCapabilities && isAvailable && meetsSLA && hasCapacity;
-        });
-    }
-    scoreAgent(agent, task, constraints) {
-        let score = 0;
-        // Success rate (0-0.4)
-        score += agent.metrics.successRate * 0.4;
-        // Capacity (0-0.3)
-        score += agent.capacity * 0.3;
-        // Performance (0-0.2)
-        const performanceScore = 1 - Math.min(agent.metrics.avgCompletionTime / 300000, 1); // Normalize to 5 min
-        score += performanceScore * 0.2;
-        // Load (0-0.1) - prefer less loaded
-        score += (1 - agent.load) * 0.1;
-        return Math.min(score, 1);
-    }
-    calculateCost(task, agent) {
-        // Simple cost calculation (can be enhanced)
-        const baseCost = 10;
-        const complexityMultiplier = task.capabilities.length;
-        const performanceMultiplier = agent.metrics.avgCompletionTime / 60000; // per minute
-        return baseCost * complexityMultiplier * performanceMultiplier;
-    }
-    calculateEstimatedCompletion(task, agent) {
-        const estimatedDuration = agent.metrics.avgCompletionTime * 1.2; // 20% buffer
-        const completionTime = new Date(Date.now() + estimatedDuration);
-        return completionTime.toISOString();
-    }
-    checkSLAViolations(delegationId) {
-        const delegation = this.delegations.get(delegationId);
-        const execution = this.executions.get(delegationId);
-        const sla = delegation ? this.slas.get(delegation.sla.id) : undefined;
-        if (!delegation || !execution || !sla) {
-            return;
-        }
-        const violations = [];
-        // Check response time violation
-        if (execution.duration && execution.duration > sla.responseTime) {
-            violations.push({
-                id: crypto.randomUUID(),
-                slaId: sla.id,
-                type: 'response-time',
-                severity: 'medium',
-                actualValue: execution.duration,
-                expectedValue: sla.responseTime,
-                timestamp: new Date().toISOString(),
-                penalty: sla.penalties?.responseTimePenalty,
-            });
-        }
-        // Check error rate violation (if failed)
-        if (execution.state === 'failed') {
-            violations.push({
-                id: crypto.randomUUID(),
-                slaId: sla.id,
-                type: 'error-rate',
-                severity: 'high',
-                actualValue: 1,
-                expectedValue: sla.errorRate,
-                timestamp: new Date().toISOString(),
-                penalty: sla.penalties?.errorRatePenalty,
-            });
-        }
-        if (violations.length > 0) {
-            sla.status = 'violated';
-            this.violations.set(sla.id, violations);
-        }
-    }
-}
-//# sourceMappingURL=delegation.js.map

package/dist/adapters/a2a/index.d.ts

@@ -1,18 +0,0 @@
-/**
- * A2A (Agent-to-Agent) Communication System
- *
- * Revolutionary multi-agent orchestration system that extends MCP protocol
- * with swarm intelligence, service mesh, and intelligent delegation.
- *
- * Architectural inspiration from Symfony MCP Bundle and PHP Foundation
- * MCP SDK collaboration.
- *
- * @module adapters/a2a
- */
-export * from './a2a-protocol.js';
-export * from './mcp-integration.js';
-export * from './swarm-orchestration.js';
-export * from './agent-mesh.js';
-export * from './delegation.js';
-export * from './a2a-tool.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/adapters/a2a/index.js

@@ -1,24 +0,0 @@
-/**
- * A2A (Agent-to-Agent) Communication System
- *
- * Revolutionary multi-agent orchestration system that extends MCP protocol
- * with swarm intelligence, service mesh, and intelligent delegation.
- *
- * Architectural inspiration from Symfony MCP Bundle and PHP Foundation
- * MCP SDK collaboration.
- *
- * @module adapters/a2a
- */
-// Protocol and types
-export * from './a2a-protocol.js';
-// MCP integration
-export * from './mcp-integration.js';
-// Swarm orchestration
-export * from './swarm-orchestration.js';
-// Agent mesh
-export * from './agent-mesh.js';
-// Delegation service
-export * from './delegation.js';
-// A2A tool
-export * from './a2a-tool.js';
-//# sourceMappingURL=index.js.map

package/dist/adapters/a2a/mcp-integration.d.ts

@@ -1,259 +0,0 @@
-/**
- * MCP (Model Context Protocol) Integration
- *
- * Integrates OSSA A2A protocol with MCP specification
- * Enables cross-language agent communication (TypeScript ↔ PHP ↔ Python)
- *
- * References:
- * - MCP Spec: https://spec.modelcontextprotocol.io/
- * - Symfony MCP Bundle: https://github.com/symfony/mcp-bundle
- * - PHP MCP SDK: https://github.com/modelcontextprotocol/php-sdk
- *
- * @module adapters/a2a/mcp-integration
- */
-import type { AgentIdentity, A2AMessage } from './a2a-protocol.js';
-/**
- * MCP Protocol Version
- */
-export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
-/**
- * MCP Message Types
- */
-export declare enum MCPMessageType {
-    /** Initialize connection */
-    INITIALIZE = "initialize",
-    /** Initialized response */
-    INITIALIZED = "initialized",
-    /** List resources */
-    RESOURCES_LIST = "resources/list",
-    /** Read resource */
-    RESOURCES_READ = "resources/read",
-    /** List prompts */
-    PROMPTS_LIST = "prompts/list",
-    /** Get prompt */
-    PROMPTS_GET = "prompts/get",
-    /** List tools */
-    TOOLS_LIST = "tools/list",
-    /** Call tool */
-    TOOLS_CALL = "tools/call",
-    /** Ping */
-    PING = "ping",
-    /** Notification */
-    NOTIFICATION = "notification"
-}
-/**
- * MCP Resource
- * Represents data/content exposed by an MCP server
- */
-export interface MCPResource {
-    /** Resource URI */
-    uri: string;
-    /** Resource name */
-    name: string;
-    /** Resource description */
-    description?: string;
-    /** MIME type */
-    mimeType?: string;
-    /** Resource metadata */
-    metadata?: Record<string, unknown>;
-}
-/**
- * MCP Prompt
- * Represents a prompt template from an MCP server
- */
-export interface MCPPrompt {
-    /** Prompt name */
-    name: string;
-    /** Prompt description */
-    description?: string;
-    /** Required arguments */
-    arguments?: MCPPromptArgument[];
-}
-/**
- * MCP Prompt Argument
- */
-export interface MCPPromptArgument {
-    /** Argument name */
-    name: string;
-    /** Argument description */
-    description?: string;
-    /** Is required */
-    required?: boolean;
-}
-/**
- * MCP Tool
- * Represents a function callable via MCP
- */
-export interface MCPTool {
-    /** Tool name */
-    name: string;
-    /** Tool description */
-    description?: string;
-    /** Input schema (JSON Schema) */
-    inputSchema: Record<string, unknown>;
-}
-/**
- * MCP Connection
- * Represents a connection to an MCP server
- */
-export interface MCPConnection {
-    /** Connection ID */
-    id: string;
-    /** MCP server URI */
-    uri: string;
-    /** Server name */
-    name: string;
-    /** Server version */
-    version: string;
-    /** Protocol version */
-    protocolVersion: string;
-    /** Capabilities */
-    capabilities: MCPCapabilities;
-    /** Connection status */
-    status: 'connected' | 'disconnected' | 'error';
-    /** Last activity timestamp */
-    lastActivity: string;
-}
-/**
- * MCP Server Capabilities
- */
-export interface MCPCapabilities {
-    /** Supports resources */
-    resources?: {
-        /** Supports listing resources */
-        list?: boolean;
-        /** Supports subscribing to resources */
-        subscribe?: boolean;
-    };
-    /** Supports prompts */
-    prompts?: {
-        /** Supports listing prompts */
-        list?: boolean;
-    };
-    /** Supports tools */
-    tools?: {
-        /** Supports listing tools */
-        list?: boolean;
-    };
-    /** Supports logging */
-    logging?: {
-        /** Log levels supported */
-        levels?: string[];
-    };
-}
-/**
- * MCP Server
- * Represents an OSSA agent exposed as an MCP server
- */
-export interface MCPServer {
-    /** Server ID */
-    id: string;
-    /** Agent identity */
-    agent: AgentIdentity;
-    /** Server endpoint */
-    endpoint: string;
-    /** Server capabilities */
-    capabilities: MCPCapabilities;
-    /** Exposed resources */
-    resources: MCPResource[];
-    /** Exposed prompts */
-    prompts: MCPPrompt[];
-    /** Exposed tools */
-    tools: MCPTool[];
-}
-/**
- * MCP Integration Service
- * Bridges OSSA A2A protocol with MCP
- */
-export declare class MCPIntegrationService {
-    private connections;
-    private servers;
-    private transportManager;
-    /**
-     * Connect to an MCP server
-     */
-    connectMCPServer(uri: string): Promise<MCPConnection>;
-    /**
-     * Disconnect from an MCP server
-     */
-    disconnectMCPServer(connectionId: string): Promise<void>;
-    /**
-     * Expose OSSA agent as MCP server
-     */
-    exposeMCPServer(agent: AgentIdentity): Promise<MCPServer>;
-    /**
-     * Discover available MCP resources
-     */
-    discoverResources(connectionId: string): Promise<MCPResource[]>;
-    /**
-     * Discover available MCP prompts
-     */
-    discoverPrompts(connectionId: string): Promise<MCPPrompt[]>;
-    /**
-     * Discover available MCP tools
-     */
-    discoverTools(connectionId: string): Promise<MCPTool[]>;
-    /**
-     * Call an MCP tool
-     */
-    callTool(connectionId: string, toolName: string, arguments_: Record<string, unknown>): Promise<unknown>;
-    /**
-     * Read an MCP resource
-     */
-    readResource(connectionId: string, uri: string): Promise<unknown>;
-    /**
-     * Convert A2A message to MCP message
-     */
-    a2aToMCP(message: A2AMessage): unknown;
-    /**
-     * Convert MCP message to A2A message
-     */
-    mcpToA2A(mcpMessage: unknown, from: AgentIdentity, to: AgentIdentity): A2AMessage;
-    /**
-     * Send MCP message using real transport
-     */
-    private sendMCPMessage;
-    /**
-     * Cleanup - disconnect all MCP connections
-     */
-    cleanup(): Promise<void>;
-    /**
-     * Get transport statistics
-     */
-    getTransportStats(): {
-        totalConnections: number;
-        totalRequests: number;
-        connections: Array<{
-            uri: string;
-            connectedAt: Date;
-            requestCount: number;
-            lastActivity: Date;
-        }>;
-    };
-    /**
-     * Map A2A message type to MCP method
-     */
-    private mapA2ATypeToMCP;
-    /**
-     * Map MCP method to A2A message type
-     */
-    private mapMCPTypeToA2A;
-    /**
-     * Create trace context — prefers active OTel span so outbound messages
-     * carry the same traceId as the surrounding span tree.
-     */
-    private createTraceContext;
-    /**
-     * Generate random hex string
-     */
-    private generateHex;
-    /**
-     * Get all active connections
-     */
-    getConnections(): MCPConnection[];
-    /**
-     * Get all exposed servers
-     */
-    getServers(): MCPServer[];
-}
-//# sourceMappingURL=mcp-integration.d.ts.map