opc-agent 2.0.0 → 2.0.2

package/dist/protocols/a2a/server.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2AServer = void 0;
+const http_1 = require("http");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+class A2AServer {
+    tasks = new Map();
+    agent;
+    card;
+    server;
+    taskHandler;
+    constructor(agent, config) {
+        this.agent = agent;
+        // Build card from OAD if available, then overlay explicit config
+        const baseCard = config?.oad
+            ? (0, utils_1.oadToAgentCard)(config.oad, config?.card?.url || `http://localhost:${config?.port || 3001}`)
+            : {
+                name: agent?.name || 'opc-agent',
+                description: agent?.config?.systemPrompt?.slice(0, 200) || 'OPC Agent',
+                url: `http://localhost:${config?.port || 3001}`,
+                version: '1.0.0',
+                capabilities: { streaming: true, pushNotifications: false, stateTransitionHistory: true },
+                skills: [],
+                defaultInputModes: ['text'],
+                defaultOutputModes: ['text'],
+            };
+        this.card = { ...baseCard, ...config?.card };
+    }
+    /** Set custom handler for processing tasks */
+    onTask(handler) {
+        this.taskHandler = handler;
+    }
+    getAgentCard() {
+        return this.card;
+    }
+    getTasks() {
+        return Array.from(this.tasks.values());
+    }
+    /** Mount A2A routes on an existing HTTP server handler */
+    mount(handleRequest) {
+        return (req, res) => {
+            const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+            // /.well-known/agent.json
+            if (url.pathname === '/.well-known/agent.json' && req.method === 'GET') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(this.card, null, 2));
+                return;
+            }
+            // JSON-RPC endpoint
+            if (url.pathname === '/' && req.method === 'POST') {
+                this.handleHTTP(req, res);
+                return;
+            }
+            // Fall through to original handler
+            handleRequest(req, res);
+        };
+    }
+    async start(port) {
+        this.card.url = `http://localhost:${port}`;
+        return new Promise((resolve) => {
+            this.server = (0, http_1.createServer)((req, res) => {
+                const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+                if (url.pathname === '/.well-known/agent.json' && req.method === 'GET') {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(this.card, null, 2));
+                    return;
+                }
+                if (url.pathname === '/' && req.method === 'POST') {
+                    this.handleHTTP(req, res);
+                    return;
+                }
+                res.writeHead(404);
+                res.end('Not Found');
+            });
+            this.server.listen(port, () => resolve());
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    async handleHTTP(req, res) {
+        const body = await this.readBody(req);
+        let rpcReq;
+        try {
+            rpcReq = JSON.parse(body);
+        }
+        catch {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(this.rpcError(null, types_1.JSON_RPC_ERRORS.PARSE_ERROR, 'Parse error')));
+            return;
+        }
+        if (!rpcReq.jsonrpc || rpcReq.jsonrpc !== '2.0' || !rpcReq.method) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(this.rpcError(rpcReq?.id ?? null, types_1.JSON_RPC_ERRORS.INVALID_REQUEST, 'Invalid Request')));
+            return;
+        }
+        // SSE for streaming
+        if (rpcReq.method === 'tasks/sendSubscribe') {
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+            });
+            try {
+                await this.tasksSendSubscribe(rpcReq.params, (event) => {
+                    res.write(`data: ${JSON.stringify(event)}\n\n`);
+                });
+            }
+            catch (err) {
+                res.write(`data: ${JSON.stringify({ error: err.message })}\n\n`);
+            }
+            res.end();
+            return;
+        }
+        const result = await this.handleRPC(rpcReq.method, rpcReq.params, rpcReq.id);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(result));
+    }
+    async handleRPC(method, params, id) {
+        try {
+            let result;
+            switch (method) {
+                case 'tasks/send':
+                    result = await this.tasksSend(params);
+                    break;
+                case 'tasks/get':
+                    result = await this.tasksGet(params);
+                    break;
+                case 'tasks/cancel':
+                    result = await this.tasksCancel(params);
+                    break;
+                default:
+                    return this.rpcError(id, types_1.JSON_RPC_ERRORS.METHOD_NOT_FOUND, `Method not found: ${method}`);
+            }
+            return { jsonrpc: '2.0', id: id, result };
+        }
+        catch (err) {
+            if (err.code) {
+                return this.rpcError(id, err.code, err.message);
+            }
+            return this.rpcError(id, types_1.JSON_RPC_ERRORS.INTERNAL_ERROR, err.message);
+        }
+    }
+    async tasksSend(params) {
+        const taskId = params.id;
+        const sessionId = params.sessionId || `session_${Date.now()}`;
+        let task = this.tasks.get(taskId);
+        if (!task) {
+            task = {
+                id: taskId,
+                sessionId,
+                status: { state: 'submitted', timestamp: new Date().toISOString() },
+                history: [],
+                artifacts: [],
+                metadata: params.metadata,
+            };
+            this.tasks.set(taskId, task);
+        }
+        // Add user message to history
+        task.history.push(params.message);
+        task.status = { state: 'working', timestamp: new Date().toISOString() };
+        // Process with custom handler or agent
+        if (this.taskHandler) {
+            task = await this.taskHandler(task);
+            this.tasks.set(taskId, task);
+            return task;
+        }
+        // Default: use agent.handleMessage if available
+        if (this.agent?.handleMessage) {
+            try {
+                const textContent = params.message.parts
+                    .filter((p) => p.type === 'text')
+                    .map((p) => p.text)
+                    .join('\n');
+                const response = await this.agent.handleMessage({
+                    id: taskId,
+                    role: 'user',
+                    content: textContent,
+                    timestamp: Date.now(),
+                });
+                const agentMessage = {
+                    role: 'agent',
+                    parts: [{ type: 'text', text: response.content }],
+                };
+                task.history.push(agentMessage);
+                task.status = { state: 'completed', message: agentMessage, timestamp: new Date().toISOString() };
+            }
+            catch (err) {
+                task.status = {
+                    state: 'failed',
+                    message: { role: 'agent', parts: [{ type: 'text', text: err.message }] },
+                    timestamp: new Date().toISOString(),
+                };
+            }
+        }
+        else {
+            // No agent — just mark completed with echo
+            const agentMessage = {
+                role: 'agent',
+                parts: [{ type: 'text', text: 'No agent handler configured' }],
+            };
+            task.history.push(agentMessage);
+            task.status = { state: 'completed', message: agentMessage, timestamp: new Date().toISOString() };
+        }
+        this.tasks.set(taskId, task);
+        return task;
+    }
+    async tasksSendSubscribe(params, onEvent) {
+        const taskId = params.id;
+        const sessionId = params.sessionId || `session_${Date.now()}`;
+        let task = {
+            id: taskId,
+            sessionId,
+            status: { state: 'submitted', timestamp: new Date().toISOString() },
+            history: [],
+            artifacts: [],
+            metadata: params.metadata,
+        };
+        this.tasks.set(taskId, task);
+        task.history.push(params.message);
+        // Emit submitted
+        onEvent({ jsonrpc: '2.0', result: { id: taskId, status: task.status } });
+        task.status = { state: 'working', timestamp: new Date().toISOString() };
+        onEvent({ jsonrpc: '2.0', result: { id: taskId, status: task.status } });
+        // Process
+        if (this.agent?.handleMessage) {
+            const textContent = params.message.parts
+                .filter((p) => p.type === 'text')
+                .map((p) => p.text)
+                .join('\n');
+            try {
+                const response = await this.agent.handleMessage({
+                    id: taskId, role: 'user', content: textContent, timestamp: Date.now(),
+                });
+                const agentMessage = { role: 'agent', parts: [{ type: 'text', text: response.content }] };
+                task.history.push(agentMessage);
+                task.status = { state: 'completed', message: agentMessage, timestamp: new Date().toISOString() };
+            }
+            catch (err) {
+                task.status = { state: 'failed', message: { role: 'agent', parts: [{ type: 'text', text: err.message }] }, timestamp: new Date().toISOString() };
+            }
+        }
+        else {
+            const msg = { role: 'agent', parts: [{ type: 'text', text: 'No agent handler' }] };
+            task.history.push(msg);
+            task.status = { state: 'completed', message: msg, timestamp: new Date().toISOString() };
+        }
+        this.tasks.set(taskId, task);
+        onEvent({ jsonrpc: '2.0', result: { id: taskId, status: task.status, history: task.history } });
+    }
+    async tasksGet(params) {
+        const task = this.tasks.get(params.id);
+        if (!task) {
+            const err = new Error(`Task not found: ${params.id}`);
+            err.code = types_1.JSON_RPC_ERRORS.TASK_NOT_FOUND;
+            throw err;
+        }
+        if (params.historyLength !== undefined) {
+            return { ...task, history: task.history.slice(-params.historyLength) };
+        }
+        return task;
+    }
+    async tasksCancel(params) {
+        const task = this.tasks.get(params.id);
+        if (!task) {
+            const err = new Error(`Task not found: ${params.id}`);
+            err.code = types_1.JSON_RPC_ERRORS.TASK_NOT_FOUND;
+            throw err;
+        }
+        task.status = { state: 'canceled', timestamp: new Date().toISOString() };
+        this.tasks.set(params.id, task);
+        return task;
+    }
+    rpcError(id, code, message) {
+        return { jsonrpc: '2.0', id, error: { code, message } };
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+            req.on('error', reject);
+        });
+    }
+}
+exports.A2AServer = A2AServer;
+//# sourceMappingURL=server.js.map

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

