@bluefly/openstandardagents 0.5.0 → 0.5.1

package/dist/adapters/a2a/__tests__/mcp-integration.spec.js

@@ -1,268 +0,0 @@
-/**
- * MCP Integration Service Tests
- */
-import { afterEach, beforeEach, describe, expect, it } from '@jest/globals';
-import { SPEC_VERSION } from '../../../version.js';
-import { A2AMessageType, MessagePriority } from '../a2a-protocol.js';
-import { MCPIntegrationService, MCPMessageType } from '../mcp-integration.js';
-// Helper to create test agent identity
-function createTestAgent(name, namespace) {
-    return {
-        id: crypto.randomUUID(),
-        uri: `uadp://${namespace}/${name}`,
-        name,
-        namespace,
-        capabilities: ['test'],
-        version: '1.0.0',
-    };
-}
-describe('MCPIntegrationService', () => {
-    let service;
-    beforeEach(() => {
-        service = new MCPIntegrationService();
-    });
-    afterEach(async () => {
-        await service.cleanup();
-    });
-    describe('Connection Management', () => {
-        it('should connect to MCP server (mock)', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                const connection = await service.connectMCPServer(uri);
-                expect(connection).toBeDefined();
-                expect(connection.uri).toBe(uri);
-                expect(connection.status).toBe('connected');
-            }
-            catch (error) {
-                // Expected to fail without real server, but should attempt connection
-                expect(error).toBeDefined();
-            }
-        });
-        it('should disconnect from MCP server', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                const connection = await service.connectMCPServer(uri);
-                await service.disconnectMCPServer(connection.id);
-            }
-            catch (error) {
-                // Expected to fail without real server
-            }
-        });
-        it('should handle disconnect of non-existent connection', async () => {
-            await expect(service.disconnectMCPServer('non-existent-id')).rejects.toThrow('MCP connection not found');
-        });
-    });
-    describe('Server Exposure', () => {
-        it('should expose agent as MCP server', async () => {
-            const agent = createTestAgent('Test Agent', 'test-namespace');
-            const server = await service.exposeMCPServer(agent);
-            expect(server).toBeDefined();
-            expect(server.agent).toEqual(agent);
-            expect(server.endpoint).toContain(agent.namespace);
-            expect(server.endpoint).toContain(agent.name);
-            expect(server.capabilities).toBeDefined();
-        });
-        it('should set default capabilities for exposed server', async () => {
-            const agent = createTestAgent('Test Agent', 'test-namespace');
-            const server = await service.exposeMCPServer(agent);
-            expect(server.capabilities.resources?.list).toBe(true);
-            expect(server.capabilities.prompts?.list).toBe(true);
-            expect(server.capabilities.tools?.list).toBe(true);
-            expect(server.capabilities.logging).toBeDefined();
-        });
-    });
-    describe('Discovery Operations', () => {
-        it('should discover resources (connection required)', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                const connection = await service.connectMCPServer(uri);
-                const resources = await service.discoverResources(connection.id);
-                expect(Array.isArray(resources)).toBe(true);
-            }
-            catch (error) {
-                // Expected to fail without real server
-                expect(error).toBeDefined();
-            }
-        });
-        it('should discover prompts (connection required)', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                const connection = await service.connectMCPServer(uri);
-                const prompts = await service.discoverPrompts(connection.id);
-                expect(Array.isArray(prompts)).toBe(true);
-            }
-            catch (error) {
-                // Expected to fail without real server
-                expect(error).toBeDefined();
-            }
-        });
-        it('should discover tools (connection required)', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                const connection = await service.connectMCPServer(uri);
-                const tools = await service.discoverTools(connection.id);
-                expect(Array.isArray(tools)).toBe(true);
-            }
-            catch (error) {
-                // Expected to fail without real server
-                expect(error).toBeDefined();
-            }
-        });
-        it('should handle discovery with invalid connection ID', async () => {
-            await expect(service.discoverResources('invalid-id')).rejects.toThrow('MCP connection not found');
-            await expect(service.discoverPrompts('invalid-id')).rejects.toThrow('MCP connection not found');
-            await expect(service.discoverTools('invalid-id')).rejects.toThrow('MCP connection not found');
-        });
-    });
-    describe('Tool Invocation', () => {
-        it('should call MCP tool (connection required)', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                const connection = await service.connectMCPServer(uri);
-                const result = await service.callTool(connection.id, 'test-tool', {
-                    arg1: 'value1',
-                });
-                expect(result).toBeDefined();
-            }
-            catch (error) {
-                // Expected to fail without real server
-                expect(error).toBeDefined();
-            }
-        });
-        it('should handle tool call with invalid connection', async () => {
-            await expect(service.callTool('invalid-id', 'test-tool', {})).rejects.toThrow('MCP connection not found');
-        });
-    });
-    describe('Resource Reading', () => {
-        it('should read MCP resource (connection required)', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                const connection = await service.connectMCPServer(uri);
-                const content = await service.readResource(connection.id, 'resource://test/path');
-                expect(content).toBeDefined();
-            }
-            catch (error) {
-                // Expected to fail without real server
-                expect(error).toBeDefined();
-            }
-        });
-        it('should handle resource read with invalid connection', async () => {
-            await expect(service.readResource('invalid-id', 'resource://test')).rejects.toThrow('MCP connection not found');
-        });
-    });
-    describe('Protocol Conversion', () => {
-        it('should convert A2A message to MCP format', () => {
-            const from = createTestAgent('Sender', 'sender');
-            const to = createTestAgent('Receiver', 'receiver');
-            const a2aMessage = {
-                id: 'test-123',
-                from,
-                to,
-                type: A2AMessageType.COMMAND,
-                payload: { action: 'test' },
-                version: SPEC_VERSION,
-                metadata: {
-                    priority: MessagePriority.NORMAL,
-                    timeout: 30000,
-                    retries: 3,
-                    traceContext: {
-                        traceparent: '00-trace-span-01',
-                        traceId: 'trace',
-                        spanId: 'span',
-                    },
-                    createdAt: new Date().toISOString(),
-                },
-            };
-            const mcpMessage = service.a2aToMCP(a2aMessage);
-            expect(mcpMessage).toHaveProperty('jsonrpc', '2.0');
-            expect(mcpMessage).toHaveProperty('id', 'test-123');
-            expect(mcpMessage).toHaveProperty('method');
-            expect(mcpMessage).toHaveProperty('params');
-            expect(mcpMessage.metadata).toHaveProperty('from', from.uri);
-        });
-        it('should convert MCP message to A2A format', () => {
-            const from = createTestAgent('Sender', 'sender');
-            const to = createTestAgent('Receiver', 'receiver');
-            const mcpMessage = {
-                jsonrpc: '2.0',
-                id: 'mcp-123',
-                method: MCPMessageType.TOOLS_CALL,
-                params: { tool: 'test' },
-            };
-            const a2aMessage = service.mcpToA2A(mcpMessage, from, to);
-            expect(a2aMessage).toHaveProperty('id', 'mcp-123');
-            expect(a2aMessage).toHaveProperty('from', from);
-            expect(a2aMessage).toHaveProperty('to', to);
-            expect(a2aMessage).toHaveProperty('type');
-            expect(a2aMessage).toHaveProperty('payload');
-            expect(a2aMessage).toHaveProperty('version', '0.4.4');
-            expect(a2aMessage.metadata).toBeDefined();
-        });
-        it('should map A2A types to MCP methods correctly', () => {
-            const agent = createTestAgent('Test', 'test');
-            const baseMessage = {
-                id: '1',
-                from: agent,
-                to: agent,
-                payload: {},
-                version: SPEC_VERSION,
-                metadata: {
-                    priority: MessagePriority.NORMAL,
-                    timeout: 30000,
-                    retries: 3,
-                    traceContext: { traceparent: '00-t-s-01', traceId: 't', spanId: 's' },
-                    createdAt: new Date().toISOString(),
-                },
-            };
-            // Test request -> tools/call
-            const requestMsg = { ...baseMessage, type: A2AMessageType.REQUEST };
-            const mcpRequest = service.a2aToMCP(requestMsg);
-            expect(mcpRequest.method).toBe(MCPMessageType.TOOLS_CALL);
-            // Test command -> tools/call
-            const commandMsg = { ...baseMessage, type: A2AMessageType.COMMAND };
-            const mcpCommand = service.a2aToMCP(commandMsg);
-            expect(mcpCommand.method).toBe(MCPMessageType.TOOLS_CALL);
-            // Test event -> notification
-            const eventMsg = { ...baseMessage, type: A2AMessageType.EVENT };
-            const mcpEvent = service.a2aToMCP(eventMsg);
-            expect(mcpEvent.method).toBe(MCPMessageType.NOTIFICATION);
-        });
-    });
-    describe('Statistics and State', () => {
-        it('should track connections', () => {
-            const connections = service.getConnections();
-            expect(Array.isArray(connections)).toBe(true);
-        });
-        it('should track exposed servers', async () => {
-            const agent = createTestAgent('Test', 'test');
-            await service.exposeMCPServer(agent);
-            const servers = service.getServers();
-            expect(servers.length).toBeGreaterThan(0);
-            expect(servers[0].agent).toEqual(agent);
-        });
-        it('should provide transport statistics', () => {
-            const stats = service.getTransportStats();
-            expect(stats).toHaveProperty('totalConnections');
-            expect(stats).toHaveProperty('totalRequests');
-            expect(stats).toHaveProperty('connections');
-        });
-    });
-    describe('Cleanup', () => {
-        it('should cleanup all connections', async () => {
-            await expect(service.cleanup()).resolves.not.toThrow();
-        });
-        it('should disconnect all transport connections on cleanup', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                await service.connectMCPServer(uri);
-            }
-            catch (error) {
-                // Ignore connection errors
-            }
-            await service.cleanup();
-            const stats = service.getTransportStats();
-            expect(stats.totalConnections).toBe(0);
-        });
-    });
-});
-//# sourceMappingURL=mcp-integration.spec.js.map

