opc-agent 0.2.0 → 0.4.0

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

package/dist/core/hitl.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'events';
+export interface ApprovalRequest {
+    id: string;
+    action: string;
+    description: string;
+    context?: Record<string, unknown>;
+    timeoutMs: number;
+    defaultAction: 'approve' | 'deny';
+    createdAt: number;
+}
+export interface ApprovalResponse {
+    requestId: string;
+    decision: 'approve' | 'deny';
+    respondedBy?: string;
+    respondedAt: number;
+    timedOut: boolean;
+}
+export type ApprovalHandler = (request: ApprovalRequest) => Promise<ApprovalResponse>;
+export interface HITLConfig {
+    /** Actions that always require approval */
+    requireApproval: string[];
+    /** Default timeout in ms */
+    defaultTimeoutMs: number;
+    /** Default action on timeout */
+    defaultAction: 'approve' | 'deny';
+}
+export declare class HITLManager extends EventEmitter {
+    private config;
+    private handler;
+    private pending;
+    private logger;
+    constructor(config?: Partial<HITLConfig>);
+    setHandler(handler: ApprovalHandler): void;
+    needsApproval(action: string): boolean;
+    requestApproval(action: string, description: string, context?: Record<string, unknown>): Promise<ApprovalResponse>;
+    respond(requestId: string, decision: 'approve' | 'deny', respondedBy?: string): boolean;
+    getPending(): ApprovalRequest[];
+    private createTimeout;
+    private timeoutResponse;
+}
+//# sourceMappingURL=hitl.d.ts.map

