opc-agent 0.3.0 → 0.4.0

package/dist/channels/voice.d.ts

@@ -0,0 +1,43 @@
+import { BaseChannel } from './index';
+export interface STTProvider {
+    name: string;
+    transcribe(audio: Buffer, options?: STTOptions): Promise<string>;
+}
+export interface TTSProvider {
+    name: string;
+    synthesize(text: string, options?: TTSOptions): Promise<Buffer>;
+}
+export interface STTOptions {
+    language?: string;
+    model?: string;
+}
+export interface TTSOptions {
+    voice?: string;
+    speed?: number;
+    language?: string;
+}
+export interface VoiceChannelConfig {
+    sttProvider?: STTProvider;
+    ttsProvider?: TTSProvider;
+    sampleRate?: number;
+    language?: string;
+}
+export declare class VoiceChannel extends BaseChannel {
+    type: string;
+    private config;
+    private logger;
+    private running;
+    constructor(config?: VoiceChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    /** Process audio input: STT → Agent → TTS */
+    processAudio(audio: Buffer): Promise<{
+        text: string;
+        response: string;
+        audioResponse?: Buffer;
+    }>;
+    setSTTProvider(provider: STTProvider): void;
+    setTTSProvider(provider: TTSProvider): void;
+}
+//# sourceMappingURL=voice.d.ts.map

package/dist/channels/voice.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceChannel = void 0;
+const index_1 = require("./index");
+const logger_1 = require("../core/logger");
+// ── Voice Channel ───────────────────────────────────────────
+class VoiceChannel extends index_1.BaseChannel {
+    type = 'voice';
+    config;
+    logger = new logger_1.Logger('voice-channel');
+    running = false;
+    constructor(config) {
+        super();
+        this.config = config ?? {};
+    }
+    async start() {
+        this.running = true;
+        this.logger.info('Voice channel started', {
+            stt: this.config.sttProvider?.name ?? 'none',
+            tts: this.config.ttsProvider?.name ?? 'none',
+        });
+    }
+    async stop() {
+        this.running = false;
+        this.logger.info('Voice channel stopped');
+    }
+    isRunning() {
+        return this.running;
+    }
+    /** Process audio input: STT → Agent → TTS */
+    async processAudio(audio) {
+        if (!this.handler)
+            throw new Error('No message handler set');
+        // STT
+        let text;
+        if (this.config.sttProvider) {
+            text = await this.config.sttProvider.transcribe(audio, { language: this.config.language });
+        }
+        else {
+            text = audio.toString('utf-8'); // Fallback: treat as text
+        }
+        this.logger.debug('STT result', { text });
+        // Create message and send to agent
+        const message = {
+            id: `voice_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            role: 'user',
+            content: text,
+            timestamp: Date.now(),
+            metadata: { channel: 'voice' },
+        };
+        const response = await this.handler(message);
+        // TTS
+        let audioResponse;
+        if (this.config.ttsProvider) {
+            audioResponse = await this.config.ttsProvider.synthesize(response.content, { language: this.config.language });
+        }
+        return { text, response: response.content, audioResponse };
+    }
+    setSTTProvider(provider) {
+        this.config.sttProvider = provider;
+    }
+    setTTSProvider(provider) {
+        this.config.ttsProvider = provider;
+    }
+}
+exports.VoiceChannel = VoiceChannel;
+//# sourceMappingURL=voice.js.map

package/dist/channels/webhook.d.ts

@@ -0,0 +1,40 @@
+import { BaseChannel } from './index';
+export interface WebhookConfig {
+    port?: number;
+    path?: string;
+    secret?: string;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+    outgoing?: WebhookOutgoing[];
+}
+export interface WebhookOutgoing {
+    name: string;
+    url: string;
+    secret?: string;
+    events: string[];
+}
+export interface WebhookPayload {
+    event: string;
+    data: unknown;
+    timestamp: number;
+    id: string;
+}
+export declare class WebhookChannel extends BaseChannel {
+    type: string;
+    private config;
+    private server;
+    private logger;
+    private outgoing;
+    constructor(config?: WebhookConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Send a webhook to outgoing endpoints */
+    send(event: string, data: unknown): Promise<void>;
+    private sendWithRetry;
+    private httpPost;
+    private readBody;
+    verifySignature(body: string, signature: string, secret: string): boolean;
+    createSignature(body: string, secret: string): string;
+    addOutgoing(outgoing: WebhookOutgoing): void;
+}
+//# sourceMappingURL=webhook.d.ts.map

package/dist/channels/webhook.js

@@ -0,0 +1,193 @@
+"use strict";
+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.WebhookChannel = void 0;
+const index_1 = require("./index");
+const logger_1 = require("../core/logger");
+const http = __importStar(require("http"));
+const crypto = __importStar(require("crypto"));
+// ── Webhook Channel ─────────────────────────────────────────
+class WebhookChannel extends index_1.BaseChannel {
+    type = 'webhook';
+    config;
+    server = null;
+    logger = new logger_1.Logger('webhook-channel');
+    outgoing = [];
+    constructor(config) {
+        super();
+        this.config = config ?? {};
+        this.outgoing = config?.outgoing ?? [];
+    }
+    async start() {
+        const port = this.config.port ?? 3100;
+        const path = this.config.path ?? '/webhook';
+        this.server = http.createServer(async (req, res) => {
+            if (req.url !== path || req.method !== 'POST') {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+            try {
+                const body = await this.readBody(req);
+                // Verify signature if secret configured
+                if (this.config.secret) {
+                    const signature = req.headers['x-webhook-signature'];
+                    if (!this.verifySignature(body, signature, this.config.secret)) {
+                        res.writeHead(401);
+                        res.end('Invalid signature');
+                        return;
+                    }
+                }
+                const payload = JSON.parse(body);
+                const message = {
+                    id: payload.id ?? `wh_${Date.now()}`,
+                    role: 'user',
+                    content: typeof payload.data === 'string' ? payload.data : JSON.stringify(payload.data),
+                    timestamp: payload.timestamp ?? Date.now(),
+                    metadata: { channel: 'webhook', event: payload.event },
+                };
+                if (this.handler) {
+                    const response = await this.handler(message);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ status: 'ok', response: response.content }));
+                }
+                else {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ status: 'ok' }));
+                }
+            }
+            catch (err) {
+                this.logger.error('Webhook error', { error: err.message });
+                res.writeHead(500);
+                res.end('Internal error');
+            }
+        });
+        return new Promise((resolve) => {
+            this.server.listen(port, () => {
+                this.logger.info('Webhook channel started', { port, path });
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    this.logger.info('Webhook channel stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /** Send a webhook to outgoing endpoints */
+    async send(event, data) {
+        const targets = this.outgoing.filter(o => o.events.includes(event) || o.events.includes('*'));
+        for (const target of targets) {
+            const payload = {
+                event,
+                data,
+                timestamp: Date.now(),
+                id: `wh_out_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            };
+            await this.sendWithRetry(target, payload);
+        }
+    }
+    async sendWithRetry(target, payload) {
+        const maxRetries = this.config.retryAttempts ?? 3;
+        const retryDelay = this.config.retryDelayMs ?? 1000;
+        const body = JSON.stringify(payload);
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                await this.httpPost(target.url, body, target.secret);
+                return;
+            }
+            catch (err) {
+                if (attempt === maxRetries) {
+                    this.logger.error('Webhook delivery failed', { target: target.name, error: err.message });
+                    throw err;
+                }
+                await new Promise(r => setTimeout(r, retryDelay * Math.pow(2, attempt)));
+            }
+        }
+    }
+    httpPost(url, body, secret) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(url);
+            const headers = { 'Content-Type': 'application/json' };
+            if (secret) {
+                headers['x-webhook-signature'] = this.createSignature(body, secret);
+            }
+            const req = http.request({ hostname: urlObj.hostname, port: urlObj.port, path: urlObj.pathname, method: 'POST', headers }, (res) => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                }
+                res.resume();
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', (c) => chunks.push(c));
+            req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+            req.on('error', reject);
+        });
+    }
+    verifySignature(body, signature, secret) {
+        if (!signature)
+            return false;
+        const expected = this.createSignature(body, secret);
+        if (signature.length !== expected.length)
+            return false;
+        return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+    }
+    createSignature(body, secret) {
+        return crypto.createHmac('sha256', secret).update(body).digest('hex');
+    }
+    addOutgoing(outgoing) {
+        this.outgoing.push(outgoing);
+    }
+}
+exports.WebhookChannel = WebhookChannel;
+//# sourceMappingURL=webhook.js.map

