opc-agent 2.0.0 → 2.0.2

package/dist/protocols/agui/server.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGUIServer = exports.AGUIEventEmitter = void 0;
+// ─── AGUIEventEmitter ────────────────────────────────────────
+class AGUIEventEmitter {
+    res;
+    closed = false;
+    constructor(res) {
+        this.res = res;
+    }
+    emit(event) {
+        if (this.closed)
+            return;
+        const data = JSON.stringify(event);
+        this.res.write(`data: ${data}\n\n`);
+    }
+    textStart(messageId) {
+        this.emit({ type: 'TEXT_MESSAGE_START', messageId, role: 'assistant', timestamp: now() });
+    }
+    textContent(messageId, delta) {
+        this.emit({ type: 'TEXT_MESSAGE_CONTENT', messageId, delta, timestamp: now() });
+    }
+    textEnd(messageId) {
+        this.emit({ type: 'TEXT_MESSAGE_END', messageId, timestamp: now() });
+    }
+    toolCallStart(id, name) {
+        this.emit({ type: 'TOOL_CALL_START', toolCallId: id, toolCallName: name, timestamp: now() });
+    }
+    toolCallArgs(id, delta) {
+        this.emit({ type: 'TOOL_CALL_ARGS', toolCallId: id, delta, timestamp: now() });
+    }
+    toolCallEnd(id) {
+        this.emit({ type: 'TOOL_CALL_END', toolCallId: id, timestamp: now() });
+    }
+    stateSnapshot(snapshot) {
+        this.emit({ type: 'STATE_SNAPSHOT', snapshot, timestamp: now() });
+    }
+    stateDelta(delta) {
+        this.emit({ type: 'STATE_DELTA', delta, timestamp: now() });
+    }
+    runStarted(runId, threadId) {
+        this.emit({ type: 'RUN_STARTED', runId, ...(threadId ? { threadId } : {}), timestamp: now() });
+    }
+    runFinished(runId) {
+        this.emit({ type: 'RUN_FINISHED', runId, timestamp: now() });
+    }
+    runError(runId, message, code) {
+        this.emit({ type: 'RUN_ERROR', runId, message, ...(code ? { code } : {}), timestamp: now() });
+    }
+    stepStarted(stepId, stepName) {
+        this.emit({ type: 'STEP_STARTED', stepId, ...(stepName ? { stepName } : {}), timestamp: now() });
+    }
+    stepFinished(stepId) {
+        this.emit({ type: 'STEP_FINISHED', stepId, timestamp: now() });
+    }
+    messagesSnapshot(messages) {
+        this.emit({ type: 'MESSAGES_SNAPSHOT', messages, timestamp: now() });
+    }
+    custom(name, value) {
+        this.emit({ type: 'CUSTOM', name, value, timestamp: now() });
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.res.end();
+    }
+    get isClosed() {
+        return this.closed;
+    }
+}
+exports.AGUIEventEmitter = AGUIEventEmitter;
+// ─── AGUIServer ──────────────────────────────────────────────
+class AGUIServer {
+    agent;
+    path;
+    constructor(agent, config) {
+        this.agent = agent;
+        this.path = config?.path ?? '/agui';
+    }
+    mount(server) {
+        const original = server.listeners('request')[0];
+        server.removeAllListeners('request');
+        server.on('request', (req, res) => {
+            const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+            if (req.method === 'POST' && url.pathname === this.path) {
+                this.handleRun(req, res);
+            }
+            else if (req.method === 'OPTIONS' && url.pathname === this.path) {
+                res.writeHead(204, {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Content-Type',
+                });
+                res.end();
+            }
+            else if (original) {
+                original(req, res);
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not Found');
+            }
+        });
+    }
+    async handleRun(req, res) {
+        let body = '';
+        for await (const chunk of req)
+            body += chunk;
+        let request;
+        try {
+            request = JSON.parse(body);
+            if (!request.messages || !Array.isArray(request.messages)) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'messages array required' }));
+                return;
+            }
+        }
+        catch {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid JSON' }));
+            return;
+        }
+        // Set up SSE
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+        });
+        const emitter = new AGUIEventEmitter(res);
+        const runId = request.runId ?? `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        try {
+            await this.streamResponse(request, emitter, runId);
+        }
+        catch (err) {
+            emitter.runError(runId, err?.message ?? 'Unknown error', 'INTERNAL_ERROR');
+        }
+        finally {
+            emitter.close();
+        }
+    }
+    async streamResponse(request, emitter, runId) {
+        emitter.runStarted(runId, request.threadId);
+        // Convert AG-UI messages to BaseAgent message format
+        const lastUserMsg = [...request.messages].reverse().find(m => m.role === 'user');
+        if (!lastUserMsg) {
+            emitter.runError(runId, 'No user message found', 'BAD_REQUEST');
+            return;
+        }
+        const message = {
+            id: lastUserMsg.id || `msg_${Date.now()}`,
+            role: 'user',
+            content: lastUserMsg.content,
+            timestamp: Date.now(),
+            metadata: {
+                channel: 'agui',
+                sessionId: request.threadId ?? 'agui-default',
+            },
+        };
+        const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        // Try streaming if agent supports it
+        try {
+            emitter.textStart(messageId);
+            let hasChunks = false;
+            for await (const chunk of this.agent.handleMessageStream(message)) {
+                hasChunks = true;
+                emitter.textContent(messageId, chunk);
+            }
+            if (!hasChunks) {
+                // Fallback to non-streaming
+                const response = await this.agent.handleMessage(message);
+                emitter.textContent(messageId, response.content);
+            }
+            emitter.textEnd(messageId);
+        }
+        catch {
+            // Fallback to non-streaming handleMessage
+            emitter.textStart(messageId);
+            const response = await this.agent.handleMessage(message);
+            emitter.textContent(messageId, response.content);
+            emitter.textEnd(messageId);
+        }
+        emitter.runFinished(runId);
+    }
+}
+exports.AGUIServer = AGUIServer;
+function now() {
+    return new Date().toISOString();
+}
+//# sourceMappingURL=server.js.map

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

@@ -0,0 +1,107 @@
+export type AGUIEventType = 'TEXT_MESSAGE_START' | 'TEXT_MESSAGE_CONTENT' | 'TEXT_MESSAGE_END' | 'TOOL_CALL_START' | 'TOOL_CALL_ARGS' | 'TOOL_CALL_END' | 'STATE_SNAPSHOT' | 'STATE_DELTA' | 'MESSAGES_SNAPSHOT' | 'RUN_STARTED' | 'RUN_FINISHED' | 'RUN_ERROR' | 'STEP_STARTED' | 'STEP_FINISHED' | 'CUSTOM';
+export declare const AGUI_EVENT_TYPES: AGUIEventType[];
+export interface AGUIEvent {
+    type: AGUIEventType;
+    timestamp: string;
+    [key: string]: any;
+}
+export interface TextMessageStartEvent extends AGUIEvent {
+    type: 'TEXT_MESSAGE_START';
+    messageId: string;
+    role: 'assistant';
+}
+export interface TextMessageContentEvent extends AGUIEvent {
+    type: 'TEXT_MESSAGE_CONTENT';
+    messageId: string;
+    delta: string;
+}
+export interface TextMessageEndEvent extends AGUIEvent {
+    type: 'TEXT_MESSAGE_END';
+    messageId: string;
+}
+export interface ToolCallStartEvent extends AGUIEvent {
+    type: 'TOOL_CALL_START';
+    toolCallId: string;
+    toolCallName: string;
+}
+export interface ToolCallArgsEvent extends AGUIEvent {
+    type: 'TOOL_CALL_ARGS';
+    toolCallId: string;
+    delta: string;
+}
+export interface ToolCallEndEvent extends AGUIEvent {
+    type: 'TOOL_CALL_END';
+    toolCallId: string;
+}
+export interface StateSnapshotEvent extends AGUIEvent {
+    type: 'STATE_SNAPSHOT';
+    snapshot: Record<string, any>;
+}
+export interface StateDeltaEvent extends AGUIEvent {
+    type: 'STATE_DELTA';
+    delta: any[];
+}
+export interface MessagesSnapshotEvent extends AGUIEvent {
+    type: 'MESSAGES_SNAPSHOT';
+    messages: AGUIMessage[];
+}
+export interface RunStartedEvent extends AGUIEvent {
+    type: 'RUN_STARTED';
+    runId: string;
+    threadId?: string;
+}
+export interface RunFinishedEvent extends AGUIEvent {
+    type: 'RUN_FINISHED';
+    runId: string;
+}
+export interface RunErrorEvent extends AGUIEvent {
+    type: 'RUN_ERROR';
+    runId: string;
+    message: string;
+    code?: string;
+}
+export interface StepStartedEvent extends AGUIEvent {
+    type: 'STEP_STARTED';
+    stepId: string;
+    stepName?: string;
+}
+export interface StepFinishedEvent extends AGUIEvent {
+    type: 'STEP_FINISHED';
+    stepId: string;
+}
+export interface CustomEvent extends AGUIEvent {
+    type: 'CUSTOM';
+    name: string;
+    value: any;
+}
+export interface AGUIMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: AGUIToolCall[];
+}
+export interface AGUIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface AGUIRunRequest {
+    threadId?: string;
+    runId?: string;
+    messages: AGUIMessage[];
+    tools?: AGUIToolDefinition[];
+    context?: any[];
+    forwardedProps?: Record<string, any>;
+}
+export interface AGUIToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, any>;
+}
+export declare function isValidEventType(type: string): type is AGUIEventType;
+//# sourceMappingURL=types.d.ts.map

package/dist/protocols/agui/types.js

@@ -0,0 +1,17 @@
+"use strict";
+// AG-UI Protocol Types — Agent-User Interaction Protocol
+// https://docs.ag-ui.com
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGUI_EVENT_TYPES = void 0;
+exports.isValidEventType = isValidEventType;
+exports.AGUI_EVENT_TYPES = [
+    'TEXT_MESSAGE_START', 'TEXT_MESSAGE_CONTENT', 'TEXT_MESSAGE_END',
+    'TOOL_CALL_START', 'TOOL_CALL_ARGS', 'TOOL_CALL_END',
+    'STATE_SNAPSHOT', 'STATE_DELTA', 'MESSAGES_SNAPSHOT',
+    'RUN_STARTED', 'RUN_FINISHED', 'RUN_ERROR',
+    'STEP_STARTED', 'STEP_FINISHED', 'CUSTOM',
+];
+function isValidEventType(type) {
+    return exports.AGUI_EVENT_TYPES.includes(type);
+}
+//# sourceMappingURL=types.js.map

package/dist/protocols/index.d.ts

@@ -0,0 +1,2 @@
+export * from './agui';
+//# sourceMappingURL=index.d.ts.map

package/dist/protocols/index.js

@@ -0,0 +1,19 @@
+"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 });
+// Protocols barrel export
+__exportStar(require("./agui"), exports);
+//# sourceMappingURL=index.js.map

package/dist/protocols/mcp/agent-tools.d.ts

@@ -0,0 +1,11 @@
+import type { MCPServerToolDefinition, MCPResourceDefinition } from './types';
+/**
+ * Convert an OPC agent into MCP tool definitions.
+ * Works with any agent-like object that has name/handleMessage/brain.
+ */
+export declare function agentToMCPTools(agent: any): MCPServerToolDefinition[];
+/**
+ * Expose agent files and brain pages as MCP resources.
+ */
+export declare function agentToMCPResources(agent: any, agentDir: string): MCPResourceDefinition[];
+//# sourceMappingURL=agent-tools.d.ts.map

package/dist/protocols/mcp/agent-tools.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentToMCPTools = agentToMCPTools;
+exports.agentToMCPResources = agentToMCPResources;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Convert an OPC agent into MCP tool definitions.
+ * Works with any agent-like object that has name/handleMessage/brain.
+ */
+function agentToMCPTools(agent) {
+    const tools = [];
+    const agentName = agent?.name || agent?.config?.name || 'agent';
+    // 1. Chat tool
+    tools.push({
+        name: 'chat',
+        description: `Chat with ${agentName} agent`,
+        inputSchema: {
+            type: 'object',
+            properties: { message: { type: 'string', description: 'Message to send to the agent' } },
+            required: ['message'],
+        },
+        handler: async (args) => {
+            if (typeof agent.handleMessage === 'function') {
+                const result = await agent.handleMessage({
+                    role: 'user', content: args.message, channel: 'mcp',
+                });
+                return typeof result === 'string' ? result : result?.content || JSON.stringify(result);
+            }
+            return `Agent ${agentName} does not support handleMessage`;
+        },
+    });
+    // 2. Memory search
+    tools.push({
+        name: 'memory_search',
+        description: 'Search agent memory/knowledge',
+        inputSchema: {
+            type: 'object',
+            properties: { query: { type: 'string', description: 'Search query' } },
+            required: ['query'],
+        },
+        handler: async (args) => {
+            const brain = agent.brain || agent.memory || agent.memoryStore;
+            if (brain && typeof brain.query === 'function') {
+                return await brain.query(args.query);
+            }
+            if (brain && typeof brain.search === 'function') {
+                return await brain.search(args.query);
+            }
+            return 'Memory search not available';
+        },
+    });
+    // 3. Memory store
+    tools.push({
+        name: 'memory_store',
+        description: 'Store knowledge in agent memory',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: { type: 'string', description: 'Identifier/key for the memory entry' },
+                content: { type: 'string', description: 'Content to store' },
+            },
+            required: ['slug', 'content'],
+        },
+        handler: async (args) => {
+            const brain = agent.brain || agent.memory || agent.memoryStore;
+            if (brain && typeof brain.put === 'function') {
+                await brain.put(args.slug, args.content);
+                return `Stored: ${args.slug}`;
+            }
+            if (brain && typeof brain.store === 'function') {
+                await brain.store(args.slug, args.content);
+                return `Stored: ${args.slug}`;
+            }
+            return 'Memory store not available';
+        },
+    });
+    // 4. Expose agent skills as individual tools
+    const skills = agent.skills || agent.skillRegistry?.list?.() || [];
+    for (const skill of Array.isArray(skills) ? skills : []) {
+        const skillName = skill.name || skill.id;
+        if (!skillName)
+            continue;
+        tools.push({
+            name: `skill_${skillName}`,
+            description: skill.description || `Execute ${skillName} skill`,
+            inputSchema: skill.inputSchema || {
+                type: 'object',
+                properties: { input: { type: 'string' } },
+                required: ['input'],
+            },
+            handler: async (args) => {
+                if (typeof skill.execute === 'function') {
+                    return await skill.execute(args);
+                }
+                return `Skill ${skillName} not executable`;
+            },
+        });
+    }
+    return tools;
+}
+/**
+ * Expose agent files and brain pages as MCP resources.
+ */
+function agentToMCPResources(agent, agentDir) {
+    const resources = [];
+    // Standard agent files
+    const standardFiles = [
+        { name: 'SOUL.md', desc: 'Agent personality and identity' },
+        { name: 'CONTEXT.md', desc: 'Agent context' },
+        { name: 'AGENTS.md', desc: 'Agent instructions' },
+        { name: 'USER.md', desc: 'User profile' },
+        { name: 'agent.yaml', desc: 'Agent OAD configuration' },
+    ];
+    for (const file of standardFiles) {
+        const filePath = (0, path_1.join)(agentDir, file.name);
+        if ((0, fs_1.existsSync)(filePath)) {
+            resources.push({
+                uri: `agent:///${file.name}`,
+                name: file.name,
+                description: file.desc,
+                mimeType: file.name.endsWith('.yaml') ? 'text/yaml' : 'text/markdown',
+                handler: async () => (0, fs_1.readFileSync)(filePath, 'utf-8'),
+            });
+        }
+    }
+    return resources;
+}
+//# sourceMappingURL=agent-tools.js.map

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

