opc-agent 1.3.2 → 2.0.0

package/examples/multi-channel.ts

@@ -0,0 +1,74 @@
+/**
+ * OPC Agent Example: Multi-Channel Setup
+ *
+ * Shows how to configure Web + Telegram channels for an agent.
+ * Note: This is a configuration demo — actual channel connections
+ * require valid tokens/endpoints.
+ *
+ * Run: npx tsx examples/multi-channel.ts
+ */
+
+import {
+  BaseAgent,
+  AgentRuntime,
+  WebChannel,
+  TelegramChannel,
+  InMemoryStore,
+} from 'opc-agent';
+
+async function main() {
+  console.log('🌐 OPC Agent — Multi-Channel Demo\n');
+
+  try {
+    const agent = new BaseAgent({
+      name: 'multi-channel-agent',
+      description: 'Agent that works across multiple channels',
+      version: '1.0.0',
+    });
+
+    const memory = new InMemoryStore();
+    const runtime = new AgentRuntime(agent, { memory });
+
+    // Channel 1: Web (HTTP endpoint)
+    const webChannel = new WebChannel({
+      port: 3000,
+      path: '/chat',
+    });
+    console.log('📡 Web channel configured: http://localhost:3000/chat');
+
+    // Channel 2: Telegram (requires BOT_TOKEN)
+    const telegramToken = process.env.TELEGRAM_BOT_TOKEN;
+    if (telegramToken) {
+      const telegramChannel = new TelegramChannel({
+        token: telegramToken,
+      });
+      runtime.addChannel(telegramChannel);
+      console.log('📱 Telegram channel configured');
+    } else {
+      console.log('📱 Telegram: skipped (set TELEGRAM_BOT_TOKEN to enable)');
+    }
+
+    // Register web channel
+    runtime.addChannel(webChannel);
+
+    console.log('\n✅ Agent configured with channels:');
+    console.log('  • Web:      HTTP REST endpoint');
+    console.log('  • Telegram: Bot API (optional)');
+    console.log('\nAvailable channels in OPC Agent:');
+    console.log('  WebChannel, TelegramChannel, WebSocketChannel,');
+    console.log('  SlackChannel, DiscordChannel, FeishuChannel,');
+    console.log('  EmailChannel, WeChatChannel, VoiceChannel,');
+    console.log('  WebhookChannel\n');
+
+    // In production you would call: await runtime.start();
+    console.log('💡 To start: await runtime.start()');
+  } catch (e: any) {
+    console.error(`❌ Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+main().catch(e => {
+  console.error(`\n❌ Error: ${e.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "1.3.2",
+  "version": "2.0.0",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/analytics/index.ts

@@ -1,66 +1,66 @@
-/**
- * Agent Analytics — track messages, response times, skill usage, errors, tokens.
- */
-export interface AnalyticsSnapshot {
-  messagesProcessed: number;
-  avgResponseTimeMs: number;
-  skillUsage: Record<string, number>;
-  errorCount: number;
-  tokenUsage: { input: number; output: number; total: number };
-  uptime: number;
-  startedAt: number;
-}
-
-export class Analytics {
-  private messagesProcessed = 0;
-  private totalResponseTimeMs = 0;
-  private skillUsage: Record<string, number> = {};
-  private errorCount = 0;
-  private tokenUsage = { input: 0, output: 0 };
-  private startedAt = Date.now();
-
-  recordMessage(responseTimeMs: number): void {
-    this.messagesProcessed++;
-    this.totalResponseTimeMs += responseTimeMs;
-  }
-
-  recordSkillUsage(skillName: string): void {
-    this.skillUsage[skillName] = (this.skillUsage[skillName] ?? 0) + 1;
-  }
-
-  recordError(): void {
-    this.errorCount++;
-  }
-
-  recordTokens(input: number, output: number): void {
-    this.tokenUsage.input += input;
-    this.tokenUsage.output += output;
-  }
-
-  getSnapshot(): AnalyticsSnapshot {
-    return {
-      messagesProcessed: this.messagesProcessed,
-      avgResponseTimeMs: this.messagesProcessed > 0
-        ? Math.round(this.totalResponseTimeMs / this.messagesProcessed)
-        : 0,
-      skillUsage: { ...this.skillUsage },
-      errorCount: this.errorCount,
-      tokenUsage: {
-        input: this.tokenUsage.input,
-        output: this.tokenUsage.output,
-        total: this.tokenUsage.input + this.tokenUsage.output,
-      },
-      uptime: Date.now() - this.startedAt,
-      startedAt: this.startedAt,
-    };
-  }
-
-  reset(): void {
-    this.messagesProcessed = 0;
-    this.totalResponseTimeMs = 0;
-    this.skillUsage = {};
-    this.errorCount = 0;
-    this.tokenUsage = { input: 0, output: 0 };
-    this.startedAt = Date.now();
-  }
-}
+/**
+ * Agent Analytics — track messages, response times, skill usage, errors, tokens.
+ */
+export interface AnalyticsSnapshot {
+  messagesProcessed: number;
+  avgResponseTimeMs: number;
+  skillUsage: Record<string, number>;
+  errorCount: number;
+  tokenUsage: { input: number; output: number; total: number };
+  uptime: number;
+  startedAt: number;
+}
+
+export class Analytics {
+  private messagesProcessed = 0;
+  private totalResponseTimeMs = 0;
+  private skillUsage: Record<string, number> = {};
+  private errorCount = 0;
+  private tokenUsage = { input: 0, output: 0 };
+  private startedAt = Date.now();
+
+  recordMessage(responseTimeMs: number): void {
+    this.messagesProcessed++;
+    this.totalResponseTimeMs += responseTimeMs;
+  }
+
+  recordSkillUsage(skillName: string): void {
+    this.skillUsage[skillName] = (this.skillUsage[skillName] ?? 0) + 1;
+  }
+
+  recordError(): void {
+    this.errorCount++;
+  }
+
+  recordTokens(input: number, output: number): void {
+    this.tokenUsage.input += input;
+    this.tokenUsage.output += output;
+  }
+
+  getSnapshot(): AnalyticsSnapshot {
+    return {
+      messagesProcessed: this.messagesProcessed,
+      avgResponseTimeMs: this.messagesProcessed > 0
+        ? Math.round(this.totalResponseTimeMs / this.messagesProcessed)
+        : 0,
+      skillUsage: { ...this.skillUsage },
+      errorCount: this.errorCount,
+      tokenUsage: {
+        input: this.tokenUsage.input,
+        output: this.tokenUsage.output,
+        total: this.tokenUsage.input + this.tokenUsage.output,
+      },
+      uptime: Date.now() - this.startedAt,
+      startedAt: this.startedAt,
+    };
+  }
+
+  reset(): void {
+    this.messagesProcessed = 0;
+    this.totalResponseTimeMs = 0;
+    this.skillUsage = {};
+    this.errorCount = 0;
+    this.tokenUsage = { input: 0, output: 0 };
+    this.startedAt = Date.now();
+  }
+}

package/src/channels/discord.ts

@@ -1,192 +1,192 @@
-import { BaseChannel } from './index';
-import type { Message } from '../core/types';
-
-/**
- * Discord Channel — v1.1.0
- *
- * Supports:
- * - Discord Bot via Gateway (WebSocket) or HTTP interactions
- * - Slash commands, message content intent
- * - Thread-based conversations
- * - Reactions, embeds
- *
- * Env vars:
- *   DISCORD_BOT_TOKEN — bot token
- *   DISCORD_APPLICATION_ID — application ID for slash commands
- */
-
-export interface DiscordChannelConfig {
-  /** Bot token */
-  botToken?: string;
-  /** Application ID */
-  applicationId?: string;
-  /** Guild IDs to register slash commands (empty = global) */
-  guildIds?: string[];
-  /** Whether to use threads for conversations */
-  useThreads?: boolean;
-}
-
-export class DiscordChannel extends BaseChannel {
-  readonly type = 'discord';
-  private config: DiscordChannelConfig;
-  private ws: import('ws').WebSocket | null = null;
-  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
-  private sequenceNumber: number | null = null;
-  private sessionId: string | null = null;
-  private resumeUrl: string | null = null;
-
-  constructor(config: DiscordChannelConfig = {}) {
-    super();
-    this.config = {
-      botToken: config.botToken ?? process.env.DISCORD_BOT_TOKEN ?? '',
-      applicationId: config.applicationId ?? process.env.DISCORD_APPLICATION_ID ?? '',
-      guildIds: config.guildIds ?? [],
-      useThreads: config.useThreads ?? true,
-    };
-  }
-
-  async start(): Promise<void> {
-    if (!this.config.botToken) {
-      console.warn('[DiscordChannel] No bot token. Set DISCORD_BOT_TOKEN.');
-      return;
-    }
-
-    // Get gateway URL
-    const gatewayResp = await fetch('https://discord.com/api/v10/gateway/bot', {
-      headers: { Authorization: `Bot ${this.config.botToken}` },
-    });
-    const gatewayData = await gatewayResp.json() as { url: string };
-    const wsUrl = `${gatewayData.url}?v=10&encoding=json`;
-
-    const { WebSocket } = await import('ws');
-    this.ws = new WebSocket(wsUrl);
-
-    this.ws.on('message', async (data: Buffer) => {
-      const payload = JSON.parse(data.toString());
-      this.sequenceNumber = payload.s ?? this.sequenceNumber;
-
-      switch (payload.op) {
-        case 10: // Hello
-          this.startHeartbeat(payload.d.heartbeat_interval);
-          this.identify();
-          break;
-        case 11: // Heartbeat ACK
-          break;
-        case 0: // Dispatch
-          if (payload.t === 'READY') {
-            this.sessionId = payload.d.session_id;
-            this.resumeUrl = payload.d.resume_gateway_url;
-            console.log(`[DiscordChannel] Connected as ${payload.d.user.username}`);
-          } else if (payload.t === 'MESSAGE_CREATE') {
-            await this.handleMessage(payload.d);
-          }
-          break;
-      }
-    });
-
-    this.ws.on('close', (code: number) => {
-      console.log(`[DiscordChannel] WebSocket closed: ${code}`);
-      this.stopHeartbeat();
-      // Auto-reconnect after 5s for resumable codes
-      if (code !== 4004 && code !== 4014) {
-        setTimeout(() => this.start(), 5000);
-      }
-    });
-
-    this.ws.on('error', (err: Error) => {
-      console.error('[DiscordChannel] WebSocket error:', err.message);
-    });
-  }
-
-  async stop(): Promise<void> {
-    this.stopHeartbeat();
-    if (this.ws) {
-      this.ws.close(1000);
-      this.ws = null;
-    }
-  }
-
-  private identify(): void {
-    this.ws?.send(JSON.stringify({
-      op: 2,
-      d: {
-        token: this.config.botToken,
-        intents: (1 << 9) | (1 << 15), // GUILD_MESSAGES | MESSAGE_CONTENT
-        properties: {
-          os: process.platform,
-          browser: 'opc-agent',
-          device: 'opc-agent',
-        },
-      },
-    }));
-  }
-
-  private startHeartbeat(intervalMs: number): void {
-    this.stopHeartbeat();
-    // Send first heartbeat with jitter
-    setTimeout(() => {
-      this.sendHeartbeat();
-      this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), intervalMs);
-    }, intervalMs * Math.random());
-  }
-
-  private stopHeartbeat(): void {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-  }
-
-  private sendHeartbeat(): void {
-    this.ws?.send(JSON.stringify({ op: 1, d: this.sequenceNumber }));
-  }
-
-  private async handleMessage(d: Record<string, unknown>): Promise<void> {
-    // Ignore bot messages
-    const author = d.author as Record<string, unknown>;
-    if (author?.bot) return;
-    if (!d.content || !this.handler) return;
-
-    const msg: Message = {
-      id: `discord_${d.id}`,
-      role: 'user',
-      content: d.content as string,
-      timestamp: new Date(d.timestamp as string).getTime(),
-      metadata: {
-        sessionId: `discord_${d.channel_id}`,
-        chatId: d.channel_id as string,
-        userId: author.id as string,
-        platform: 'discord',
-        guildId: d.guild_id as string | undefined,
-        threadId: (d as Record<string, unknown>).thread?.toString(),
-      },
-    };
-
-    const response = await this.handler(msg);
-    await this.sendMessage(d.channel_id as string, response.content);
-  }
-
-  async sendMessage(channelId: string, content: string): Promise<void> {
-    // Discord max message length is 2000
-    const chunks = this.splitMessage(content, 2000);
-    for (const chunk of chunks) {
-      await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bot ${this.config.botToken}`,
-        },
-        body: JSON.stringify({ content: chunk }),
-      });
-    }
-  }
-
-  private splitMessage(text: string, maxLen: number): string[] {
-    if (text.length <= maxLen) return [text];
-    const parts: string[] = [];
-    for (let i = 0; i < text.length; i += maxLen) {
-      parts.push(text.slice(i, i + maxLen));
-    }
-    return parts;
-  }
-}
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+/**
+ * Discord Channel — v1.1.0
+ *
+ * Supports:
+ * - Discord Bot via Gateway (WebSocket) or HTTP interactions
+ * - Slash commands, message content intent
+ * - Thread-based conversations
+ * - Reactions, embeds
+ *
+ * Env vars:
+ *   DISCORD_BOT_TOKEN — bot token
+ *   DISCORD_APPLICATION_ID — application ID for slash commands
+ */
+
+export interface DiscordChannelConfig {
+  /** Bot token */
+  botToken?: string;
+  /** Application ID */
+  applicationId?: string;
+  /** Guild IDs to register slash commands (empty = global) */
+  guildIds?: string[];
+  /** Whether to use threads for conversations */
+  useThreads?: boolean;
+}
+
+export class DiscordChannel extends BaseChannel {
+  readonly type = 'discord';
+  private config: DiscordChannelConfig;
+  private ws: import('ws').WebSocket | null = null;
+  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+  private sequenceNumber: number | null = null;
+  private sessionId: string | null = null;
+  private resumeUrl: string | null = null;
+
+  constructor(config: DiscordChannelConfig = {}) {
+    super();
+    this.config = {
+      botToken: config.botToken ?? process.env.DISCORD_BOT_TOKEN ?? '',
+      applicationId: config.applicationId ?? process.env.DISCORD_APPLICATION_ID ?? '',
+      guildIds: config.guildIds ?? [],
+      useThreads: config.useThreads ?? true,
+    };
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.botToken) {
+      console.warn('[DiscordChannel] No bot token. Set DISCORD_BOT_TOKEN.');
+      return;
+    }
+
+    // Get gateway URL
+    const gatewayResp = await fetch('https://discord.com/api/v10/gateway/bot', {
+      headers: { Authorization: `Bot ${this.config.botToken}` },
+    });
+    const gatewayData = await gatewayResp.json() as { url: string };
+    const wsUrl = `${gatewayData.url}?v=10&encoding=json`;
+
+    const { WebSocket } = await import('ws');
+    this.ws = new WebSocket(wsUrl);
+
+    this.ws.on('message', async (data: Buffer) => {
+      const payload = JSON.parse(data.toString());
+      this.sequenceNumber = payload.s ?? this.sequenceNumber;
+
+      switch (payload.op) {
+        case 10: // Hello
+          this.startHeartbeat(payload.d.heartbeat_interval);
+          this.identify();
+          break;
+        case 11: // Heartbeat ACK
+          break;
+        case 0: // Dispatch
+          if (payload.t === 'READY') {
+            this.sessionId = payload.d.session_id;
+            this.resumeUrl = payload.d.resume_gateway_url;
+            console.log(`[DiscordChannel] Connected as ${payload.d.user.username}`);
+          } else if (payload.t === 'MESSAGE_CREATE') {
+            await this.handleMessage(payload.d);
+          }
+          break;
+      }
+    });
+
+    this.ws.on('close', (code: number) => {
+      console.log(`[DiscordChannel] WebSocket closed: ${code}`);
+      this.stopHeartbeat();
+      // Auto-reconnect after 5s for resumable codes
+      if (code !== 4004 && code !== 4014) {
+        setTimeout(() => this.start(), 5000);
+      }
+    });
+
+    this.ws.on('error', (err: Error) => {
+      console.error('[DiscordChannel] WebSocket error:', err.message);
+    });
+  }
+
+  async stop(): Promise<void> {
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.close(1000);
+      this.ws = null;
+    }
+  }
+
+  private identify(): void {
+    this.ws?.send(JSON.stringify({
+      op: 2,
+      d: {
+        token: this.config.botToken,
+        intents: (1 << 9) | (1 << 15), // GUILD_MESSAGES | MESSAGE_CONTENT
+        properties: {
+          os: process.platform,
+          browser: 'opc-agent',
+          device: 'opc-agent',
+        },
+      },
+    }));
+  }
+
+  private startHeartbeat(intervalMs: number): void {
+    this.stopHeartbeat();
+    // Send first heartbeat with jitter
+    setTimeout(() => {
+      this.sendHeartbeat();
+      this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), intervalMs);
+    }, intervalMs * Math.random());
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+
+  private sendHeartbeat(): void {
+    this.ws?.send(JSON.stringify({ op: 1, d: this.sequenceNumber }));
+  }
+
+  private async handleMessage(d: Record<string, unknown>): Promise<void> {
+    // Ignore bot messages
+    const author = d.author as Record<string, unknown>;
+    if (author?.bot) return;
+    if (!d.content || !this.handler) return;
+
+    const msg: Message = {
+      id: `discord_${d.id}`,
+      role: 'user',
+      content: d.content as string,
+      timestamp: new Date(d.timestamp as string).getTime(),
+      metadata: {
+        sessionId: `discord_${d.channel_id}`,
+        chatId: d.channel_id as string,
+        userId: author.id as string,
+        platform: 'discord',
+        guildId: d.guild_id as string | undefined,
+        threadId: (d as Record<string, unknown>).thread?.toString(),
+      },
+    };
+
+    const response = await this.handler(msg);
+    await this.sendMessage(d.channel_id as string, response.content);
+  }
+
+  async sendMessage(channelId: string, content: string): Promise<void> {
+    // Discord max message length is 2000
+    const chunks = this.splitMessage(content, 2000);
+    for (const chunk of chunks) {
+      await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bot ${this.config.botToken}`,
+        },
+        body: JSON.stringify({ content: chunk }),
+      });
+    }
+  }
+
+  private splitMessage(text: string, maxLen: number): string[] {
+    if (text.length <= maxLen) return [text];
+    const parts: string[] = [];
+    for (let i = 0; i < text.length; i += maxLen) {
+      parts.push(text.slice(i, i + maxLen));
+    }
+    return parts;
+  }
+}