@@ -0,0 +1,91 @@
+export interface A2AAgentCard {
+    name: string;
+    description: string;
+    url: string;
+    version: string;
+    capabilities: {
+        streaming: boolean;
+        pushNotifications: boolean;
+        stateTransitionHistory: boolean;
+    };
+    skills: A2AAgentSkill[];
+    defaultInputModes: string[];
+    defaultOutputModes: string[];
+    authentication?: {
+        schemes: string[];
+    };
+}
+export interface A2AAgentSkill {
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    examples?: string[];
+}
+export interface A2ATask {
+    id: string;
+    sessionId: string;
+    status: A2ATaskStatus;
+    history: A2AMessage[];
+    artifacts: A2AArtifact[];
+    metadata?: Record<string, any>;
+}
+export type A2ATaskState = 'submitted' | 'working' | 'input-required' | 'completed' | 'canceled' | 'failed';
+export interface A2ATaskStatus {
+    state: A2ATaskState;
+    message?: A2AMessage;
+    timestamp: string;
+}
+export interface A2AMessage {
+    role: 'user' | 'agent';
+    parts: A2AMessagePart[];
+}
+export type A2AMessagePart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'file';
+    file: {
+        name: string;
+        mimeType: string;
+        bytes?: string;
+        uri?: string;
+    };
+} | {
+    type: 'data';
+    data: Record<string, any>;
+};
+export interface A2AArtifact {
+    name: string;
+    description?: string;
+    parts: A2AMessagePart[];
+    index: number;
+    append?: boolean;
+    lastChunk?: boolean;
+}
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: string | number;
+    method: string;
+    params?: any;
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: string | number | null;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+export declare const JSON_RPC_ERRORS: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly TASK_NOT_FOUND: -32001;
+    readonly TASK_CANCELED: -32002;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/protocols/a2a/types.js

