genesis-ai-cli 9.3.0 → 10.0.0

package/dist/src/a2a/client.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Genesis A2A Client
+ *
+ * Client for discovering and communicating with remote Genesis agents.
+ * Supports HTTP, WebSocket, and MessageBus transports.
+ */
+import { EventEmitter } from 'events';
+import { A2AAgentId, A2AMessage, A2AResponse, A2AEndpoint, A2AKeyPair, AgentCapability, AgentAnnouncement, TaskRequest, TaskResult, TaskProgress, TrustScore, PaymentQuote, PaymentCommitment } from './protocol.js';
+export interface A2AClientConfig {
+    agentId: A2AAgentId;
+    keyPair: A2AKeyPair;
+    directory?: AgentDirectory;
+    defaultTimeout?: number;
+    autoRetry?: boolean;
+    maxRetries?: number;
+    debug?: boolean;
+}
+export interface AgentDirectory {
+    lookup(agentId: A2AAgentId): Promise<AgentAnnouncement | null>;
+    search(query: {
+        capabilities?: string[];
+        minTrust?: number;
+        limit?: number;
+    }): Promise<AgentAnnouncement[]>;
+    register(announcement: AgentAnnouncement): Promise<void>;
+    unregister(agentId: A2AAgentId): Promise<void>;
+}
+export interface PendingRequest {
+    resolve: (response: A2AResponse) => void;
+    reject: (error: Error) => void;
+    timeout: NodeJS.Timeout;
+    created: Date;
+}
+export interface A2AClientEvents {
+    connected: (endpoint: A2AEndpoint) => void;
+    disconnected: (endpoint: A2AEndpoint) => void;
+    message: (message: A2AMessage) => void;
+    response: (response: A2AResponse) => void;
+    error: (error: Error) => void;
+    'task:progress': (taskId: string, progress: TaskProgress) => void;
+    'task:complete': (taskId: string, result: TaskResult) => void;
+}
+export declare class A2AClient extends EventEmitter {
+    private config;
+    private connections;
+    private pendingRequests;
+    private knownAgents;
+    private trustCache;
+    private metrics;
+    constructor(config: A2AClientConfig);
+    discover(options?: {
+        capabilities?: string[];
+        minTrust?: number;
+        limit?: number;
+    }): Promise<AgentAnnouncement[]>;
+    ping(agentId: A2AAgentId): Promise<{
+        latency: number;
+        version: string;
+    }>;
+    announce(announcement: AgentAnnouncement): Promise<void>;
+    registerAgent(announcement: AgentAnnouncement): void;
+    getCapabilities(agentId: A2AAgentId): Promise<AgentCapability[]>;
+    queryCapabilities(query: {
+        category?: string;
+        tags?: string[];
+        search?: string;
+        maxCostTier?: string;
+    }): Promise<Array<{
+        agent: AgentAnnouncement;
+        capability: AgentCapability;
+    }>>;
+    delegateTask(agentId: A2AAgentId, capabilityId: string, input: Record<string, unknown>, options?: {
+        priority?: TaskRequest['priority'];
+        timeout?: number;
+        payment?: PaymentCommitment;
+        onProgress?: (progress: TaskProgress) => void;
+    }): Promise<TaskResult>;
+    cancelTask(agentId: A2AAgentId, taskId: string, reason?: string): Promise<void>;
+    private waitForTaskCompletion;
+    validateResult(agentId: A2AAgentId, taskId: string, result: TaskResult): Promise<{
+        valid: boolean;
+        score: number;
+        issues?: string[];
+    }>;
+    disputeResult(agentId: A2AAgentId, taskId: string, reason: string, resolution: 'refund' | 'redo' | 'partial-refund' | 'arbitration'): Promise<void>;
+    getTrust(agentId: A2AAgentId): Promise<TrustScore>;
+    attestTrust(agentId: A2AAgentId, type: 'task-completion' | 'quality' | 'behavior', rating: number, taskId?: string, comment?: string): Promise<void>;
+    reportAgent(agentId: A2AAgentId, type: 'spam' | 'fraud' | 'abuse' | 'quality' | 'payment', severity: 'low' | 'medium' | 'high' | 'critical', description: string, evidence?: unknown): Promise<void>;
+    getQuote(agentId: A2AAgentId, capabilityId: string, estimatedInput?: Record<string, unknown>): Promise<PaymentQuote>;
+    negotiatePayment(agentId: A2AAgentId, quoteId: string, counterOffer?: number): Promise<{
+        accepted: boolean;
+        finalPrice?: number;
+    }>;
+    commitPayment(quote: PaymentQuote): Promise<PaymentCommitment>;
+    releasePayment(agentId: A2AAgentId, commitmentId: string, taskId: string, reason?: 'completed' | 'partial' | 'refund'): Promise<void>;
+    private sendRequest;
+    private sendWithRetry;
+    private send;
+    private selectEndpoint;
+    private sendHttp;
+    private sign;
+    private findCapability;
+    private getDefaultTrust;
+    private trustLevelToScore;
+    private log;
+    getMetrics(): {
+        knownAgents: number;
+        pendingRequests: number;
+        requestsSent: number;
+        responsesReceived: number;
+        errors: number;
+        avgLatency: number;
+        tasksDelegated: number;
+        tasksCompleted: number;
+    };
+}
+export declare function generateA2AKeyPair(): A2AKeyPair;

