opc-agent 2.0.0 → 2.0.2

package/dist/plugins/index.js

@@ -7,6 +7,7 @@ exports.createRateLimitPlugin = createRateLimitPlugin;
 const logger_1 = require("../core/logger");
 class PluginManager {
     plugins = new Map();
+    enhancedPlugins = new Map();
     logger = new logger_1.Logger('plugins');
     register(plugin) {
         if (this.plugins.has(plugin.name)) {
@@ -15,19 +16,43 @@ class PluginManager {
         this.plugins.set(plugin.name, plugin);
         this.logger.info(`Plugin registered: ${plugin.name}@${plugin.version}`);
     }
+    /**
+     * Register an enhanced plugin with middleware support (v1.6.0).
+     */
+    registerEnhanced(plugin) {
+        if (this.enhancedPlugins.has(plugin.name)) {
+            this.logger.warn(`Enhanced plugin "${plugin.name}" already registered, replacing`);
+        }
+        this.enhancedPlugins.set(plugin.name, plugin);
+        this.logger.info(`Enhanced plugin registered: ${plugin.name}@${plugin.version}`);
+    }
+    unregisterEnhanced(name) {
+        this.enhancedPlugins.delete(name);
+    }
+    getEnhanced(name) {
+        return this.enhancedPlugins.get(name);
+    }
+    listEnhanced() {
+        return Array.from(this.enhancedPlugins.values());
+    }
     unregister(name) {
         this.plugins.delete(name);
+        this.enhancedPlugins.delete(name);
     }
     get(name) {
         return this.plugins.get(name);
     }
     list() {
-        return Array.from(this.plugins.values()).map(({ name, version, description }) => ({
+        const legacy = Array.from(this.plugins.values()).map(({ name, version, description }) => ({
+            name, version, description,
+        }));
+        const enhanced = Array.from(this.enhancedPlugins.values()).map(({ name, version, description }) => ({
             name, version, description,
         }));
+        return [...legacy, ...enhanced];
     }
     has(name) {
-        return this.plugins.has(name);
+        return this.plugins.has(name) || this.enhancedPlugins.has(name);
     }
     async runHook(hookName, ...args) {
         for (const plugin of this.plugins.values()) {
@@ -45,6 +70,75 @@ class PluginManager {
             }
         }
     }
+    /**
+     * Initialize all plugins (legacy + enhanced).
+     */
+    async initAll(runtime) {
+        await this.runOnInit();
+        for (const plugin of this.enhancedPlugins.values()) {
+            if (plugin.onInit) {
+                try {
+                    await plugin.onInit(runtime);
+                }
+                catch (err) {
+                    this.logger.error(`Enhanced plugin "${plugin.name}" onInit failed`, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Shutdown all plugins (legacy + enhanced).
+     */
+    async shutdownAll() {
+        await this.runOnShutdown();
+        for (const plugin of this.enhancedPlugins.values()) {
+            if (plugin.onShutdown) {
+                try {
+                    await plugin.onShutdown();
+                }
+                catch (err) {
+                    this.logger.error(`Enhanced plugin "${plugin.name}" onShutdown failed`, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Run message through enhanced plugin middleware chain.
+     * Each plugin calls next() to pass to the next plugin.
+     */
+    async runMessageMiddleware(message) {
+        const plugins = Array.from(this.enhancedPlugins.values()).filter(p => p.onMessage);
+        if (plugins.length === 0)
+            return message;
+        let index = 0;
+        const next = async (msg) => {
+            if (index >= plugins.length)
+                return msg;
+            const plugin = plugins[index++];
+            return plugin.onMessage(msg, next);
+        };
+        return next(message);
+    }
+    /**
+     * Run response through enhanced plugin middleware chain.
+     */
+    async runResponseMiddleware(response) {
+        const plugins = Array.from(this.enhancedPlugins.values()).filter(p => p.onResponse);
+        if (plugins.length === 0)
+            return response;
+        let index = 0;
+        const next = async (res) => {
+            if (index >= plugins.length)
+                return res;
+            const plugin = plugins[index++];
+            return plugin.onResponse(res, next);
+        };
+        return next(response);
+    }
     async runOnInit() {
         await this.runHook('onInit');
         await this.runHook('beforeInit');
@@ -62,6 +156,8 @@ class PluginManager {
                 await plugin.hooks.beforeMessage({ content: msg.content });
             }
         }
+        // Also run enhanced middleware
+        msg = await this.runMessageMiddleware(msg);
         return msg;
     }
     async runOnResponse(message, response) {
@@ -76,10 +172,20 @@ class PluginManager {
                 await plugin.hooks.afterMessage({ content: message.content }, { content: resp.content });
             }
         }
+        // Also run enhanced middleware
+        resp = await this.runResponseMiddleware(resp);
         return resp;
     }
     async runOnError(error, context) {
         await this.runHook('onError', error, context);
+        for (const plugin of this.enhancedPlugins.values()) {
+            if (plugin.onError) {
+                try {
+                    plugin.onError(error);
+                }
+                catch (_) { /* ignore */ }
+            }
+        }
     }
     async runOnShutdown() {
         await this.runHook('onShutdown');

package/dist/plugins/logger.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from './index';
+/**
+ * Logger plugin — logs all messages and responses via middleware chain.
+ */
+export declare const loggerPlugin: Plugin;
+//# sourceMappingURL=logger.d.ts.map

package/dist/plugins/logger.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerPlugin = void 0;
+/**
+ * Logger plugin — logs all messages and responses via middleware chain.
+ */
+exports.loggerPlugin = {
+    name: 'logger',
+    version: '1.0.0',
+    description: 'Log all messages and responses',
+    onMessage: async (msg, next) => {
+        console.log(`[${new Date().toISOString()}] IN: ${msg.content?.slice(0, 100)}`);
+        return next(msg);
+    },
+    onResponse: async (res, next) => {
+        console.log(`[${new Date().toISOString()}] OUT: ${res.content?.slice(0, 100)}`);
+        return next(res);
+    },
+};
+//# sourceMappingURL=logger.js.map

package/dist/plugins/rate-limiter.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from './index';
+/**
+ * Rate limiter plugin — limits messages per session using in-memory sliding window.
+ */
+export declare function createRateLimiterPlugin(maxPerMinute?: number): Plugin;
+export declare const rateLimiterPlugin: Plugin;
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/plugins/rate-limiter.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rateLimiterPlugin = void 0;
+exports.createRateLimiterPlugin = createRateLimiterPlugin;
+/**
+ * Rate limiter plugin — limits messages per session using in-memory sliding window.
+ */
+function createRateLimiterPlugin(maxPerMinute = 60) {
+    const sessionTimestamps = new Map();
+    return {
+        name: 'rate-limiter',
+        version: '1.0.0',
+        description: `Rate limit messages per session (${maxPerMinute}/min)`,
+        onMessage: async (msg, next) => {
+            const sessionId = msg.metadata?.sessionId || msg.id || 'default';
+            const now = Date.now();
+            const windowStart = now - 60_000;
+            if (!sessionTimestamps.has(sessionId)) {
+                sessionTimestamps.set(sessionId, []);
+            }
+            const timestamps = sessionTimestamps.get(sessionId);
+            // Remove expired timestamps
+            while (timestamps.length > 0 && timestamps[0] < windowStart) {
+                timestamps.shift();
+            }
+            if (timestamps.length >= maxPerMinute) {
+                throw new Error(`Rate limit exceeded: ${maxPerMinute} messages per minute`);
+            }
+            timestamps.push(now);
+            return next(msg);
+        },
+    };
+}
+exports.rateLimiterPlugin = createRateLimiterPlugin(60);
+//# sourceMappingURL=rate-limiter.js.map

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

@@ -0,0 +1,25 @@
+import type { A2AAgentCard, A2ATask, A2AMessage } from './types';
+export declare class A2AClient {
+    private agentUrl;
+    private auth?;
+    constructor(agentUrl: string, auth?: {
+        scheme: string;
+        token: string;
+    });
+    private getHeaders;
+    private rpc;
+    getAgentCard(): Promise<A2AAgentCard>;
+    sendTask(message: A2AMessage, options?: {
+        taskId?: string;
+        sessionId?: string;
+    }): Promise<A2ATask>;
+    sendTaskSubscribe(message: A2AMessage, onEvent: (event: any) => void, options?: {
+        taskId?: string;
+    }): Promise<void>;
+    getTask(taskId: string): Promise<A2ATask>;
+    cancelTask(taskId: string): Promise<A2ATask>;
+    sendText(text: string, options?: {
+        taskId?: string;
+    }): Promise<string>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/protocols/a2a/client.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2AClient = void 0;
+class A2AClient {
+    agentUrl;
+    auth;
+    constructor(agentUrl, auth) {
+        this.agentUrl = agentUrl.endsWith('/') ? agentUrl.slice(0, -1) : agentUrl;
+        this.auth = auth;
+    }
+    getHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.auth) {
+            if (this.auth.scheme === 'bearer') {
+                headers['Authorization'] = `Bearer ${this.auth.token}`;
+            }
+            else if (this.auth.scheme === 'apiKey') {
+                headers['X-API-Key'] = this.auth.token;
+            }
+        }
+        return headers;
+    }
+    async rpc(method, params) {
+        const body = JSON.stringify({
+            jsonrpc: '2.0',
+            id: `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            method,
+            params,
+        });
+        const res = await fetch(this.agentUrl, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body,
+        });
+        const json = await res.json();
+        if (json.error) {
+            const err = new Error(json.error.message);
+            err.code = json.error.code;
+            throw err;
+        }
+        return json.result;
+    }
+    async getAgentCard() {
+        const res = await fetch(`${this.agentUrl}/.well-known/agent.json`, {
+            headers: this.getHeaders(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to fetch agent card: ${res.status}`);
+        return res.json();
+    }
+    async sendTask(message, options) {
+        return this.rpc('tasks/send', {
+            id: options?.taskId || `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            sessionId: options?.sessionId,
+            message,
+        });
+    }
+    async sendTaskSubscribe(message, onEvent, options) {
+        const body = JSON.stringify({
+            jsonrpc: '2.0',
+            id: `${Date.now()}`,
+            method: 'tasks/sendSubscribe',
+            params: {
+                id: options?.taskId || `task_${Date.now()}`,
+                message,
+            },
+        });
+        const res = await fetch(this.agentUrl, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body,
+        });
+        if (!res.ok || !res.body)
+            throw new Error(`SSE failed: ${res.status}`);
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    try {
+                        onEvent(JSON.parse(line.slice(6)));
+                    }
+                    catch { /* skip malformed */ }
+                }
+            }
+        }
+    }
+    async getTask(taskId) {
+        return this.rpc('tasks/get', { id: taskId });
+    }
+    async cancelTask(taskId) {
+        return this.rpc('tasks/cancel', { id: taskId });
+    }
+    async sendText(text, options) {
+        const task = await this.sendTask({ role: 'user', parts: [{ type: 'text', text }] }, options);
+        // Extract text from last agent message
+        const agentMessages = task.history.filter(m => m.role === 'agent');
+        const last = agentMessages[agentMessages.length - 1];
+        if (!last)
+            return '';
+        return last.parts
+            .filter(p => p.type === 'text')
+            .map(p => p.text)
+            .join('\n');
+    }
+}
+exports.A2AClient = A2AClient;
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,6 @@
+export type { A2AAgentCard, A2AAgentSkill, A2ATask, A2ATaskStatus, A2ATaskState, A2AMessage, A2AMessagePart, A2AArtifact, JsonRpcRequest, JsonRpcResponse, } from './types';
+export { JSON_RPC_ERRORS } from './types';
+export { A2AServer } from './server';
+export { A2AClient } from './client';
+export { oadToAgentCard } from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/protocols/a2a/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oadToAgentCard = exports.A2AClient = exports.A2AServer = exports.JSON_RPC_ERRORS = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "JSON_RPC_ERRORS", { enumerable: true, get: function () { return types_1.JSON_RPC_ERRORS; } });
+var server_1 = require("./server");
+Object.defineProperty(exports, "A2AServer", { enumerable: true, get: function () { return server_1.A2AServer; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "A2AClient", { enumerable: true, get: function () { return client_1.A2AClient; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "oadToAgentCard", { enumerable: true, get: function () { return utils_1.oadToAgentCard; } });
+//# sourceMappingURL=index.js.map

package/dist/protocols/a2a/server.d.ts

@@ -0,0 +1,41 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import type { A2AAgentCard, A2ATask, A2AMessage } from './types';
+export declare class A2AServer {
+    private tasks;
+    private agent;
+    private card;
+    private server;
+    private taskHandler?;
+    constructor(agent: any, config?: {
+        card?: Partial<A2AAgentCard>;
+        oad?: any;
+        port?: number;
+    });
+    /** Set custom handler for processing tasks */
+    onTask(handler: (task: A2ATask) => Promise<A2ATask>): void;
+    getAgentCard(): A2AAgentCard;
+    getTasks(): A2ATask[];
+    /** Mount A2A routes on an existing HTTP server handler */
+    mount(handleRequest: (req: IncomingMessage, res: ServerResponse) => void): (req: IncomingMessage, res: ServerResponse) => void;
+    start(port: number): Promise<void>;
+    stop(): Promise<void>;
+    private handleHTTP;
+    private handleRPC;
+    tasksSend(params: {
+        id: string;
+        sessionId?: string;
+        message: A2AMessage;
+        metadata?: any;
+    }): Promise<A2ATask>;
+    tasksSendSubscribe(params: any, onEvent: (event: any) => void): Promise<void>;
+    tasksGet(params: {
+        id: string;
+        historyLength?: number;
+    }): Promise<A2ATask>;
+    tasksCancel(params: {
+        id: string;
+    }): Promise<A2ATask>;
+    private rpcError;
+    private readBody;
+}
+//# sourceMappingURL=server.d.ts.map