@@ -0,0 +1,5 @@
+export type { MCPServerConfig, MCPServerToolDefinition, MCPResourceDefinition, MCPPromptDefinition, MCPPromptArgument, MCPPromptMessage, JsonRpcRequest, JsonRpcResponse, } from './types';
+export { MCP_ERRORS } from './types';
+export { MCPServer } from './server';
+export { agentToMCPTools, agentToMCPResources } from './agent-tools';
+//# sourceMappingURL=index.d.ts.map

package/dist/protocols/mcp/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentToMCPResources = exports.agentToMCPTools = exports.MCPServer = exports.MCP_ERRORS = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "MCP_ERRORS", { enumerable: true, get: function () { return types_1.MCP_ERRORS; } });
+var server_1 = require("./server");
+Object.defineProperty(exports, "MCPServer", { enumerable: true, get: function () { return server_1.MCPServer; } });
+var agent_tools_1 = require("./agent-tools");
+Object.defineProperty(exports, "agentToMCPTools", { enumerable: true, get: function () { return agent_tools_1.agentToMCPTools; } });
+Object.defineProperty(exports, "agentToMCPResources", { enumerable: true, get: function () { return agent_tools_1.agentToMCPResources; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,31 @@
+import type { MCPServerConfig, MCPServerToolDefinition, MCPResourceDefinition, MCPPromptDefinition, JsonRpcRequest, JsonRpcResponse } from './types';
+export declare class MCPServer {
+    private config;
+    private tools;
+    private resources;
+    private prompts;
+    private sseClients;
+    private httpServer;
+    constructor(config: MCPServerConfig);
+    addTool(tool: MCPServerToolDefinition): void;
+    removeTool(name: string): void;
+    addResource(resource: MCPResourceDefinition): void;
+    removeResource(uri: string): void;
+    addPrompt(prompt: MCPPromptDefinition): void;
+    getToolCount(): number;
+    getResourceCount(): number;
+    getPromptCount(): number;
+    getConnectedClients(): number;
+    /** Serve over stdio — one JSON-RPC message per line */
+    serveStdio(): Promise<void>;
+    /** Serve over HTTP + SSE */
+    serveHTTP(port: number): Promise<void>;
+    /** Mount on existing HTTP server at a path prefix */
+    mount(server: any, path?: string): void;
+    stop(): void;
+    private handleHTTP;
+    handleMessage(msg: JsonRpcRequest): Promise<JsonRpcResponse | null>;
+    private rpcResult;
+    private rpcError;
+}
+//# sourceMappingURL=server.d.ts.map