opc-agent 0.9.0 → 1.1.0

package/dist/plugins/index.js

@@ -1,10 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginManager = void 0;
+exports.createLoggingPlugin = createLoggingPlugin;
+exports.createAnalyticsPlugin = createAnalyticsPlugin;
+exports.createRateLimitPlugin = createRateLimitPlugin;
+const logger_1 = require("../core/logger");
 class PluginManager {
     plugins = new Map();
+    logger = new logger_1.Logger('plugins');
     register(plugin) {
+        if (this.plugins.has(plugin.name)) {
+            this.logger.warn(`Plugin "${plugin.name}" already registered, replacing`);
+        }
         this.plugins.set(plugin.name, plugin);
+        this.logger.info(`Plugin registered: ${plugin.name}@${plugin.version}`);
     }
     unregister(name) {
         this.plugins.delete(name);
@@ -14,9 +23,7 @@ class PluginManager {
     }
     list() {
         return Array.from(this.plugins.values()).map(({ name, version, description }) => ({
-            name,
-            version,
-            description,
+            name, version, description,
         }));
     }
     has(name) {
@@ -26,10 +33,58 @@ class PluginManager {
         for (const plugin of this.plugins.values()) {
             const hook = plugin.hooks?.[hookName];
             if (hook) {
-                await hook(...args);
+                try {
+                    await hook(...args);
+                }
+                catch (err) {
+                    this.logger.error(`Plugin "${plugin.name}" hook "${hookName}" failed`, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                    // Don't let one plugin break others
+                }
             }
         }
     }
+    async runOnInit() {
+        await this.runHook('onInit');
+        await this.runHook('beforeInit');
+        await this.runHook('afterInit');
+    }
+    async runOnMessage(message) {
+        let msg = message;
+        for (const plugin of this.plugins.values()) {
+            if (plugin.hooks?.onMessage) {
+                const result = await plugin.hooks.onMessage(msg);
+                if (result)
+                    msg = result;
+            }
+            if (plugin.hooks?.beforeMessage) {
+                await plugin.hooks.beforeMessage({ content: msg.content });
+            }
+        }
+        return msg;
+    }
+    async runOnResponse(message, response) {
+        let resp = response;
+        for (const plugin of this.plugins.values()) {
+            if (plugin.hooks?.onResponse) {
+                const result = await plugin.hooks.onResponse(message, resp);
+                if (result)
+                    resp = result;
+            }
+            if (plugin.hooks?.afterMessage) {
+                await plugin.hooks.afterMessage({ content: message.content }, { content: resp.content });
+            }
+        }
+        return resp;
+    }
+    async runOnError(error, context) {
+        await this.runHook('onError', error, context);
+    }
+    async runOnShutdown() {
+        await this.runHook('onShutdown');
+        await this.runHook('beforeShutdown');
+    }
     getAllSkills() {
         const skills = [];
         for (const plugin of this.plugins.values()) {
@@ -56,4 +111,54 @@ class PluginManager {
     }
 }
 exports.PluginManager = PluginManager;
+// ── Built-in Plugins ────────────────────────────────────────
+function createLoggingPlugin() {
+    const logger = new logger_1.Logger('agent:messages');
+    return {
+        name: 'logging',
+        version: '1.0.0',
+        description: 'Logs all messages and responses',
+        hooks: {
+            onInit: async () => { logger.info('Agent initialized'); },
+            onMessage: async (msg) => { logger.info(`← ${msg.role}: ${msg.content.slice(0, 100)}`); return undefined; },
+            onResponse: async (_msg, resp) => { logger.info(`→ ${resp.role}: ${resp.content.slice(0, 100)}`); return undefined; },
+            onError: async (err) => { logger.error(`Error: ${err.message}`); },
+            onShutdown: async () => { logger.info('Agent shutting down'); },
+        },
+    };
+}
+function createAnalyticsPlugin() {
+    const stats = { messages: 0, errors: 0, startedAt: 0 };
+    return {
+        name: 'analytics',
+        version: '1.0.0',
+        description: 'Tracks message counts and error rates',
+        hooks: {
+            onInit: async () => { stats.startedAt = Date.now(); },
+            onMessage: async () => { stats.messages++; return undefined; },
+            onError: async () => { stats.errors++; },
+        },
+    };
+}
+function createRateLimitPlugin(maxPerMinute = 60) {
+    const timestamps = [];
+    return {
+        name: 'rate-limit',
+        version: '1.0.0',
+        description: `Rate limits to ${maxPerMinute} messages/minute`,
+        hooks: {
+            onMessage: async () => {
+                const now = Date.now();
+                const windowStart = now - 60_000;
+                while (timestamps.length > 0 && timestamps[0] < windowStart)
+                    timestamps.shift();
+                if (timestamps.length >= maxPerMinute) {
+                    throw new Error('Rate limit exceeded. Please slow down.');
+                }
+                timestamps.push(now);
+                return undefined;
+            },
+        },
+    };
+}
 //# sourceMappingURL=index.js.map

package/dist/schema/oad.d.ts

@@ -77,6 +77,16 @@ export declare const HITLSchema: z.ZodObject<{
     defaultTimeoutMs?: number | undefined;
     defaultAction?: "approve" | "deny" | undefined;
 }>;
+export declare const PluginRefSchema: z.ZodObject<{
+    name: z.ZodString;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    config?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    config?: Record<string, unknown> | undefined;
+}>;
 export declare const AuthSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     apiKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -479,6 +489,16 @@ export declare const SpecSchema: z.ZodObject<{
         apiKeys?: string[] | undefined;
         sessionIsolation?: boolean | undefined;
     }>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        config?: Record<string, unknown> | undefined;
+    }, {
+        name: string;
+        config?: Record<string, unknown> | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     model: string;
     skills: {
@@ -552,6 +572,10 @@ export declare const SpecSchema: z.ZodObject<{
         defaultTimeoutMs: number;
         defaultAction: "approve" | "deny";
     } | undefined;
+    plugins?: {
+        name: string;
+        config?: Record<string, unknown> | undefined;
+    }[] | undefined;
 }, {
     auth?: {
         enabled?: boolean | undefined;
@@ -625,6 +649,10 @@ export declare const SpecSchema: z.ZodObject<{
         defaultTimeoutMs?: number | undefined;
         defaultAction?: "approve" | "deny" | undefined;
     } | undefined;
+    plugins?: {
+        name: string;
+        config?: Record<string, unknown> | undefined;
+    }[] | undefined;
 }>;
 export declare const OADSchema: z.ZodObject<{
     apiVersion: z.ZodLiteral<"opc/v1">;
@@ -879,6 +907,16 @@ export declare const OADSchema: z.ZodObject<{
             apiKeys?: string[] | undefined;
             sessionIsolation?: boolean | undefined;
         }>>;
+        plugins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            config?: Record<string, unknown> | undefined;
+        }, {
+            name: string;
+            config?: Record<string, unknown> | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         model: string;
         skills: {
@@ -952,6 +990,10 @@ export declare const OADSchema: z.ZodObject<{
             defaultTimeoutMs: number;
             defaultAction: "approve" | "deny";
         } | undefined;
+        plugins?: {
+            name: string;
+            config?: Record<string, unknown> | undefined;
+        }[] | undefined;
     }, {
         auth?: {
             enabled?: boolean | undefined;
@@ -1025,6 +1067,10 @@ export declare const OADSchema: z.ZodObject<{
             defaultTimeoutMs?: number | undefined;
             defaultAction?: "approve" | "deny" | undefined;
         } | undefined;
+        plugins?: {
+            name: string;
+            config?: Record<string, unknown> | undefined;
+        }[] | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     apiVersion: "opc/v1";
@@ -1115,6 +1161,10 @@ export declare const OADSchema: z.ZodObject<{
             defaultTimeoutMs: number;
             defaultAction: "approve" | "deny";
         } | undefined;
+        plugins?: {
+            name: string;
+            config?: Record<string, unknown> | undefined;
+        }[] | undefined;
     };
 }, {
     apiVersion: "opc/v1";
@@ -1205,6 +1255,10 @@ export declare const OADSchema: z.ZodObject<{
             defaultTimeoutMs?: number | undefined;
             defaultAction?: "approve" | "deny" | undefined;
         } | undefined;
+        plugins?: {
+            name: string;
+            config?: Record<string, unknown> | undefined;
+        }[] | undefined;
     };
 }>;
 export type OADDocument = z.infer<typeof OADSchema>;

package/dist/schema/oad.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OADSchema = exports.SpecSchema = exports.StreamingSchema = exports.RoomSchema = exports.MetadataSchema = exports.MarketplaceSchema = exports.ProviderSchema = exports.DTVSchema = exports.TrustLevel = exports.MemorySchema = exports.LongTermMemorySchema = exports.ChannelSchema = exports.AuthSchema = exports.HITLSchema = exports.WebhookSchema = exports.VoiceSchema = exports.WorkflowSchema = exports.WorkflowStepSchema = exports.SkillRefSchema = void 0;
+exports.OADSchema = exports.SpecSchema = exports.StreamingSchema = exports.RoomSchema = exports.MetadataSchema = exports.MarketplaceSchema = exports.ProviderSchema = exports.DTVSchema = exports.TrustLevel = exports.MemorySchema = exports.LongTermMemorySchema = exports.ChannelSchema = exports.AuthSchema = exports.PluginRefSchema = exports.HITLSchema = exports.WebhookSchema = exports.VoiceSchema = exports.WorkflowSchema = exports.WorkflowStepSchema = exports.SkillRefSchema = void 0;
 const zod_1 = require("zod");
 // ─── OAD Schema v1 ───────────────────────────────────────────
 exports.SkillRefSchema = zod_1.z.object({
@@ -43,6 +43,10 @@ exports.HITLSchema = zod_1.z.object({
     defaultTimeoutMs: zod_1.z.number().default(60000),
     defaultAction: zod_1.z.enum(['approve', 'deny']).default('deny'),
 });
+exports.PluginRefSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    config: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
 exports.AuthSchema = zod_1.z.object({
     enabled: zod_1.z.boolean().default(false),
     apiKeys: zod_1.z.array(zod_1.z.string()).default([]),
@@ -115,6 +119,7 @@ exports.SpecSchema = zod_1.z.object({
     webhook: exports.WebhookSchema.optional(),
     hitl: exports.HITLSchema.optional(),
     auth: exports.AuthSchema.optional(),
+    plugins: zod_1.z.array(exports.PluginRefSchema).optional(),
 });
 exports.OADSchema = zod_1.z.object({
     apiVersion: zod_1.z.literal('opc/v1'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "0.9.0",
+  "version": "1.1.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/channels/discord.ts

@@ -0,0 +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;
+  }
+}