package/dist/src/a2a/client.js

@@ -0,0 +1,506 @@
+"use strict";
+/**
+ * Genesis A2A Client
+ *
+ * Client for discovering and communicating with remote Genesis agents.
+ * Supports HTTP, WebSocket, and MessageBus transports.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2AClient = void 0;
+exports.generateA2AKeyPair = generateA2AKeyPair;
+const events_1 = require("events");
+const crypto = __importStar(require("crypto"));
+const protocol_js_1 = require("./protocol.js");
+// ============================================================================
+// A2A Client Class
+// ============================================================================
+class A2AClient extends events_1.EventEmitter {
+    config;
+    connections = new Map();
+    pendingRequests = new Map();
+    knownAgents = new Map();
+    trustCache = new Map();
+    metrics = {
+        requestsSent: 0,
+        responsesReceived: 0,
+        errors: 0,
+        avgLatency: 0,
+        tasksDelegated: 0,
+        tasksCompleted: 0,
+    };
+    constructor(config) {
+        super();
+        this.config = {
+            defaultTimeout: 30000,
+            autoRetry: true,
+            maxRetries: 3,
+            debug: false,
+            ...config,
+        };
+    }
+    // ============================================================================
+    // Discovery
+    // ============================================================================
+    async discover(options = {}) {
+        if (this.config.directory) {
+            return this.config.directory.search(options);
+        }
+        const message = (0, protocol_js_1.createA2AMessage)('a2a.discover', {
+            from: this.config.agentId,
+            filter: {
+                capabilities: options.capabilities,
+                minTrust: options.minTrust,
+                limit: options.limit,
+            },
+        });
+        this.log('Broadcasting discovery request');
+        return Array.from(this.knownAgents.values());
+    }
+    async ping(agentId) {
+        const startTime = Date.now();
+        const response = await this.sendRequest(agentId, 'a2a.ping', {
+            from: this.config.agentId,
+            to: agentId,
+        });
+        return {
+            latency: Date.now() - startTime,
+            version: response.result?.version || 'unknown',
+        };
+    }
+    async announce(announcement) {
+        if (this.config.directory) {
+            await this.config.directory.register(announcement);
+        }
+        this.knownAgents.set(this.config.agentId, announcement);
+        this.log(`Announced agent ${this.config.agentId}`);
+    }
+    registerAgent(announcement) {
+        this.knownAgents.set(announcement.agentId, announcement);
+    }
+    // ============================================================================
+    // Capability Queries
+    // ============================================================================
+    async getCapabilities(agentId) {
+        const response = await this.sendRequest(agentId, 'a2a.capabilities.list', {
+            from: this.config.agentId,
+            to: agentId,
+        });
+        return response.result?.capabilities || [];
+    }
+    async queryCapabilities(query) {
+        const results = [];
+        for (const agent of this.knownAgents.values()) {
+            for (const cap of agent.capabilities) {
+                let matches = true;
+                if (query.category && cap.category !== query.category)
+                    matches = false;
+                if (query.tags && !query.tags.some((t) => cap.tags?.includes(t)))
+                    matches = false;
+                if (query.search && !cap.name.toLowerCase().includes(query.search.toLowerCase())) {
+                    matches = false;
+                }
+                if (matches) {
+                    results.push({ agent, capability: cap });
+                }
+            }
+        }
+        return results;
+    }
+    // ============================================================================
+    // Task Delegation
+    // ============================================================================
+    async delegateTask(agentId, capabilityId, input, options = {}) {
+        this.metrics.tasksDelegated++;
+        const trust = await this.getTrust(agentId);
+        const capability = await this.findCapability(agentId, capabilityId);
+        if (capability?.requiredTrust) {
+            const requiredLevel = this.trustLevelToScore(capability.requiredTrust);
+            if (trust.overall < requiredLevel) {
+                throw new Error(`Insufficient trust: ${trust.overall} < ${requiredLevel}`);
+            }
+        }
+        let payment = options.payment;
+        if (capability && capability.costTier !== 'free' && !payment) {
+            const quote = await this.getQuote(agentId, capabilityId, input);
+            payment = await this.commitPayment(quote);
+        }
+        const message = (0, protocol_js_1.createTaskRequest)(this.config.agentId, agentId, capabilityId, input, {
+            priority: options.priority,
+            timeout: options.timeout || this.config.defaultTimeout,
+            payment,
+        });
+        const taskId = message.params.task.id;
+        if (options.onProgress) {
+            const progressHandler = (progress) => {
+                if (progress.taskId === taskId) {
+                    options.onProgress(progress);
+                }
+            };
+            this.on('task:progress', progressHandler);
+            this.once('task:complete', (completedId) => {
+                if (completedId === taskId) {
+                    this.off('task:progress', progressHandler);
+                }
+            });
+        }
+        const response = await this.sendRequest(agentId, 'a2a.task.request', message.params, {
+            timeout: options.timeout || this.config.defaultTimeout * 2,
+        });
+        if (response.result?.accepted === false) {
+            throw new Error(response.result?.reason || 'Task rejected');
+        }
+        const result = await this.waitForTaskCompletion(taskId, options.timeout);
+        this.metrics.tasksCompleted++;
+        return result;
+    }
+    async cancelTask(agentId, taskId, reason) {
+        await this.sendRequest(agentId, 'a2a.task.cancel', {
+            from: this.config.agentId,
+            to: agentId,
+            taskId,
+            reason,
+        });
+    }
+    async waitForTaskCompletion(taskId, timeout) {
+        return new Promise((resolve, reject) => {
+            const timeoutMs = timeout || this.config.defaultTimeout * 2;
+            const timeoutId = setTimeout(() => {
+                this.off('task:complete', handler);
+                reject(new Error(`Task ${taskId} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            const handler = (completedId, result) => {
+                if (completedId === taskId) {
+                    clearTimeout(timeoutId);
+                    this.off('task:complete', handler);
+                    resolve(result);
+                }
+            };
+            this.on('task:complete', handler);
+        });
+    }
+    // ============================================================================
+    // Result Validation
+    // ============================================================================
+    async validateResult(agentId, taskId, result) {
+        const response = await this.sendRequest(agentId, 'a2a.result.validate', {
+            from: this.config.agentId,
+            to: agentId,
+            taskId,
+            result,
+        });
+        return response.result;
+    }
+    async disputeResult(agentId, taskId, reason, resolution) {
+        await this.sendRequest(agentId, 'a2a.result.dispute', {
+            from: this.config.agentId,
+            to: agentId,
+            taskId,
+            dispute: { taskId, reason, resolution },
+        });
+    }
+    // ============================================================================
+    // Trust & Reputation
+    // ============================================================================
+    async getTrust(agentId) {
+        const cached = this.trustCache.get(agentId);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const response = await this.sendRequest(agentId, 'a2a.trust.query', {
+                from: this.config.agentId,
+                query: { agentId },
+            });
+            const trust = response.result;
+            this.trustCache.set(agentId, trust);
+            return trust;
+        }
+        catch {
+            return this.getDefaultTrust(agentId);
+        }
+    }
+    async attestTrust(agentId, type, rating, taskId, comment) {
+        const attestation = {
+            id: crypto.randomUUID(),
+            from: this.config.agentId,
+            about: agentId,
+            type,
+            rating,
+            taskId,
+            comment,
+            timestamp: new Date().toISOString(),
+            signature: this.sign(JSON.stringify({ agentId, type, rating, taskId })),
+        };
+        await this.sendRequest(agentId, 'a2a.trust.attest', {
+            from: this.config.agentId,
+            to: agentId,
+            about: agentId,
+            attestation,
+        });
+        this.trustCache.delete(agentId);
+    }
+    async reportAgent(agentId, type, severity, description, evidence) {
+        await this.sendRequest(agentId, 'a2a.trust.report', {
+            from: this.config.agentId,
+            about: agentId,
+            report: {
+                id: crypto.randomUUID(),
+                from: this.config.agentId,
+                about: agentId,
+                type,
+                severity,
+                description,
+                evidence,
+            },
+        });
+    }
+    // ============================================================================
+    // Payment
+    // ============================================================================
+    async getQuote(agentId, capabilityId, estimatedInput) {
+        const response = await this.sendRequest(agentId, 'a2a.payment.quote', {
+            from: this.config.agentId,
+            to: agentId,
+            quote: {
+                id: crypto.randomUUID(),
+                capabilityId,
+                estimatedInput,
+                price: 0,
+                currency: 'credits',
+                validUntil: new Date(Date.now() + 3600000).toISOString(),
+            },
+        });
+        return response.result;
+    }
+    async negotiatePayment(agentId, quoteId, counterOffer) {
+        const response = await this.sendRequest(agentId, 'a2a.payment.negotiate', {
+            from: this.config.agentId,
+            to: agentId,
+            negotiation: { quoteId, counterOffer, round: 1 },
+        });
+        return response.result;
+    }
+    async commitPayment(quote) {
+        return {
+            id: crypto.randomUUID(),
+            quoteId: quote.id,
+            amount: quote.price,
+            currency: quote.currency,
+            conditions: [{ type: 'task-complete' }],
+        };
+    }
+    async releasePayment(agentId, commitmentId, taskId, reason = 'completed') {
+        await this.sendRequest(agentId, 'a2a.payment.release', {
+            from: this.config.agentId,
+            to: agentId,
+            release: { commitmentId, amount: 0, taskId, reason },
+        });
+    }
+    // ============================================================================
+    // Transport Layer
+    // ============================================================================
+    async sendRequest(agentId, method, params, options = {}) {
+        const message = (0, protocol_js_1.createA2AMessage)(method, params);
+        message.signature = this.sign(JSON.stringify({ method, params }));
+        this.metrics.requestsSent++;
+        return this.sendWithRetry(agentId, message, options.timeout);
+    }
+    async sendWithRetry(agentId, message, timeout, attempt = 1) {
+        try {
+            return await this.send(agentId, message, timeout);
+        }
+        catch (error) {
+            if (this.config.autoRetry && attempt < (this.config.maxRetries || 3)) {
+                const delay = Math.pow(2, attempt) * 1000;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return this.sendWithRetry(agentId, message, timeout, attempt + 1);
+            }
+            throw error;
+        }
+    }
+    async send(agentId, message, timeout) {
+        const agent = this.knownAgents.get(agentId);
+        if (!agent) {
+            if (this.config.directory) {
+                const discovered = await this.config.directory.lookup(agentId);
+                if (discovered) {
+                    this.knownAgents.set(agentId, discovered);
+                    return this.send(agentId, message, timeout);
+                }
+            }
+            throw new Error(`Unknown agent: ${agentId}`);
+        }
+        const endpoint = this.selectEndpoint(agent.endpoints);
+        switch (endpoint.transport) {
+            case 'http':
+                return this.sendHttp(endpoint, message, timeout);
+            case 'websocket':
+                throw new Error('WebSocket transport not yet implemented');
+            case 'messagebus':
+                throw new Error('MessageBus transport not yet implemented');
+            default:
+                throw new Error(`Unsupported transport: ${endpoint.transport}`);
+        }
+    }
+    selectEndpoint(endpoints) {
+        const ws = endpoints.find((e) => e.transport === 'websocket');
+        if (ws)
+            return ws;
+        const http = endpoints.find((e) => e.transport === 'http');
+        if (http)
+            return http;
+        return endpoints[0];
+    }
+    async sendHttp(endpoint, message, timeout) {
+        const url = endpoint.secure ? `https://${endpoint.url}` : `http://${endpoint.url}`;
+        const port = endpoint.port ? `:${endpoint.port}` : '';
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout || this.config.defaultTimeout);
+        try {
+            const response = await fetch(`${url}${port}/a2a`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-A2A-Protocol': protocol_js_1.A2A_PROTOCOL_VERSION,
+                },
+                body: JSON.stringify(message),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const result = (await response.json());
+            this.metrics.responsesReceived++;
+            if (result.error) {
+                throw new Error(`A2A Error ${result.error.code}: ${result.error.message}`);
+            }
+            return result;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            this.metrics.errors++;
+            throw error;
+        }
+    }
+    // ============================================================================
+    // Cryptography
+    // ============================================================================
+    sign(data) {
+        const nonce = crypto.randomUUID();
+        const timestamp = new Date().toISOString();
+        const payload = `${data}:${nonce}:${timestamp}`;
+        const signature = crypto
+            .createHmac('sha256', this.config.keyPair.privateKey)
+            .update(payload)
+            .digest('hex');
+        return {
+            algorithm: this.config.keyPair.algorithm,
+            publicKey: this.config.keyPair.publicKey,
+            value: signature,
+            timestamp,
+            nonce,
+        };
+    }
+    // ============================================================================
+    // Utilities
+    // ============================================================================
+    async findCapability(agentId, capabilityId) {
+        const agent = this.knownAgents.get(agentId);
+        if (agent) {
+            return agent.capabilities.find((c) => c.id === capabilityId) || null;
+        }
+        const capabilities = await this.getCapabilities(agentId);
+        return capabilities.find((c) => c.id === capabilityId) || null;
+    }
+    getDefaultTrust(agentId) {
+        return {
+            agentId,
+            overall: 0.5,
+            components: {
+                reliability: 0.5,
+                quality: 0.5,
+                responsiveness: 0.5,
+                financial: 0.5,
+            },
+            level: 'basic',
+            interactions: 0,
+            confidence: 0.1,
+        };
+    }
+    trustLevelToScore(level) {
+        const levels = {
+            untrusted: 0,
+            minimal: 0.2,
+            basic: 0.4,
+            verified: 0.6,
+            trusted: 0.8,
+            'highly-trusted': 0.95,
+        };
+        return levels[level] || 0;
+    }
+    log(message) {
+        if (this.config.debug) {
+            console.log(`[A2AClient:${this.config.agentId.split(':').pop()}] ${message}`);
+        }
+    }
+    // ============================================================================
+    // Metrics
+    // ============================================================================
+    getMetrics() {
+        return {
+            ...this.metrics,
+            knownAgents: this.knownAgents.size,
+            pendingRequests: this.pendingRequests.size,
+        };
+    }
+}
+exports.A2AClient = A2AClient;
+// ============================================================================
+// Key Generation Utility
+// ============================================================================
+function generateA2AKeyPair() {
+    const id = crypto.randomUUID();
+    const privateKey = crypto.randomBytes(32).toString('hex');
+    const publicKey = crypto.createHash('sha256').update(privateKey).digest('hex');
+    return {
+        keyId: id,
+        privateKey,
+        publicKey,
+        algorithm: 'ed25519',
+        created: new Date().toISOString(),
+    };
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Genesis A2A Protocol
+ *
+ * Agent-to-Agent communication for distributed Genesis collaboration.
+ *
+ * Enables Genesis instances to:
+ * - Discover each other on a network
+ * - Advertise and query capabilities
+ * - Delegate tasks with payment negotiation
+ * - Build trust through attestations
+ *
+ * Scientific Grounding:
+ * - Global Workspace Theory: Network-wide capability broadcast
+ * - Free Energy Principle: Trust minimizes surprise in outcomes
+ * - Autopoiesis: Agents maintain identity via signatures
+ */
+export { A2A_PROTOCOL_VERSION, type A2AAgentId, type A2AEndpoint, type A2AMessage, type A2AResponse, type A2AError, type A2AMethod, type A2AParams, A2AErrorCode, type AgentCapability, type CapabilityCategory, type CapabilityQuery, type PricingModel, type RateLimit, type DiscoveryParams, type DiscoveryFilter, type AgentAnnouncement, type TaskRequest, type TaskPriority, type TaskContext, type TaskProgress, type TaskResult, type TaskMetrics, type TaskArtifact, type RetryPolicy, type ResultParams, type ResultValidation, type ValidationIssue, type ResultDispute, type TrustLevel, type TrustScore, type TrustAttestation, type TrustReport, type TrustQuery, type TrustParams, type PaymentQuote, type PaymentNegotiation, type PaymentCommitment, type PaymentCondition, type PaymentRelease, type PaymentDispute, type PaymentParams, type A2ASignature, type A2AKeyPair, type StreamParams, createA2AMessage, createA2AResponse, createA2AError, createTaskRequest, createCapabilityAdvertisement, } from './protocol.js';
+export { A2AClient, generateA2AKeyPair, type A2AClientConfig, type AgentDirectory, type PendingRequest, type A2AClientEvents, } from './client.js';
+export { A2AServer, type A2AServerConfig, type ActiveTask, type A2AMethodHandler, type HandlerContext, } from './server.js';