package/dist/cli.js

@@ -47,8 +47,13 @@ const code_reviewer_1 = require("./templates/code-reviewer");
 const hr_recruiter_1 = require("./templates/hr-recruiter");
 const project_manager_1 = require("./templates/project-manager");
 const content_writer_1 = require("./templates/content-writer");
+const legal_assistant_1 = require("./templates/legal-assistant");
+const financial_advisor_1 = require("./templates/financial-advisor");
+const executive_assistant_1 = require("./templates/executive-assistant");
 const customer_service_2 = require("./templates/customer-service");
 const analytics_1 = require("./analytics");
+const workflow_1 = require("./core/workflow");
+const versioning_1 = require("./core/versioning");
 const program = new commander_1.Command();
 const color = {
     green: (s) => `\x1b[32m${s}\x1b[0m`,
@@ -71,13 +76,16 @@ const icon = {
     file: '📄',
 };
 const TEMPLATES = {
-    'customer-service': { label: 'Customer Service — FAQ + human handoff', factory: customer_service_1.createCustomerServiceConfig },
-    'sales-assistant': { label: 'Sales Assistant — product Q&A + lead capture', factory: sales_assistant_1.createSalesAssistantConfig },
-    'knowledge-base': { label: 'Knowledge Base — RAG with DeepBrain', factory: knowledge_base_1.createKnowledgeBaseConfig },
-    'code-reviewer': { label: 'Code Reviewer — bug detection + style checks', factory: code_reviewer_1.createCodeReviewerConfig },
-    'hr-recruiter': { label: 'HR Recruiter — resume screening + interview scheduling', factory: hr_recruiter_1.createHRRecruiterConfig },
-    'project-manager': { label: 'Project Manager — task tracking + meeting notes', factory: project_manager_1.createProjectManagerConfig },
-    'content-writer': { label: 'Content Writer — blog posts + social media + SEO', factory: content_writer_1.createContentWriterConfig },
+    'customer-service': { label: 'Customer Service - FAQ + human handoff', factory: customer_service_1.createCustomerServiceConfig },
+    'sales-assistant': { label: 'Sales Assistant - product Q&A + lead capture', factory: sales_assistant_1.createSalesAssistantConfig },
+    'knowledge-base': { label: 'Knowledge Base - RAG with DeepBrain', factory: knowledge_base_1.createKnowledgeBaseConfig },
+    'code-reviewer': { label: 'Code Reviewer - bug detection + style checks', factory: code_reviewer_1.createCodeReviewerConfig },
+    'hr-recruiter': { label: 'HR Recruiter - resume screening + interview scheduling', factory: hr_recruiter_1.createHRRecruiterConfig },
+    'project-manager': { label: 'Project Manager - task tracking + meeting notes', factory: project_manager_1.createProjectManagerConfig },
+    'content-writer': { label: 'Content Writer - blog posts + social media + SEO', factory: content_writer_1.createContentWriterConfig },
+    'legal-assistant': { label: 'Legal Assistant - contract review + compliance + legal research', factory: legal_assistant_1.createLegalAssistantConfig },
+    'financial-advisor': { label: 'Financial Advisor - budget analysis + expense tracking + planning', factory: financial_advisor_1.createFinancialAdvisorConfig },
+    'executive-assistant': { label: 'Executive Assistant - calendar + email drafting + meeting prep', factory: executive_assistant_1.createExecutiveAssistantConfig },
 };
 async function prompt(question, defaultValue) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -100,8 +108,8 @@ async function select(question, options) {
 }
 program
     .name('opc')
-    .description('OPC Agent — Open Agent Framework for business workstations')
-    .version('0.3.0');
+    .description('OPC Agent - Open Agent Framework for business workstations')
+    .version('0.4.0');
 program
     .command('init')
     .description('Initialize a new OPC agent project (interactive)')
@@ -109,7 +117,7 @@ program
     .option('-t, --template <template>', 'Template to use')
     .option('-y, --yes', 'Skip prompts, use defaults')
     .action(async (nameArg, opts) => {
-    console.log(`\n${icon.rocket} ${color.bold('OPC Agent — Create New Project')}\n`);
+    console.log(`\n${icon.rocket} ${color.bold('OPC Agent - Create New Project')}\n`);
     const name = opts.yes ? (nameArg ?? 'my-agent') : (nameArg ?? await prompt('Project name', 'my-agent'));
     const template = opts.yes
         ? (opts.template ?? 'customer-service')
@@ -126,7 +134,7 @@ program
     fs.writeFileSync(path.join(dir, 'oad.yaml'), yaml.dump(config, { lineWidth: 120 }));
     fs.writeFileSync(path.join(dir, 'README.md'), `# ${name}\n\nCreated with OPC Agent using the \`${template}\` template.\n\n## Run\n\n\`\`\`bash\nopc run\n\`\`\`\n`);
     console.log(`\n${icon.success} Created agent project: ${color.bold(name + '/')}`);
-    console.log(`   ${icon.file} oad.yaml — Agent definition`);
+    console.log(`   ${icon.file} oad.yaml - Agent definition`);
     console.log(`   ${icon.file} README.md`);
     console.log(`\n   Template: ${color.cyan(template)}`);
     console.log(`\n${color.dim('Next:')} cd ${name} && opc run\n`);
@@ -238,7 +246,7 @@ program
     .description('Hot-reload development mode')
     .option('-f, --file <file>', 'OAD file', 'oad.yaml')
     .action(async (opts) => {
-    console.log(`\n${icon.gear} ${color.bold('Development mode')} — watching for changes...\n`);
+    console.log(`\n${icon.gear} ${color.bold('Development mode')} - watching for changes...\n`);
     let runtime = null;
     const startAgent = async () => {
         try {
@@ -263,7 +271,7 @@ program
         if (fs.existsSync(watchPath)) {
             const isDir = fs.statSync(watchPath).isDirectory();
             fs.watch(watchPath, { recursive: isDir }, async (_event, filename) => {
-                console.log(`\n${icon.info} ${color.dim(`Change detected: ${filename}`)} — restarting...`);
+                console.log(`\n${icon.info} ${color.dim(`Change detected: ${filename}`)} - restarting...`);
                 await startAgent();
             });
         }
@@ -376,5 +384,79 @@ program
     console.log(`  Uptime:             ${Math.round(snap.uptime / 1000)}s`);
     console.log(`\n  ${color.dim('Run an agent to collect analytics data.')}\n`);
 });
+// 🔄 Workflow commands ────────────────────────────────────────
+const workflowCmd = program.command('workflow').description('Manage workflows');
+workflowCmd
+    .command('run')
+    .description('Run a workflow defined in OAD')
+    .argument('<name>', 'Workflow name')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (name, opts) => {
+    console.log(`\n${icon.gear} Running workflow "${color.bold(name)}"...`);
+    const runtime = new runtime_1.AgentRuntime();
+    const config = await runtime.loadConfig(opts.file);
+    const workflows = config.spec.workflows ?? [];
+    const wfDef = workflows.find((w) => w.name === name);
+    if (!wfDef) {
+        console.error(`${icon.error} Workflow "${name}" not found in OAD.`);
+        process.exit(1);
+    }
+    const engine = new workflow_1.WorkflowEngine();
+    engine.registerWorkflow(wfDef);
+    console.log(`${icon.success} Workflow "${name}" loaded with ${wfDef.steps?.length ?? 0} steps.`);
+    console.log(`${color.dim('   Workflow execution requires a running agent context.')}\n`);
+});
+workflowCmd
+    .command('list')
+    .description('List workflows in OAD')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (opts) => {
+    const runtime = new runtime_1.AgentRuntime();
+    const config = await runtime.loadConfig(opts.file);
+    const workflows = config.spec.workflows ?? [];
+    console.log(`\n${icon.gear} ${color.bold('Workflows')}\n`);
+    if (workflows.length === 0) {
+        console.log(`  ${color.dim('No workflows defined.')}\n`);
+    }
+    else {
+        for (const wf of workflows) {
+            console.log(`  ${color.cyan(wf.name)} - ${wf.description ?? color.dim('(no description)')}`);
+        }
+        console.log();
+    }
+});
+// 📦 Version commands ─────────────────────────────────────────
+const versionCmd = program.command('version').description('Manage agent versions');
+versionCmd
+    .command('list')
+    .description('List saved versions')
+    .action(() => {
+    const vm = new versioning_1.VersionManager();
+    const versions = vm.list();
+    console.log(`\n${icon.gear} ${color.bold('Agent Versions')}\n`);
+    if (versions.length === 0) {
+        console.log(`  ${color.dim('No versions saved.')}\n`);
+    }
+    else {
+        for (const v of versions) {
+            console.log(`  ${color.cyan(v.version)} - ${new Date(v.timestamp).toISOString()} ${v.description ?? ''}`);
+        }
+        console.log();
+    }
+});
+versionCmd
+    .command('rollback')
+    .description('Rollback to a saved version')
+    .argument('<version>', 'Version to rollback to')
+    .action((version) => {
+    const vm = new versioning_1.VersionManager();
+    const oad = vm.rollback(version);
+    if (!oad) {
+        console.error(`${icon.error} Version "${version}" not found.`);
+        process.exit(1);
+    }
+    fs.writeFileSync('oad.yaml', oad);
+    console.log(`${icon.success} Rolled back to version ${color.bold(version)}.`);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/core/a2a.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from 'events';
+import { Room } from './room';
+import type { IAgent } from './types';
+export interface AgentCapability {
+    name: string;
+    description: string;
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+}
+export interface AgentRegistration {
+    agentName: string;
+    capabilities: AgentCapability[];
+    endpoint?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface A2ARequest {
+    id: string;
+    from: string;
+    to: string;
+    capability: string;
+    payload: string;
+    timestamp: number;
+    timeout?: number;
+}
+export interface A2AResponse {
+    requestId: string;
+    from: string;
+    status: 'success' | 'error' | 'timeout';
+    payload?: string;
+    error?: string;
+    timestamp: number;
+}
+export declare class AgentRegistry extends EventEmitter {
+    private registrations;
+    private agents;
+    private room;
+    private logger;
+    constructor(room?: Room);
+    register(agent: IAgent, capabilities: AgentCapability[]): void;
+    unregister(name: string): void;
+    discover(capability?: string): AgentRegistration[];
+    getAgent(name: string): IAgent | undefined;
+    request(req: A2ARequest): Promise<A2AResponse>;
+    call(from: string, to: string, capability: string, payload: string): Promise<A2AResponse>;
+}
+//# sourceMappingURL=a2a.d.ts.map

package/dist/core/a2a.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRegistry = void 0;
+const events_1 = require("events");
+const room_1 = require("./room");
+const logger_1 = require("./logger");
+// ── Agent Registry ──────────────────────────────────────────
+class AgentRegistry extends events_1.EventEmitter {
+    registrations = new Map();
+    agents = new Map();
+    room;
+    logger = new logger_1.Logger('a2a');
+    constructor(room) {
+        super();
+        this.room = room ?? new room_1.Room('a2a-default');
+    }
+    register(agent, capabilities) {
+        const reg = { agentName: agent.name, capabilities };
+        this.registrations.set(agent.name, reg);
+        this.agents.set(agent.name, agent);
+        this.room.addAgent(agent);
+        this.logger.info('Agent registered', { name: agent.name, capabilities: capabilities.map(c => c.name) });
+        this.emit('agent:registered', reg);
+    }
+    unregister(name) {
+        this.registrations.delete(name);
+        this.agents.delete(name);
+        this.room.removeAgent(name);
+        this.emit('agent:unregistered', name);
+    }
+    discover(capability) {
+        const all = Array.from(this.registrations.values());
+        if (!capability)
+            return all;
+        return all.filter(r => r.capabilities.some(c => c.name === capability));
+    }
+    getAgent(name) {
+        return this.agents.get(name);
+    }
+    async request(req) {
+        const agent = this.agents.get(req.to);
+        if (!agent) {
+            return {
+                requestId: req.id,
+                from: req.to,
+                status: 'error',
+                error: `Agent "${req.to}" not found`,
+                timestamp: Date.now(),
+            };
+        }
+        const message = {
+            id: req.id,
+            role: 'user',
+            content: req.payload,
+            timestamp: req.timestamp,
+            metadata: { a2a: true, from: req.from, capability: req.capability },
+        };
+        this.emit('request', req);
+        try {
+            const timeoutMs = req.timeout ?? 30000;
+            const response = await Promise.race([
+                agent.handleMessage(message),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('A2A request timeout')), timeoutMs)),
+            ]);
+            const res = {
+                requestId: req.id,
+                from: req.to,
+                status: 'success',
+                payload: response.content,
+                timestamp: Date.now(),
+            };
+            this.emit('response', res);
+            return res;
+        }
+        catch (err) {
+            const res = {
+                requestId: req.id,
+                from: req.to,
+                status: err.message.includes('timeout') ? 'timeout' : 'error',
+                error: err.message,
+                timestamp: Date.now(),
+            };
+            this.emit('response', res);
+            return res;
+        }
+    }
+    async call(from, to, capability, payload) {
+        return this.request({
+            id: `a2a_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            from,
+            to,
+            capability,
+            payload,
+            timestamp: Date.now(),
+        });
+    }
+}
+exports.AgentRegistry = AgentRegistry;
+//# sourceMappingURL=a2a.js.map