opc-agent 0.7.0 → 0.8.0

package/dist/channels/email.d.ts

@@ -0,0 +1,69 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+/**
+ * Email Channel — v0.8.0
+ * IMAP polling for incoming emails, SMTP for sending replies.
+ * Parses email threads as conversations.
+ */
+export interface EmailChannelConfig {
+    imap: {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+        tls?: boolean;
+        /** Mailbox to monitor (default: INBOX) */
+        mailbox?: string;
+        /** Poll interval in ms (default: 30000) */
+        pollInterval?: number;
+    };
+    smtp: {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+        tls?: boolean;
+        from: string;
+    };
+    /** Filter: only process emails matching these patterns */
+    filters?: {
+        from?: string[];
+        subject?: string[];
+    };
+}
+export interface EmailMessage {
+    messageId: string;
+    from: string;
+    to: string[];
+    cc?: string[];
+    subject: string;
+    body: string;
+    html?: string;
+    date: Date;
+    inReplyTo?: string;
+    references?: string[];
+    threadId?: string;
+}
+export declare class EmailChannel extends BaseChannel {
+    type: string;
+    private config;
+    private pollTimer;
+    private running;
+    private processedIds;
+    constructor(config: EmailChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Poll IMAP for new emails */
+    private poll;
+    /** Convert email to Message format */
+    private emailToMessage;
+    /** Check if email matches configured filters */
+    private matchesFilters;
+    /** Fetch emails via IMAP — stub for actual implementation */
+    private fetchEmails;
+    /** Send reply via SMTP — stub for actual implementation */
+    sendReply(originalEmail: EmailMessage, reply: Message): Promise<void>;
+    /** Send a standalone email */
+    send(to: string, subject: string, body: string): Promise<void>;
+}
+//# sourceMappingURL=email.d.ts.map

package/dist/channels/email.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailChannel = void 0;
+const index_1 = require("./index");
+class EmailChannel extends index_1.BaseChannel {
+    type = 'email';
+    config;
+    pollTimer = null;
+    running = false;
+    processedIds = new Set();
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        this.running = true;
+        const interval = this.config.imap.pollInterval ?? 30000;
+        // Initial poll
+        await this.poll();
+        // Set up recurring poll
+        this.pollTimer = setInterval(() => {
+            if (this.running)
+                this.poll().catch(console.error);
+        }, interval);
+    }
+    async stop() {
+        this.running = false;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    /** Poll IMAP for new emails */
+    async poll() {
+        // In production, use a library like `imapflow` or `imap-simple`
+        // This is the integration point — actual IMAP connection logic goes here
+        const emails = await this.fetchEmails();
+        for (const email of emails) {
+            if (this.processedIds.has(email.messageId))
+                continue;
+            this.processedIds.add(email.messageId);
+            if (!this.matchesFilters(email))
+                continue;
+            const message = this.emailToMessage(email);
+            if (this.handler) {
+                const reply = await this.handler(message);
+                await this.sendReply(email, reply);
+            }
+        }
+    }
+    /** Convert email to Message format */
+    emailToMessage(email) {
+        return {
+            id: email.messageId,
+            role: 'user',
+            content: email.body,
+            timestamp: email.date.getTime(),
+            metadata: {
+                channel: 'email',
+                from: email.from,
+                to: email.to,
+                subject: email.subject,
+                threadId: email.threadId ?? email.messageId,
+                inReplyTo: email.inReplyTo,
+            },
+        };
+    }
+    /** Check if email matches configured filters */
+    matchesFilters(email) {
+        if (!this.config.filters)
+            return true;
+        if (this.config.filters.from?.length) {
+            const fromMatch = this.config.filters.from.some((f) => email.from.toLowerCase().includes(f.toLowerCase()));
+            if (!fromMatch)
+                return false;
+        }
+        if (this.config.filters.subject?.length) {
+            const subjectMatch = this.config.filters.subject.some((s) => email.subject.toLowerCase().includes(s.toLowerCase()));
+            if (!subjectMatch)
+                return false;
+        }
+        return true;
+    }
+    /** Fetch emails via IMAP — stub for actual implementation */
+    async fetchEmails() {
+        // TODO: Implement with imapflow or similar library
+        // const { ImapFlow } = await import('imapflow');
+        // const client = new ImapFlow({ ...this.config.imap });
+        // await client.connect();
+        // ...
+        return [];
+    }
+    /** Send reply via SMTP — stub for actual implementation */
+    async sendReply(originalEmail, reply) {
+        // TODO: Implement with nodemailer or similar library
+        // const nodemailer = await import('nodemailer');
+        // const transport = nodemailer.createTransport({ ...this.config.smtp });
+        // await transport.sendMail({
+        //   from: this.config.smtp.from,
+        //   to: originalEmail.from,
+        //   subject: `Re: ${originalEmail.subject}`,
+        //   text: reply.content,
+        //   inReplyTo: originalEmail.messageId,
+        //   references: [originalEmail.messageId],
+        // });
+        void originalEmail;
+        void reply;
+    }
+    /** Send a standalone email */
+    async send(to, subject, body) {
+        void to;
+        void subject;
+        void body;
+        // TODO: Implement with nodemailer
+    }
+}
+exports.EmailChannel = EmailChannel;
+//# sourceMappingURL=email.js.map

package/dist/channels/slack.d.ts

@@ -0,0 +1,62 @@
+import { BaseChannel } from './index';
+/**
+ * Slack Channel — v0.8.0
+ * Slack Bot with Socket Mode / Events API support, threads, and slash commands.
+ */
+export interface SlackChannelConfig {
+    /** Bot token (xoxb-...) */
+    botToken: string;
+    /** App-level token for Socket Mode (xapp-...) */
+    appToken?: string;
+    /** Signing secret for Events API verification */
+    signingSecret?: string;
+    /** Use Socket Mode (true) or Events API (false) */
+    socketMode?: boolean;
+    /** Port for Events API webhook server (default: 3001) */
+    port?: number;
+    /** Slash commands to register */
+    slashCommands?: SlashCommandConfig[];
+}
+export interface SlashCommandConfig {
+    command: string;
+    description: string;
+    handler?: (payload: SlashCommandPayload) => Promise<string>;
+}
+export interface SlashCommandPayload {
+    command: string;
+    text: string;
+    userId: string;
+    channelId: string;
+    triggerId: string;
+}
+export interface SlackMessageEvent {
+    type: string;
+    channel: string;
+    user: string;
+    text: string;
+    ts: string;
+    threadTs?: string;
+    botId?: string;
+}
+export declare class SlackChannel extends BaseChannel {
+    type: string;
+    private config;
+    private running;
+    private slashHandlers;
+    constructor(config: SlackChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Start Socket Mode connection */
+    private startSocketMode;
+    /** Start Events API HTTP server */
+    private startEventsAPI;
+    /** Handle incoming Slack message */
+    handleMessage(event: SlackMessageEvent): Promise<void>;
+    /** Handle slash command */
+    handleSlashCommand(payload: SlashCommandPayload): Promise<string>;
+    /** Convert Slack event to Message */
+    private slackToMessage;
+    /** Send a message to a Slack channel */
+    sendMessage(channel: string, text: string, threadTs?: string): Promise<void>;
+}
+//# sourceMappingURL=slack.d.ts.map

package/dist/channels/slack.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackChannel = void 0;
+const index_1 = require("./index");
+class SlackChannel extends index_1.BaseChannel {
+    type = 'slack';
+    config;
+    running = false;
+    slashHandlers = new Map();
+    constructor(config) {
+        super();
+        this.config = config;
+        for (const cmd of config.slashCommands ?? []) {
+            this.slashHandlers.set(cmd.command, cmd);
+        }
+    }
+    async start() {
+        this.running = true;
+        if (this.config.socketMode && this.config.appToken) {
+            await this.startSocketMode();
+        }
+        else {
+            await this.startEventsAPI();
+        }
+    }
+    async stop() {
+        this.running = false;
+        // Cleanup connections
+    }
+    /** Start Socket Mode connection */
+    async startSocketMode() {
+        // TODO: Implement with @slack/socket-mode
+        // const { SocketModeClient } = await import('@slack/socket-mode');
+        // const client = new SocketModeClient({ appToken: this.config.appToken! });
+        // client.on('message', (event) => this.handleMessage(event));
+        // await client.start();
+    }
+    /** Start Events API HTTP server */
+    async startEventsAPI() {
+        // TODO: Implement with express or http
+        // const port = this.config.port ?? 3001;
+        // Listen for POST /slack/events and /slack/commands
+    }
+    /** Handle incoming Slack message */
+    async handleMessage(event) {
+        // Ignore bot messages
+        if (event.botId)
+            return;
+        const message = this.slackToMessage(event);
+        if (this.handler) {
+            const reply = await this.handler(message);
+            await this.sendMessage(event.channel, reply.content, event.threadTs ?? event.ts);
+        }
+    }
+    /** Handle slash command */
+    async handleSlashCommand(payload) {
+        const cmd = this.slashHandlers.get(payload.command);
+        if (cmd?.handler) {
+            return cmd.handler(payload);
+        }
+        // Default: pass to message handler
+        const message = {
+            id: `slack-cmd-${Date.now()}`,
+            role: 'user',
+            content: `${payload.command} ${payload.text}`.trim(),
+            timestamp: Date.now(),
+            metadata: {
+                channel: 'slack',
+                channelId: payload.channelId,
+                userId: payload.userId,
+                isSlashCommand: true,
+            },
+        };
+        if (this.handler) {
+            const reply = await this.handler(message);
+            return reply.content;
+        }
+        return 'Command received.';
+    }
+    /** Convert Slack event to Message */
+    slackToMessage(event) {
+        return {
+            id: event.ts,
+            role: 'user',
+            content: event.text,
+            timestamp: parseFloat(event.ts) * 1000,
+            metadata: {
+                channel: 'slack',
+                channelId: event.channel,
+                userId: event.user,
+                threadTs: event.threadTs,
+            },
+        };
+    }
+    /** Send a message to a Slack channel */
+    async sendMessage(channel, text, threadTs) {
+        // TODO: Implement with @slack/web-api
+        // const { WebClient } = await import('@slack/web-api');
+        // const client = new WebClient(this.config.botToken);
+        // await client.chat.postMessage({ channel, text, thread_ts: threadTs });
+        void channel;
+        void text;
+        void threadTs;
+    }
+}
+exports.SlackChannel = SlackChannel;
+//# sourceMappingURL=slack.js.map

package/dist/channels/wechat.d.ts

@@ -0,0 +1,62 @@
+import { BaseChannel } from './index';
+/**
+ * WeChat Channel (Stub) — v0.8.0
+ * WeChat Official Account message handling, template messages, QR code login.
+ */
+export interface WeChatChannelConfig {
+    /** WeChat Official Account AppID */
+    appId: string;
+    /** WeChat Official Account AppSecret */
+    appSecret: string;
+    /** Verification token for message validation */
+    token: string;
+    /** AES encoding key for encrypted messages */
+    encodingAESKey?: string;
+    /** HTTP server port (default: 3002) */
+    port?: number;
+}
+export interface WeChatMessage {
+    toUserName: string;
+    fromUserName: string;
+    createTime: number;
+    msgType: 'text' | 'image' | 'voice' | 'video' | 'event';
+    content?: string;
+    msgId?: string;
+    event?: string;
+    eventKey?: string;
+}
+export interface TemplateMessageData {
+    toUser: string;
+    templateId: string;
+    url?: string;
+    data: Record<string, {
+        value: string;
+        color?: string;
+    }>;
+}
+export declare class WeChatChannel extends BaseChannel {
+    type: string;
+    private config;
+    private accessToken;
+    private tokenExpiry;
+    constructor(config: WeChatChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Get or refresh access token */
+    getAccessToken(): Promise<string>;
+    /** Handle incoming WeChat message */
+    handleMessage(wxMsg: WeChatMessage): Promise<string>;
+    /** Handle WeChat events (subscribe, scan, etc.) */
+    private handleEvent;
+    /** Convert WeChat message to internal Message */
+    private wechatToMessage;
+    /** Send template message */
+    sendTemplateMessage(data: TemplateMessageData): Promise<boolean>;
+    /** Generate QR code for login (stub) */
+    generateLoginQR(): Promise<{
+        ticket: string;
+        url: string;
+        expireSeconds: number;
+    }>;
+}
+//# sourceMappingURL=wechat.d.ts.map

package/dist/channels/wechat.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeChatChannel = void 0;
+const index_1 = require("./index");
+class WeChatChannel extends index_1.BaseChannel {
+    type = 'wechat';
+    config;
+    accessToken = null;
+    tokenExpiry = 0;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        // TODO: Start HTTP server to receive WeChat push messages
+        // 1. Verify signature on GET requests
+        // 2. Parse XML messages on POST requests
+        // 3. Route to handler and reply with XML
+    }
+    async stop() {
+        // TODO: Stop HTTP server
+    }
+    /** Get or refresh access token */
+    async getAccessToken() {
+        if (this.accessToken && Date.now() < this.tokenExpiry) {
+            return this.accessToken;
+        }
+        // TODO: Implement token refresh
+        // const url = `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${this.config.appId}&secret=${this.config.appSecret}`;
+        // const res = await fetch(url);
+        // const data = await res.json();
+        // this.accessToken = data.access_token;
+        // this.tokenExpiry = Date.now() + (data.expires_in - 300) * 1000;
+        return this.accessToken ?? '';
+    }
+    /** Handle incoming WeChat message */
+    async handleMessage(wxMsg) {
+        if (wxMsg.msgType === 'event') {
+            return this.handleEvent(wxMsg);
+        }
+        const message = this.wechatToMessage(wxMsg);
+        if (this.handler) {
+            const reply = await this.handler(message);
+            return reply.content;
+        }
+        return '';
+    }
+    /** Handle WeChat events (subscribe, scan, etc.) */
+    handleEvent(wxMsg) {
+        switch (wxMsg.event) {
+            case 'subscribe':
+                return 'Welcome! How can I help you?';
+            case 'SCAN':
+                return `QR code scanned: ${wxMsg.eventKey}`;
+            default:
+                return '';
+        }
+    }
+    /** Convert WeChat message to internal Message */
+    wechatToMessage(wxMsg) {
+        return {
+            id: wxMsg.msgId ?? `wx-${wxMsg.createTime}`,
+            role: 'user',
+            content: wxMsg.content ?? '',
+            timestamp: wxMsg.createTime * 1000,
+            metadata: {
+                channel: 'wechat',
+                fromUser: wxMsg.fromUserName,
+                toUser: wxMsg.toUserName,
+                msgType: wxMsg.msgType,
+            },
+        };
+    }
+    /** Send template message */
+    async sendTemplateMessage(data) {
+        // TODO: Implement
+        // const token = await this.getAccessToken();
+        // const url = `https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=${token}`;
+        // const res = await fetch(url, {
+        //   method: 'POST',
+        //   body: JSON.stringify({
+        //     touser: data.toUser,
+        //     template_id: data.templateId,
+        //     url: data.url,
+        //     data: data.data,
+        //   }),
+        // });
+        void data;
+        return true;
+    }
+    /** Generate QR code for login (stub) */
+    async generateLoginQR() {
+        // TODO: Implement with WeChat QR code API
+        // const token = await this.getAccessToken();
+        // POST to https://api.weixin.qq.com/cgi-bin/qrcode/create
+        return {
+            ticket: 'stub-ticket',
+            url: 'https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=stub-ticket',
+            expireSeconds: 300,
+        };
+    }
+}
+exports.WeChatChannel = WeChatChannel;
+//# sourceMappingURL=wechat.js.map

package/dist/core/compose.d.ts

@@ -0,0 +1,35 @@
+import type { AgentContext, Message } from './types';
+/**
+ * Agent Composition — v0.8.0
+ * Combine multiple agents into a pipeline: Agent A output → Agent B input.
+ * Configurable in OAD: `compose: [agent-a, agent-b]`
+ */
+export type AgentHandler = (context: AgentContext, message: Message) => Promise<Message>;
+export interface ComposableAgent {
+    id: string;
+    name: string;
+    handler: AgentHandler;
+}
+export interface ComposeOptions {
+    /** Stop pipeline if any agent returns empty content */
+    stopOnEmpty?: boolean;
+    /** Transform output between agents */
+    transform?: (output: Message, nextAgentId: string) => Message;
+    /** Timeout per agent in ms */
+    timeoutMs?: number;
+}
+export declare class AgentPipeline {
+    private agents;
+    private options;
+    constructor(agents: ComposableAgent[], options?: ComposeOptions);
+    /** Run the pipeline sequentially: each agent's output becomes the next agent's input */
+    execute(context: AgentContext, initialMessage: Message): Promise<Message>;
+    /** Get the pipeline agent IDs in order */
+    getAgentIds(): string[];
+}
+/**
+ * Create a pipeline from an array of composable agents.
+ * Usage in OAD: `compose: [agent-a, agent-b, agent-c]`
+ */
+export declare function compose(agents: ComposableAgent[], options?: ComposeOptions): AgentPipeline;
+//# sourceMappingURL=compose.d.ts.map

package/dist/core/compose.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentPipeline = void 0;
+exports.compose = compose;
+class AgentPipeline {
+    agents = [];
+    options;
+    constructor(agents, options = {}) {
+        this.agents = agents;
+        this.options = options;
+    }
+    /** Run the pipeline sequentially: each agent's output becomes the next agent's input */
+    async execute(context, initialMessage) {
+        let currentMessage = initialMessage;
+        for (const agent of this.agents) {
+            if (this.options.stopOnEmpty && !currentMessage.content.trim()) {
+                break;
+            }
+            // Apply transform if provided
+            if (this.options.transform) {
+                currentMessage = this.options.transform(currentMessage, agent.id);
+            }
+            if (this.options.timeoutMs) {
+                const result = await Promise.race([
+                    agent.handler(context, currentMessage),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Agent ${agent.id} timed out`)), this.options.timeoutMs)),
+                ]);
+                currentMessage = result;
+            }
+            else {
+                currentMessage = await agent.handler(context, currentMessage);
+            }
+        }
+        return currentMessage;
+    }
+    /** Get the pipeline agent IDs in order */
+    getAgentIds() {
+        return this.agents.map((a) => a.id);
+    }
+}
+exports.AgentPipeline = AgentPipeline;
+/**
+ * Create a pipeline from an array of composable agents.
+ * Usage in OAD: `compose: [agent-a, agent-b, agent-c]`
+ */
+function compose(agents, options) {
+    return new AgentPipeline(agents, options);
+}
+//# sourceMappingURL=compose.js.map

package/dist/core/orchestrator.d.ts

@@ -0,0 +1,68 @@
+import { EventEmitter } from 'events';
+import type { AgentContext, Message } from './types';
+/**
+ * Multi-Agent Orchestrator — v0.8.0
+ * Routes messages to specialized sub-agents, supports parallel execution and handoffs.
+ */
+export interface AgentNode {
+    id: string;
+    name: string;
+    description: string;
+    /** Patterns or intents this agent handles */
+    routes: string[];
+    /** Function that processes a message and returns a response */
+    handler: (context: AgentContext, message: Message) => Promise<Message>;
+    /** Priority for routing conflicts (higher wins) */
+    priority?: number;
+}
+export interface OrchestratorWorkflow {
+    name: string;
+    description?: string;
+    /** Ordered list of agent IDs for sequential execution */
+    steps?: string[];
+    /** List of agent IDs for parallel execution */
+    parallel?: string[];
+    /** Router config: auto-route based on message content */
+    router?: {
+        agents: string[];
+        fallback?: string;
+    };
+}
+export interface HandoffRequest {
+    fromAgent: string;
+    toAgent: string;
+    context: AgentContext;
+    reason: string;
+}
+export interface OrchestratorConfig {
+    agents: AgentNode[];
+    workflows?: OrchestratorWorkflow[];
+    defaultWorkflow?: string;
+    maxParallel?: number;
+}
+export declare class Orchestrator extends EventEmitter {
+    private agents;
+    private workflows;
+    private defaultWorkflow?;
+    private maxParallel;
+    constructor(config: OrchestratorConfig);
+    /** Register a new agent node */
+    registerAgent(agent: AgentNode): void;
+    /** Unregister an agent */
+    unregisterAgent(id: string): void;
+    /** Route a message to the best-matching agent */
+    route(message: Message): AgentNode | undefined;
+    /** Execute a single agent */
+    executeAgent(agentId: string, context: AgentContext, message: Message): Promise<Message>;
+    /** Run multiple agents in parallel */
+    executeParallel(agentIds: string[], context: AgentContext, message: Message): Promise<Map<string, Message>>;
+    /** Execute a named workflow */
+    executeWorkflow(workflowName: string, context: AgentContext, message: Message): Promise<Message[]>;
+    /** Hand off conversation from one agent to another */
+    handoff(request: HandoffRequest): Promise<Message>;
+    /** Process an incoming message using the default workflow or routing */
+    process(context: AgentContext, message: Message): Promise<Message[]>;
+    getAgents(): AgentNode[];
+    getWorkflows(): OrchestratorWorkflow[];
+}
+//# sourceMappingURL=orchestrator.d.ts.map