package/dist/src/a2a/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Genesis A2A Protocol
+ *
+ * Agent-to-Agent communication for distributed Genesis collaboration.
+ *
+ * Enables Genesis instances to:
+ * - Discover each other on a network
+ * - Advertise and query capabilities
+ * - Delegate tasks with payment negotiation
+ * - Build trust through attestations
+ *
+ * Scientific Grounding:
+ * - Global Workspace Theory: Network-wide capability broadcast
+ * - Free Energy Principle: Trust minimizes surprise in outcomes
+ * - Autopoiesis: Agents maintain identity via signatures
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2AServer = exports.generateA2AKeyPair = exports.A2AClient = exports.createCapabilityAdvertisement = exports.createTaskRequest = exports.createA2AError = exports.createA2AResponse = exports.createA2AMessage = exports.A2AErrorCode = exports.A2A_PROTOCOL_VERSION = void 0;
+// Protocol types and constants
+var protocol_js_1 = require("./protocol.js");
+Object.defineProperty(exports, "A2A_PROTOCOL_VERSION", { enumerable: true, get: function () { return protocol_js_1.A2A_PROTOCOL_VERSION; } });
+Object.defineProperty(exports, "A2AErrorCode", { enumerable: true, get: function () { return protocol_js_1.A2AErrorCode; } });
+// Factory functions
+Object.defineProperty(exports, "createA2AMessage", { enumerable: true, get: function () { return protocol_js_1.createA2AMessage; } });
+Object.defineProperty(exports, "createA2AResponse", { enumerable: true, get: function () { return protocol_js_1.createA2AResponse; } });
+Object.defineProperty(exports, "createA2AError", { enumerable: true, get: function () { return protocol_js_1.createA2AError; } });
+Object.defineProperty(exports, "createTaskRequest", { enumerable: true, get: function () { return protocol_js_1.createTaskRequest; } });
+Object.defineProperty(exports, "createCapabilityAdvertisement", { enumerable: true, get: function () { return protocol_js_1.createCapabilityAdvertisement; } });
+// Client
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "A2AClient", { enumerable: true, get: function () { return client_js_1.A2AClient; } });
+Object.defineProperty(exports, "generateA2AKeyPair", { enumerable: true, get: function () { return client_js_1.generateA2AKeyPair; } });
+// Server
+var server_js_1 = require("./server.js");
+Object.defineProperty(exports, "A2AServer", { enumerable: true, get: function () { return server_js_1.A2AServer; } });