@@ -0,0 +1,15 @@
+"use strict";
+// Google A2A Protocol Types — https://google.github.io/A2A/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSON_RPC_ERRORS = void 0;
+// Standard JSON-RPC error codes
+exports.JSON_RPC_ERRORS = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+    TASK_NOT_FOUND: -32001,
+    TASK_CANCELED: -32002,
+};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,6 @@
+import type { A2AAgentCard } from './types';
+/**
+ * Convert an OAD (Open Agent Definition) document to an A2A AgentCard.
+ */
+export declare function oadToAgentCard(oad: any, baseUrl: string): A2AAgentCard;
+//# sourceMappingURL=utils.d.ts.map

package/dist/protocols/a2a/utils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oadToAgentCard = oadToAgentCard;
+/**
+ * Convert an OAD (Open Agent Definition) document to an A2A AgentCard.
+ */
+function oadToAgentCard(oad, baseUrl) {
+    const meta = oad?.metadata || {};
+    const spec = oad?.spec || {};
+    // Extract skills from OAD
+    const skills = (spec.skills || []).map((s, i) => ({
+        id: s.id || s.name || `skill-${i}`,
+        name: s.name || `Skill ${i}`,
+        description: s.description || '',
+        tags: s.tags || [],
+        examples: s.examples || [],
+    }));
+    // If no skills defined, create one from the agent description
+    if (skills.length === 0 && (spec.systemPrompt || meta.description)) {
+        skills.push({
+            id: 'default',
+            name: meta.name || 'default',
+            description: meta.description || spec.systemPrompt?.slice(0, 200) || 'General agent capability',
+            tags: ['general'],
+        });
+    }
+    // Detect capabilities from OAD
+    const channels = spec.channels || [];
+    const hasStreaming = channels.some((c) => c.type === 'websocket' || c.type === 'web');
+    const url = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+    return {
+        name: meta.name || 'opc-agent',
+        description: meta.description || '',
+        url,
+        version: meta.version || '1.0.0',
+        capabilities: {
+            streaming: hasStreaming,
+            pushNotifications: false,
+            stateTransitionHistory: true,
+        },
+        skills,
+        defaultInputModes: ['text'],
+        defaultOutputModes: ['text'],
+        authentication: spec.auth ? { schemes: [spec.auth.type || 'bearer'] } : undefined,
+    };
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,10 @@
+import type { AGUIEvent, AGUIRunRequest } from './types';
+export declare class AGUIClient {
+    private endpoint;
+    private controller?;
+    constructor(endpoint: string);
+    run(request: AGUIRunRequest, onEvent: (event: AGUIEvent) => void): Promise<void>;
+    sendText(text: string, onChunk: (text: string) => void): Promise<string>;
+    abort(): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/protocols/agui/client.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGUIClient = void 0;
+const types_1 = require("./types");
+class AGUIClient {
+    endpoint;
+    controller;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+    }
+    async run(request, onEvent) {
+        this.controller = new AbortController();
+        const res = await fetch(this.endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+            signal: this.controller.signal,
+        });
+        if (!res.ok) {
+            throw new Error(`AG-UI request failed: ${res.status} ${res.statusText}`);
+        }
+        if (!res.body) {
+            throw new Error('No response body');
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            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 {
+                            const event = JSON.parse(line.slice(6));
+                            if (event.type && (0, types_1.isValidEventType)(event.type)) {
+                                onEvent(event);
+                            }
+                        }
+                        catch {
+                            // skip malformed events
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async sendText(text, onChunk) {
+        let fullText = '';
+        const request = {
+            messages: [{ id: `msg_${Date.now()}`, role: 'user', content: text }],
+        };
+        await this.run(request, (event) => {
+            if (event.type === 'TEXT_MESSAGE_CONTENT') {
+                const delta = event.delta;
+                fullText += delta;
+                onChunk(delta);
+            }
+        });
+        return fullText;
+    }
+    abort() {
+        this.controller?.abort();
+        this.controller = undefined;
+    }
+}
+exports.AGUIClient = AGUIClient;
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,4 @@
+export * from './types';
+export { AGUIServer, AGUIEventEmitter } from './server';
+export { AGUIClient } from './client';
+//# sourceMappingURL=index.d.ts.map

package/dist/protocols/agui/index.js

@@ -0,0 +1,25 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGUIClient = exports.AGUIEventEmitter = exports.AGUIServer = void 0;
+// AG-UI Protocol — barrel export
+__exportStar(require("./types"), exports);
+var server_1 = require("./server");
+Object.defineProperty(exports, "AGUIServer", { enumerable: true, get: function () { return server_1.AGUIServer; } });
+Object.defineProperty(exports, "AGUIEventEmitter", { enumerable: true, get: function () { return server_1.AGUIEventEmitter; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "AGUIClient", { enumerable: true, get: function () { return client_1.AGUIClient; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,37 @@
+import { IncomingMessage, ServerResponse, Server } from 'http';
+import type { AGUIEvent, AGUIMessage } from './types';
+import type { BaseAgent } from '../../core/agent';
+export declare class AGUIEventEmitter {
+    private res;
+    private closed;
+    constructor(res: ServerResponse);
+    emit(event: AGUIEvent): void;
+    textStart(messageId: string): void;
+    textContent(messageId: string, delta: string): void;
+    textEnd(messageId: string): void;
+    toolCallStart(id: string, name: string): void;
+    toolCallArgs(id: string, delta: string): void;
+    toolCallEnd(id: string): void;
+    stateSnapshot(snapshot: Record<string, any>): void;
+    stateDelta(delta: any[]): void;
+    runStarted(runId: string, threadId?: string): void;
+    runFinished(runId: string): void;
+    runError(runId: string, message: string, code?: string): void;
+    stepStarted(stepId: string, stepName?: string): void;
+    stepFinished(stepId: string): void;
+    messagesSnapshot(messages: AGUIMessage[]): void;
+    custom(name: string, value: any): void;
+    close(): void;
+    get isClosed(): boolean;
+}
+export declare class AGUIServer {
+    private agent;
+    private path;
+    constructor(agent: BaseAgent, config?: {
+        path?: string;
+    });
+    mount(server: Server): void;
+    handleRun(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    private streamResponse;
+}
+//# sourceMappingURL=server.d.ts.map