package/dist/adapters/a2a/__tests__/mcp-transport.spec.d.ts

@@ -1,5 +0,0 @@
-/**
- * MCP Transport Manager Tests
- */
-export {};
-//# sourceMappingURL=mcp-transport.spec.d.ts.map

package/dist/adapters/a2a/__tests__/mcp-transport.spec.js

@@ -1,203 +0,0 @@
-/**
- * MCP Transport Manager Tests
- */
-import { describe, it, expect, beforeEach, afterEach, } from '@jest/globals';
-import { MCPTransportManager } from '../mcp-transport.js';
-describe('MCPTransportManager', () => {
-    let transportManager;
-    beforeEach(() => {
-        transportManager = new MCPTransportManager();
-    });
-    afterEach(async () => {
-        await transportManager.disconnectAll();
-    });
-    describe('URI Parsing', () => {
-        it('should parse stdio URI correctly', async () => {
-            const uri = 'stdio://python/path/to/script.py?arg1=value1&arg2=value2';
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                // Expected to fail (no actual server), but parsing should work
-                expect(error).toBeDefined();
-            }
-            // Check that connection attempt was made
-            const connections = transportManager.getConnections();
-            expect(connections.length).toBeLessThanOrEqual(1);
-        });
-        it('should parse HTTP URI correctly', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                // Expected to fail (no actual server)
-                expect(error).toBeDefined();
-            }
-        });
-        it('should parse HTTPS URI correctly', async () => {
-            const uri = 'https://api.example.com/mcp';
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                // Expected to fail (no actual server)
-                expect(error).toBeDefined();
-            }
-        });
-        it('should reject unsupported protocols', async () => {
-            const uri = 'ftp://example.com/mcp';
-            await expect(transportManager.getClient(uri)).rejects.toThrow('Unsupported protocol');
-        });
-        it('should reject invalid URIs', async () => {
-            const uri = 'not-a-valid-uri';
-            await expect(transportManager.getClient(uri)).rejects.toThrow('Invalid MCP URI');
-        });
-    });
-    describe('Connection Pooling', () => {
-        it('should reuse existing connections', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            // First connection attempt
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                // Ignore connection error
-            }
-            const stats1 = transportManager.getStats();
-            const initialConnections = stats1.totalConnections;
-            // Second connection attempt (should reuse)
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                // Ignore connection error
-            }
-            const stats2 = transportManager.getStats();
-            expect(stats2.totalConnections).toBe(initialConnections);
-        });
-        it('should track request count', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                const wrapper = await transportManager.getClient(uri);
-                expect(wrapper.requestCount).toBe(0);
-            }
-            catch (error) {
-                // Connection will fail, but wrapper should be tracked
-            }
-        });
-        it('should update last activity timestamp', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                const wrapper1 = await transportManager.getClient(uri);
-                const firstActivity = wrapper1.lastActivity;
-                // Wait a bit
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                const wrapper2 = await transportManager.getClient(uri);
-                expect(wrapper2.lastActivity.getTime()).toBeGreaterThanOrEqual(firstActivity.getTime());
-            }
-            catch (error) {
-                // Ignore connection errors
-            }
-        });
-    });
-    describe('Connection Management', () => {
-        it('should disconnect specific connection', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                // Ignore connection error
-            }
-            await transportManager.disconnect(uri);
-            const connections = transportManager.getConnections();
-            expect(connections.find((c) => c.config.url === uri)).toBeUndefined();
-        });
-        it('should disconnect all connections', async () => {
-            const uri1 = 'http://localhost:3000/mcp';
-            const uri2 = 'http://localhost:3001/mcp';
-            try {
-                await transportManager.getClient(uri1);
-                await transportManager.getClient(uri2);
-            }
-            catch (error) {
-                // Ignore connection errors
-            }
-            await transportManager.disconnectAll();
-            const connections = transportManager.getConnections();
-            expect(connections.length).toBe(0);
-        });
-        it('should handle disconnect of non-existent connection gracefully', async () => {
-            await expect(transportManager.disconnect('http://nonexistent:3000/mcp')).resolves.not.toThrow();
-        });
-    });
-    describe('Statistics', () => {
-        it('should track connection statistics', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                // Ignore connection error
-            }
-            const stats = transportManager.getStats();
-            expect(stats).toHaveProperty('totalConnections');
-            expect(stats).toHaveProperty('totalRequests');
-            expect(stats).toHaveProperty('connections');
-            expect(Array.isArray(stats.connections)).toBe(true);
-        });
-        it('should return empty stats when no connections', () => {
-            const stats = transportManager.getStats();
-            expect(stats.totalConnections).toBe(0);
-            expect(stats.totalRequests).toBe(0);
-            expect(stats.connections.length).toBe(0);
-        });
-    });
-    describe('Error Handling', () => {
-        it('should handle connection timeout gracefully', async () => {
-            const uri = 'http://192.0.2.1:9999/mcp'; // Non-routable IP
-            await expect(transportManager.getClient(uri)).rejects.toThrow();
-        }, 35000); // Longer timeout for connection attempt
-        it('should handle request errors', async () => {
-            const uri = 'http://localhost:9999/mcp';
-            await expect(transportManager.sendRequest(uri, 'test/method', {})).rejects.toThrow();
-        }, 35000);
-    });
-    describe('Transport Types', () => {
-        it('should support STDIO transport type', async () => {
-            const uri = 'stdio://node/script.js';
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                // Connection will fail, but transport type should be parsed
-                expect(error).toBeDefined();
-            }
-        });
-        it('should support HTTP transport type', async () => {
-            const uri = 'http://localhost:3000/mcp';
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                expect(error).toBeDefined();
-            }
-        });
-        it('should support HTTPS transport type', async () => {
-            const uri = 'https://api.example.com/mcp';
-            try {
-                await transportManager.getClient(uri);
-            }
-            catch (error) {
-                expect(error).toBeDefined();
-            }
-        });
-        it('should accept WebSocket URI and use SSE fallback', async () => {
-            const uri = 'ws://localhost:3000/mcp';
-            await expect(transportManager.getClient(uri)).rejects.toThrow();
-            // Connection fails (no server) but WebSocket path is handled via SSE fallback
-        });
-    });
-});
-//# sourceMappingURL=mcp-transport.spec.js.map

package/dist/mcp-server/__tests__/mcp-server.spec.d.ts

@@ -1,8 +0,0 @@
-/**
- * OSSA MCP Server — Integration Tests
- *
- * Tests all 7 tools end-to-end using the MCP SDK Client.
- * Uses vitest + @modelcontextprotocol/sdk.
- */
-export {};
-//# sourceMappingURL=mcp-server.spec.d.ts.map