@bluefly/openstandardagents 0.4.9 → 0.5.1

package/spec/v1/agent-card.schema.json

@@ -0,0 +1,254 @@
+{
+  "$id": "https://ossa.dev/spec/v1/agent-card.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Agent Card v1.0",
+  "description": "Machine-readable agent passport enabling auto-discovery, auth negotiation, capability verification, and A2A protocol compatibility.",
+  "type": "object",
+  "required": [
+    "schemaVersion",
+    "humanReadableId",
+    "agentVersion",
+    "name",
+    "description",
+    "url",
+    "capabilities",
+    "authSchemes"
+  ],
+  "properties": {
+    "schemaVersion": {
+      "type": "string",
+      "const": "1.0",
+      "description": "Version of the Agent Card schema."
+    },
+    "humanReadableId": {
+      "type": "string",
+      "pattern": "^[a-z0-9][a-z0-9._-]*/[a-z0-9][a-z0-9._-]*$",
+      "description": "Unique namespace/agent identifier in 'org/agent-name' format.",
+      "examples": ["acme/weather-reporter", "blueflyio/code-review-agent"]
+    },
+    "agentVersion": {
+      "type": "string",
+      "pattern": "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$",
+      "description": "Semantic version (MAJOR.MINOR.PATCH) of the agent software.",
+      "examples": ["1.0.0", "2.1.0-beta.1"]
+    },
+    "name": {
+      "type": "string",
+      "maxLength": 150,
+      "description": "Human-readable display name."
+    },
+    "description": {
+      "type": "string",
+      "maxLength": 2000,
+      "description": "Clear description of the agent's purpose and capabilities."
+    },
+    "url": {
+      "type": "string",
+      "format": "uri",
+      "description": "Primary A2A endpoint URL. MUST use HTTPS except for localhost.",
+      "examples": ["https://api.my-agent.example.com/a2a"]
+    },
+    "provider": {
+      "$ref": "#/$defs/Provider"
+    },
+    "capabilities": {
+      "$ref": "#/$defs/Capabilities"
+    },
+    "authSchemes": {
+      "type": "array",
+      "minItems": 1,
+      "description": "Authentication schemes supported. At least one is required.",
+      "items": {
+        "$ref": "#/$defs/AuthScheme"
+      }
+    },
+    "skills": {
+      "type": "array",
+      "description": "Discrete operations the agent can perform.",
+      "items": {
+        "$ref": "#/$defs/Skill"
+      }
+    },
+    "tags": {
+      "type": "array",
+      "description": "Searchable discovery keywords.",
+      "items": {
+        "type": "string"
+      }
+    },
+    "privacyPolicyUrl": {
+      "type": "string",
+      "format": "uri",
+      "description": "URL to the agent's privacy policy."
+    },
+    "termsOfServiceUrl": {
+      "type": "string",
+      "format": "uri",
+      "description": "URL to the agent's terms of service."
+    },
+    "iconUrl": {
+      "type": "string",
+      "format": "uri",
+      "description": "URL to the agent's icon image."
+    },
+    "lastUpdated": {
+      "type": "string",
+      "format": "date-time",
+      "description": "ISO 8601 timestamp of last modification to this card."
+    }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "Provider": {
+      "type": "object",
+      "required": ["name"],
+      "description": "Organization or individual operating this agent.",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "Display name of the provider."
+        },
+        "url": {
+          "type": "string",
+          "format": "uri",
+          "description": "Provider's homepage URL."
+        },
+        "support_contact": {
+          "type": "string",
+          "description": "Support contact (email, URL, or mailto: URI)."
+        }
+      },
+      "additionalProperties": false
+    },
+    "Capabilities": {
+      "type": "object",
+      "required": ["a2aVersion"],
+      "description": "Protocol capabilities for this agent.",
+      "properties": {
+        "a2aVersion": {
+          "type": "string",
+          "description": "A2A protocol version supported.",
+          "examples": ["1.0"]
+        },
+        "mcpVersion": {
+          "type": "string",
+          "description": "MCP protocol version supported, if any.",
+          "examples": ["0.6"]
+        },
+        "supportedMessageParts": {
+          "type": "array",
+          "description": "Message part types this agent can consume/produce.",
+          "items": {
+            "type": "string",
+            "enum": ["text", "file", "data", "image", "audio", "video"]
+          }
+        },
+        "supportsPushNotifications": {
+          "type": "boolean",
+          "default": false,
+          "description": "Whether the agent supports async push notifications."
+        },
+        "teeDetails": {
+          "$ref": "#/$defs/TeeDetails"
+        }
+      },
+      "additionalProperties": false
+    },
+    "TeeDetails": {
+      "type": "object",
+      "required": ["type"],
+      "description": "Trusted Execution Environment attestation details.",
+      "properties": {
+        "type": {
+          "type": "string",
+          "description": "TEE technology type.",
+          "examples": ["Intel SGX", "AMD SEV", "AWS Nitro"]
+        },
+        "attestationEndpoint": {
+          "type": "string",
+          "format": "uri",
+          "description": "URL of the TEE remote attestation endpoint."
+        },
+        "publicKey": {
+          "type": "string",
+          "description": "PEM-encoded public key of the enclave."
+        },
+        "description": {
+          "type": "string",
+          "description": "Human-readable explanation of what the TEE protects."
+        }
+      },
+      "additionalProperties": false
+    },
+    "AuthScheme": {
+      "type": "object",
+      "required": ["scheme"],
+      "description": "A single authentication method supported by the agent.",
+      "properties": {
+        "scheme": {
+          "type": "string",
+          "enum": ["apiKey", "oauth2", "bearer", "none"],
+          "description": "Authentication scheme identifier."
+        },
+        "description": {
+          "type": "string",
+          "description": "How to obtain and use credentials for this scheme."
+        },
+        "tokenUrl": {
+          "type": "string",
+          "format": "uri",
+          "description": "OAuth2 token endpoint. Required when scheme is 'oauth2'."
+        },
+        "scopes": {
+          "type": "array",
+          "description": "OAuth2 scopes required (scheme: oauth2 only).",
+          "items": {
+            "type": "string"
+          }
+        },
+        "service_identifier": {
+          "type": "string",
+          "description": "Stable key for credential managers (e.g., 'acme-weather-api')."
+        }
+      },
+      "if": {
+        "properties": { "scheme": { "const": "oauth2" } }
+      },
+      "then": {
+        "required": ["tokenUrl"]
+      },
+      "additionalProperties": false
+    },
+    "Skill": {
+      "type": "object",
+      "required": ["id", "name", "description"],
+      "description": "A discrete callable operation the agent can perform.",
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^[a-z][a-z0-9_-]*$",
+          "description": "Stable machine-readable skill identifier, unique within the agent."
+        },
+        "name": {
+          "type": "string",
+          "description": "Human-readable display name."
+        },
+        "description": {
+          "type": "string",
+          "description": "Purpose and behaviour of this skill."
+        },
+        "input_schema": {
+          "type": "object",
+          "description": "JSON Schema describing the expected input payload.",
+          "additionalProperties": true
+        },
+        "output_schema": {
+          "type": "object",
+          "description": "JSON Schema describing the response payload structure.",
+          "additionalProperties": true
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+}

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

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

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