package/dist/core/hitl.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HITLManager = void 0;
+const events_1 = require("events");
+const logger_1 = require("./logger");
+// ── HITL Manager ────────────────────────────────────────────
+class HITLManager extends events_1.EventEmitter {
+    config;
+    handler = null;
+    pending = new Map();
+    logger = new logger_1.Logger('hitl');
+    constructor(config) {
+        super();
+        this.config = {
+            requireApproval: config?.requireApproval ?? [],
+            defaultTimeoutMs: config?.defaultTimeoutMs ?? 60000,
+            defaultAction: config?.defaultAction ?? 'deny',
+        };
+    }
+    setHandler(handler) {
+        this.handler = handler;
+    }
+    needsApproval(action) {
+        if (this.config.requireApproval.includes('*'))
+            return true;
+        return this.config.requireApproval.includes(action);
+    }
+    async requestApproval(action, description, context) {
+        const request = {
+            id: `hitl_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            action,
+            description,
+            context,
+            timeoutMs: this.config.defaultTimeoutMs,
+            defaultAction: this.config.defaultAction,
+            createdAt: Date.now(),
+        };
+        this.emit('approval:requested', request);
+        this.logger.info('Approval requested', { id: request.id, action });
+        if (this.handler) {
+            try {
+                const response = await Promise.race([
+                    this.handler(request),
+                    this.createTimeout(request),
+                ]);
+                this.emit('approval:responded', response);
+                return response;
+            }
+            catch {
+                return this.timeoutResponse(request);
+            }
+        }
+        // No handler: wait for manual response via respond()
+        return new Promise((resolve) => {
+            this.pending.set(request.id, { request, resolve });
+            setTimeout(() => {
+                if (this.pending.has(request.id)) {
+                    this.pending.delete(request.id);
+                    const response = this.timeoutResponse(request);
+                    this.emit('approval:timeout', response);
+                    resolve(response);
+                }
+            }, request.timeoutMs);
+        });
+    }
+    respond(requestId, decision, respondedBy) {
+        const entry = this.pending.get(requestId);
+        if (!entry)
+            return false;
+        this.pending.delete(requestId);
+        const response = {
+            requestId,
+            decision,
+            respondedBy,
+            respondedAt: Date.now(),
+            timedOut: false,
+        };
+        entry.resolve(response);
+        this.emit('approval:responded', response);
+        return true;
+    }
+    getPending() {
+        return Array.from(this.pending.values()).map(e => e.request);
+    }
+    createTimeout(request) {
+        return new Promise((resolve) => {
+            setTimeout(() => resolve(this.timeoutResponse(request)), request.timeoutMs);
+        });
+    }
+    timeoutResponse(request) {
+        return {
+            requestId: request.id,
+            decision: request.defaultAction,
+            respondedAt: Date.now(),
+            timedOut: true,
+        };
+    }
+}
+exports.HITLManager = HITLManager;
+//# sourceMappingURL=hitl.js.map

package/dist/core/performance.d.ts

@@ -0,0 +1,50 @@
+export interface PooledConnection {
+    id: string;
+    provider: string;
+    createdAt: number;
+    lastUsedAt: number;
+    inUse: boolean;
+}
+export declare class ConnectionPool {
+    private pool;
+    private maxPerProvider;
+    private ttlMs;
+    private logger;
+    constructor(maxPerProvider?: number, ttlMs?: number);
+    acquire(provider: string): PooledConnection;
+    release(id: string): void;
+    getStats(): Record<string, {
+        total: number;
+        inUse: number;
+    }>;
+    drain(): void;
+}
+export interface BatchRequest<T> {
+    payload: T;
+    resolve: (result: unknown) => void;
+    reject: (error: Error) => void;
+}
+export declare class RequestBatcher<T> {
+    private queue;
+    private timer;
+    private maxBatchSize;
+    private delayMs;
+    private processor;
+    private logger;
+    constructor(processor: (batch: T[]) => Promise<unknown[]>, maxBatchSize?: number, delayMs?: number);
+    add(payload: T): Promise<unknown>;
+    flush(): Promise<void>;
+    get pending(): number;
+}
+export declare class LazyLoader<T> {
+    private cache;
+    private loaders;
+    register(name: string, loader: () => Promise<T>): void;
+    get(name: string): Promise<T>;
+    isLoaded(name: string): boolean;
+    evict(name: string): void;
+    clear(): void;
+    get loadedCount(): number;
+    get registeredCount(): number;
+}
+//# sourceMappingURL=performance.d.ts.map

package/dist/core/performance.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyLoader = exports.RequestBatcher = exports.ConnectionPool = void 0;
+const logger_1 = require("../core/logger");
+class ConnectionPool {
+    pool = new Map();
+    maxPerProvider;
+    ttlMs;
+    logger = new logger_1.Logger('connection-pool');
+    constructor(maxPerProvider = 5, ttlMs = 300000) {
+        this.maxPerProvider = maxPerProvider;
+        this.ttlMs = ttlMs;
+    }
+    acquire(provider) {
+        const connections = this.pool.get(provider) ?? [];
+        // Cleanup expired
+        const now = Date.now();
+        const active = connections.filter(c => now - c.createdAt < this.ttlMs);
+        // Find available
+        const available = active.find(c => !c.inUse);
+        if (available) {
+            available.inUse = true;
+            available.lastUsedAt = now;
+            return available;
+        }
+        // Create new if under limit
+        if (active.length < this.maxPerProvider) {
+            const conn = {
+                id: `conn_${now}_${Math.random().toString(36).slice(2, 8)}`,
+                provider,
+                createdAt: now,
+                lastUsedAt: now,
+                inUse: true,
+            };
+            active.push(conn);
+            this.pool.set(provider, active);
+            return conn;
+        }
+        // Wait for one (return oldest used for now)
+        const oldest = active.sort((a, b) => a.lastUsedAt - b.lastUsedAt)[0];
+        oldest.inUse = true;
+        oldest.lastUsedAt = now;
+        return oldest;
+    }
+    release(id) {
+        for (const connections of this.pool.values()) {
+            const conn = connections.find(c => c.id === id);
+            if (conn) {
+                conn.inUse = false;
+                return;
+            }
+        }
+    }
+    getStats() {
+        const stats = {};
+        for (const [provider, connections] of this.pool) {
+            stats[provider] = {
+                total: connections.length,
+                inUse: connections.filter(c => c.inUse).length,
+            };
+        }
+        return stats;
+    }
+    drain() {
+        this.pool.clear();
+    }
+}
+exports.ConnectionPool = ConnectionPool;
+class RequestBatcher {
+    queue = [];
+    timer = null;
+    maxBatchSize;
+    delayMs;
+    processor;
+    logger = new logger_1.Logger('batcher');
+    constructor(processor, maxBatchSize = 10, delayMs = 50) {
+        this.processor = processor;
+        this.maxBatchSize = maxBatchSize;
+        this.delayMs = delayMs;
+    }
+    add(payload) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ payload, resolve, reject });
+            if (this.queue.length >= this.maxBatchSize) {
+                this.flush();
+            }
+            else if (!this.timer) {
+                this.timer = setTimeout(() => this.flush(), this.delayMs);
+            }
+        });
+    }
+    async flush() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.queue.length === 0)
+            return;
+        const batch = this.queue.splice(0, this.maxBatchSize);
+        try {
+            const results = await this.processor(batch.map(b => b.payload));
+            batch.forEach((req, i) => req.resolve(results[i]));
+        }
+        catch (err) {
+            batch.forEach(req => req.reject(err));
+        }
+    }
+    get pending() {
+        return this.queue.length;
+    }
+}
+exports.RequestBatcher = RequestBatcher;
+// ── Lazy Loader ─────────────────────────────────────────────
+class LazyLoader {
+    cache = new Map();
+    loaders = new Map();
+    register(name, loader) {
+        this.loaders.set(name, loader);
+    }
+    async get(name) {
+        const cached = this.cache.get(name);
+        if (cached)
+            return cached;
+        const loader = this.loaders.get(name);
+        if (!loader)
+            throw new Error(`No loader registered for "${name}"`);
+        const instance = await loader();
+        this.cache.set(name, instance);
+        return instance;
+    }
+    isLoaded(name) {
+        return this.cache.has(name);
+    }
+    evict(name) {
+        this.cache.delete(name);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    get loadedCount() {
+        return this.cache.size;
+    }
+    get registeredCount() {
+        return this.loaders.size;
+    }
+}
+exports.LazyLoader = LazyLoader;
+//# sourceMappingURL=performance.js.map

package/dist/core/room.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from 'events';
+import type { Message, IAgent } from './types';
+export interface RoomMessage {
+    from: string;
+    to?: string;
+    topic?: string;
+    message: Message;
+}
+export declare class Room extends EventEmitter {
+    readonly name: string;
+    private agents;
+    private subscriptions;
+    constructor(name: string);
+    addAgent(agent: IAgent): void;
+    removeAgent(name: string): void;
+    getAgents(): string[];
+    subscribe(agentName: string, topic: string): void;
+    unsubscribe(agentName: string, topic: string): void;
+    getSubscribers(topic: string): string[];
+    send(roomMessage: RoomMessage): Promise<Message[]>;
+    broadcast(from: string, content: string): Promise<Message[]>;
+    publishToTopic(from: string, topic: string, content: string): Promise<Message[]>;
+}
+//# sourceMappingURL=room.d.ts.map

package/dist/core/room.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Room = void 0;
+const events_1 = require("events");
+class Room extends events_1.EventEmitter {
+    name;
+    agents = new Map();
+    subscriptions = new Map(); // topic -> agentNames
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+    addAgent(agent) {
+        this.agents.set(agent.name, agent);
+        this.emit('agent:join', agent.name);
+    }
+    removeAgent(name) {
+        this.agents.delete(name);
+        // Remove from all subscriptions
+        for (const [, subscribers] of this.subscriptions) {
+            subscribers.delete(name);
+        }
+        this.emit('agent:leave', name);
+    }
+    getAgents() {
+        return Array.from(this.agents.keys());
+    }
+    subscribe(agentName, topic) {
+        if (!this.subscriptions.has(topic)) {
+            this.subscriptions.set(topic, new Set());
+        }
+        this.subscriptions.get(topic).add(agentName);
+    }
+    unsubscribe(agentName, topic) {
+        this.subscriptions.get(topic)?.delete(agentName);
+    }
+    getSubscribers(topic) {
+        return Array.from(this.subscriptions.get(topic) ?? []);
+    }
+    async send(roomMessage) {
+        const responses = [];
+        this.emit('message', roomMessage);
+        if (roomMessage.to) {
+            // Direct message
+            const agent = this.agents.get(roomMessage.to);
+            if (agent) {
+                const response = await agent.handleMessage(roomMessage.message);
+                responses.push(response);
+            }
+        }
+        else if (roomMessage.topic) {
+            // Topic-based pub/sub
+            const subscribers = this.subscriptions.get(roomMessage.topic) ?? new Set();
+            for (const name of subscribers) {
+                if (name === roomMessage.from)
+                    continue;
+                const agent = this.agents.get(name);
+                if (agent) {
+                    const response = await agent.handleMessage(roomMessage.message);
+                    responses.push(response);
+                }
+            }
+        }
+        else {
+            // Broadcast to all except sender
+            for (const [name, agent] of this.agents) {
+                if (name === roomMessage.from)
+                    continue;
+                const response = await agent.handleMessage(roomMessage.message);
+                responses.push(response);
+            }
+        }
+        return responses;
+    }
+    async broadcast(from, content) {
+        const message = {
+            id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            role: 'user',
+            content,
+            timestamp: Date.now(),
+            metadata: { room: this.name, from },
+        };
+        return this.send({ from, message });
+    }
+    async publishToTopic(from, topic, content) {
+        const message = {
+            id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            role: 'user',
+            content,
+            timestamp: Date.now(),
+            metadata: { room: this.name, from, topic },
+        };
+        return this.send({ from, topic, message });
+    }
+}
+exports.Room = Room;
+//# sourceMappingURL=room.js.map

package/dist/core/sandbox.d.ts

@@ -0,0 +1,28 @@
+import type { TrustLevelType } from '../schema/oad';
+export interface SandboxConfig {
+    trustLevel: TrustLevelType;
+    agentDir: string;
+    networkAllowlist?: string[];
+    shellAllowed?: boolean;
+}
+export interface SandboxRestrictions {
+    fileSystem: {
+        read: string[];
+        write: string[];
+    };
+    network: {
+        allowed: string[];
+    };
+    shell: boolean;
+}
+export declare class Sandbox {
+    private config;
+    private restrictions;
+    constructor(config: SandboxConfig);
+    get trustLevel(): TrustLevelType;
+    getRestrictions(): SandboxRestrictions;
+    checkFileAccess(filePath: string, mode: 'read' | 'write'): boolean;
+    checkNetworkAccess(url: string): boolean;
+    checkShellAccess(): boolean;
+}
+//# sourceMappingURL=sandbox.d.ts.map