opc-agent 0.6.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/web.d.ts

@@ -1,6 +1,7 @@
 import { type Response } from 'express';
 import type { Message } from '../core/types';
 import { BaseChannel } from './index';
+import { type AuthConfig } from '../core/auth';
 export declare class WebChannel extends BaseChannel {
     readonly type = "web";
     private app;
@@ -11,11 +12,16 @@ export declare class WebChannel extends BaseChannel {
     private currentProvider;
     private stats;
     private eventHandlers;
+    private conversations;
+    private requestCount;
+    private llmLatencySum;
+    private llmCalls;
     private emit;
     onConfigChange(handler: (config: any) => void): void;
     trackMessage(responseMs: number, tokens?: number): void;
+    trackError(): void;
     trackSession(): void;
-    constructor(port?: number);
+    constructor(port?: number, authConfig?: AuthConfig);
     setAgentName(name: string): void;
     onStreamMessage(handler: (msg: Message, res: Response) => Promise<void>): void;
     private setupRoutes;

package/dist/channels/web.js

@@ -7,6 +7,57 @@ exports.WebChannel = void 0;
 const express_1 = __importDefault(require("express"));
 const index_1 = require("./index");
 const knowledge_1 = require("../core/knowledge");
+const auth_1 = require("../core/auth");
+const AGENT_TEMPLATES = [
+    { id: 'customer-service', name: 'Customer Service', description: 'Handle support tickets, FAQs, and customer inquiries', icon: '🎧', category: 'Business' },
+    { id: 'code-reviewer', name: 'Code Reviewer', description: 'Review PRs, suggest improvements, check for bugs', icon: '🔍', category: 'Engineering' },
+    { id: 'content-writer', name: 'Content Writer', description: 'Write blogs, social media posts, and marketing copy', icon: '✍️', category: 'Marketing' },
+    { id: 'executive-assistant', name: 'Executive Assistant', description: 'Schedule management, email drafting, meeting prep', icon: '📋', category: 'Business' },
+    { id: 'knowledge-base', name: 'Knowledge Base', description: 'RAG-powered Q&A over your documents', icon: '📚', category: 'Knowledge' },
+    { id: 'project-manager', name: 'Project Manager', description: 'Track tasks, milestones, and team coordination', icon: '📊', category: 'Business' },
+    { id: 'sales-assistant', name: 'Sales Assistant', description: 'Lead qualification, outreach drafting, CRM updates', icon: '💼', category: 'Sales' },
+    { id: 'financial-advisor', name: 'Financial Advisor', description: 'Budget analysis, financial planning, cost optimization', icon: '💰', category: 'Finance' },
+    { id: 'hr-recruiter', name: 'HR Recruiter', description: 'Resume screening, interview scheduling, candidate comms', icon: '👥', category: 'HR' },
+    { id: 'legal-assistant', name: 'Legal Assistant', description: 'Contract review, compliance checks, legal research', icon: '⚖️', category: 'Legal' },
+];
+const TEMPLATES_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0">
+<title>Agent Templates</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{background:#0a0a0f;color:#e0e0e0;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;padding:24px}
+h1{font-size:28px;margin-bottom:8px;color:#fff}
+.sub{color:#888;margin-bottom:32px;font-size:14px}
+nav{margin-bottom:24px}
+nav a{color:#818cf8;text-decoration:none;margin-right:16px;font-size:14px}
+.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:16px}
+.card{background:#12121a;border:1px solid #1e1e2e;border-radius:12px;padding:24px;cursor:pointer;transition:all .2s}
+.card:hover{border-color:#818cf8;transform:translateY(-2px)}
+.card .icon{font-size:32px;margin-bottom:12px}
+.card h3{font-size:16px;color:#fff;margin-bottom:8px}
+.card p{font-size:13px;color:#888;line-height:1.5}
+.card .cat{font-size:11px;color:#818cf8;text-transform:uppercase;letter-spacing:1px;margin-top:12px}
+.btn{display:inline-block;background:#2563eb;color:#fff;border:none;border-radius:8px;padding:8px 16px;font-size:13px;cursor:pointer;margin-top:12px}
+.btn:hover{background:#1d4ed8}
+</style>
+</head>
+<body>
+<nav><a href="/">← Chat</a><a href="/dashboard">Dashboard</a><a href="/templates">Templates</a></nav>
+<h1>🧩 Agent Templates</h1>
+<p class="sub">Create a new agent from a pre-built template in one click.</p>
+<div class="grid" id="grid"></div>
+<script>
+fetch('/api/templates').then(r=>r.json()).then(d=>{
+  const g=document.getElementById('grid');
+  d.templates.forEach(t=>{
+    g.innerHTML+=\`<div class="card"><div class="icon">\${t.icon}</div><h3>\${t.name}</h3><p>\${t.description}</p><div class="cat">\${t.category}</div><button class="btn" onclick="alert('Creating agent from template: '+'\${t.id}'+'\\\\nRun: opc init --template \${t.id}')">Use Template</button></div>\`;
+  });
+});
+</script>
+</body>
+</html>`;
 const CHAT_HTML = `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -157,8 +208,12 @@ class WebChannel extends index_1.BaseChannel {
     streamHandler = null;
     agentName = 'OPC Agent';
     currentProvider = 'openai';
-    stats = { sessions: 0, messages: 0, totalResponseMs: 0, tokenUsage: 0, knowledgeFiles: 0, startedAt: Date.now() };
+    stats = { sessions: 0, messages: 0, totalResponseMs: 0, tokenUsage: 0, knowledgeFiles: 0, startedAt: Date.now(), errors: 0 };
     eventHandlers = new Map();
+    conversations = new Map();
+    requestCount = 0;
+    llmLatencySum = 0;
+    llmCalls = 0;
     emit(event, data) {
         const handlers = this.eventHandlers.get(event) ?? [];
         for (const h of handlers)
@@ -173,13 +228,20 @@ class WebChannel extends index_1.BaseChannel {
         this.stats.messages++;
         this.stats.totalResponseMs += responseMs;
         this.stats.tokenUsage += tokens;
+        this.requestCount++;
+        this.llmLatencySum += responseMs;
+        this.llmCalls++;
     }
+    trackError() { this.stats.errors++; }
     trackSession() { this.stats.sessions++; }
-    constructor(port = 3000) {
+    constructor(port = 3000, authConfig) {
         super();
         this.port = port;
         this.app = (0, express_1.default)();
-        this.app.use(express_1.default.json());
+        this.app.use(express_1.default.json({ limit: '10mb' }));
+        if (authConfig && authConfig.apiKeys.length > 0) {
+            this.app.use((0, auth_1.createAuthMiddleware)(authConfig));
+        }
         this.setupRoutes();
     }
     setAgentName(name) {
@@ -201,6 +263,7 @@ class WebChannel extends index_1.BaseChannel {
         // Streaming chat endpoint
         this.app.post('/api/chat', async (req, res) => {
             const { message, sessionId } = req.body;
+            const sid = sessionId ?? 'default';
             if (!message) {
                 res.status(400).json({ error: 'message is required' });
                 return;
@@ -210,8 +273,12 @@ class WebChannel extends index_1.BaseChannel {
                 role: 'user',
                 content: message,
                 timestamp: Date.now(),
-                metadata: { sessionId: sessionId ?? 'default' },
+                metadata: { sessionId: sid },
             };
+            // Track conversation
+            if (!this.conversations.has(sid))
+                this.conversations.set(sid, []);
+            this.conversations.get(sid).push(msg);
             if (this.streamHandler) {
                 try {
                     await this.streamHandler(msg, res);
@@ -290,6 +357,100 @@ class WebChannel extends index_1.BaseChannel {
                 res.json({ totalEntries: 0, sources: [] });
             }
         });
+        // --- Health Check (detailed) ---
+        this.app.get('/api/health', (_req, res) => {
+            const uptimeMs = Date.now() - this.stats.startedAt;
+            res.json({
+                status: 'ok',
+                timestamp: Date.now(),
+                uptime: uptimeMs,
+                uptimeHuman: `${Math.floor(uptimeMs / 3600000)}h ${Math.floor((uptimeMs % 3600000) / 60000)}m`,
+                version: '0.7.0',
+                agent: this.agentName,
+                stats: {
+                    sessions: this.stats.sessions,
+                    messages: this.stats.messages,
+                    errors: this.stats.errors,
+                    avgResponseMs: this.stats.messages > 0 ? Math.round(this.stats.totalResponseMs / this.stats.messages) : 0,
+                },
+                memory: {
+                    rss: process.memoryUsage().rss,
+                    heapUsed: process.memoryUsage().heapUsed,
+                },
+            });
+        });
+        // --- Prometheus Metrics ---
+        this.app.get('/api/metrics', (_req, res) => {
+            const uptimeMs = Date.now() - this.stats.startedAt;
+            const avgLatency = this.llmCalls > 0 ? this.llmLatencySum / this.llmCalls : 0;
+            const mem = process.memoryUsage();
+            res.type('text/plain').send(`# HELP opc_uptime_seconds Agent uptime in seconds\n` +
+                `# TYPE opc_uptime_seconds gauge\n` +
+                `opc_uptime_seconds ${(uptimeMs / 1000).toFixed(1)}\n` +
+                `# HELP opc_requests_total Total requests\n` +
+                `# TYPE opc_requests_total counter\n` +
+                `opc_requests_total ${this.requestCount}\n` +
+                `# HELP opc_messages_total Total messages processed\n` +
+                `# TYPE opc_messages_total counter\n` +
+                `opc_messages_total ${this.stats.messages}\n` +
+                `# HELP opc_errors_total Total errors\n` +
+                `# TYPE opc_errors_total counter\n` +
+                `opc_errors_total ${this.stats.errors}\n` +
+                `# HELP opc_llm_latency_avg_ms Average LLM response latency\n` +
+                `# TYPE opc_llm_latency_avg_ms gauge\n` +
+                `opc_llm_latency_avg_ms ${avgLatency.toFixed(1)}\n` +
+                `# HELP opc_sessions_total Total sessions\n` +
+                `# TYPE opc_sessions_total counter\n` +
+                `opc_sessions_total ${this.stats.sessions}\n` +
+                `# HELP opc_token_usage_total Total token usage\n` +
+                `# TYPE opc_token_usage_total counter\n` +
+                `opc_token_usage_total ${this.stats.tokenUsage}\n` +
+                `# HELP process_resident_memory_bytes Resident memory size\n` +
+                `# TYPE process_resident_memory_bytes gauge\n` +
+                `process_resident_memory_bytes ${mem.rss}\n`);
+        });
+        // --- Conversation tracking & export ---
+        this.app.get('/api/conversations/export', (req, res) => {
+            const sessionId = req.query.sessionId;
+            const format = req.query.format ?? 'json';
+            const messages = sessionId ? (this.conversations.get(sessionId) ?? []) : Array.from(this.conversations.values()).flat();
+            if (format === 'markdown') {
+                const md = messages.map(m => `**${m.role}** (${new Date(m.timestamp).toISOString()}):\n${m.content}`).join('\n\n---\n\n');
+                res.type('text/markdown').send(md);
+            }
+            else if (format === 'csv') {
+                const header = 'id,role,content,timestamp\n';
+                const rows = messages.map(m => `"${m.id}","${m.role}","${m.content.replace(/"/g, '""')}",${m.timestamp}`).join('\n');
+                res.type('text/csv').send(header + rows);
+            }
+            else {
+                res.json({ sessionId: sessionId ?? 'all', messages, count: messages.length });
+            }
+        });
+        // --- Document Upload ---
+        this.app.post('/api/documents/upload', async (req, res) => {
+            try {
+                const { content, filename, mimeType } = req.body;
+                if (!content || !filename) {
+                    res.status(400).json({ error: 'content and filename are required' });
+                    return;
+                }
+                const kb = new knowledge_1.KnowledgeBase('.');
+                const result = await kb.addText(content, filename);
+                this.stats.knowledgeFiles++;
+                res.json({ ok: true, filename, chunks: result.chunks, chars: content.length });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : 'Upload failed' });
+            }
+        });
+        // --- Agent Templates Gallery ---
+        this.app.get('/api/templates', (_req, res) => {
+            res.json({ templates: AGENT_TEMPLATES });
+        });
+        this.app.get('/templates', (_req, res) => {
+            res.type('html').send(TEMPLATES_HTML);
+        });
         // Legacy endpoint
         this.app.post('/chat', async (req, res) => {
             if (!this.handler) {

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