opc-agent 0.9.0 → 1.1.0

package/dist/core/errors.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * OPC Agent Error Hierarchy - v1.0.0
+ * Custom error classes with user-friendly messages and recovery hints.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = exports.SecurityError = exports.RateLimitError = exports.PluginError = exports.ChannelError = exports.ConfigError = exports.ValidationError = exports.ProviderError = exports.OPCError = void 0;
+exports.wrapError = wrapError;
+exports.formatErrorForUser = formatErrorForUser;
+class OPCError extends Error {
+    code;
+    hint;
+    context;
+    timestamp = Date.now();
+    constructor(message, opts) {
+        super(message);
+        this.name = 'OPCError';
+        this.code = opts?.code ?? 'OPC_UNKNOWN';
+        this.hint = opts?.hint;
+        this.context = opts?.context;
+        if (opts?.cause)
+            this.cause = opts.cause;
+    }
+    toJSON() {
+        return { name: this.name, code: this.code, message: this.message, hint: this.hint, context: this.context, timestamp: this.timestamp };
+    }
+    toUserMessage() {
+        return this.hint ? `${this.message}\n💡 ${this.hint}` : this.message;
+    }
+}
+exports.OPCError = OPCError;
+class ProviderError extends OPCError {
+    provider;
+    statusCode;
+    constructor(provider, message, opts) {
+        super(message, {
+            code: 'OPC_PROVIDER_ERROR',
+            hint: opts?.hint ?? `Check your API key and network connection for ${provider}.`,
+            context: { provider, statusCode: opts?.statusCode },
+            cause: opts?.cause,
+        });
+        this.name = 'ProviderError';
+        this.provider = provider;
+        this.statusCode = opts?.statusCode;
+    }
+}
+exports.ProviderError = ProviderError;
+class ValidationError extends OPCError {
+    field;
+    errors;
+    constructor(message, errors = [], field) {
+        super(message, {
+            code: 'OPC_VALIDATION_ERROR',
+            hint: 'Check your OAD configuration file for missing or invalid fields.',
+            context: { field, errors },
+        });
+        this.name = 'ValidationError';
+        this.field = field;
+        this.errors = errors;
+    }
+}
+exports.ValidationError = ValidationError;
+class ConfigError extends OPCError {
+    constructor(message, hint) {
+        super(message, { code: 'OPC_CONFIG_ERROR', hint: hint ?? 'Check your oad.yaml and .env files.' });
+        this.name = 'ConfigError';
+    }
+}
+exports.ConfigError = ConfigError;
+class ChannelError extends OPCError {
+    channelType;
+    constructor(channelType, message, opts) {
+        super(message, {
+            code: 'OPC_CHANNEL_ERROR',
+            hint: opts?.hint ?? `Check configuration for the ${channelType} channel.`,
+            context: { channelType },
+            cause: opts?.cause,
+        });
+        this.name = 'ChannelError';
+        this.channelType = channelType;
+    }
+}
+exports.ChannelError = ChannelError;
+class PluginError extends OPCError {
+    pluginName;
+    constructor(pluginName, message, opts) {
+        super(message, {
+            code: 'OPC_PLUGIN_ERROR',
+            hint: opts?.hint ?? `Check plugin "${pluginName}" configuration.`,
+            context: { pluginName },
+            cause: opts?.cause,
+        });
+        this.name = 'PluginError';
+        this.pluginName = pluginName;
+    }
+}
+exports.PluginError = PluginError;
+class RateLimitError extends OPCError {
+    retryAfterMs;
+    constructor(message, retryAfterMs) {
+        super(message ?? 'Rate limit exceeded. Please slow down.', {
+            code: 'OPC_RATE_LIMIT',
+            hint: retryAfterMs ? `Try again in ${Math.ceil(retryAfterMs / 1000)} seconds.` : 'Please wait before sending more messages.',
+            context: { retryAfterMs },
+        });
+        this.name = 'RateLimitError';
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+exports.RateLimitError = RateLimitError;
+class SecurityError extends OPCError {
+    constructor(message, hint) {
+        super(message, { code: 'OPC_SECURITY_ERROR', hint: hint ?? 'This request was blocked for security reasons.' });
+        this.name = 'SecurityError';
+    }
+}
+exports.SecurityError = SecurityError;
+class TimeoutError extends OPCError {
+    constructor(operation, timeoutMs) {
+        super(`Operation "${operation}" timed out after ${timeoutMs}ms`, {
+            code: 'OPC_TIMEOUT',
+            hint: 'The operation took too long. Try again or increase the timeout.',
+            context: { operation, timeoutMs },
+        });
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;
+/**
+ * Wrap an unknown thrown value into an OPCError.
+ */
+function wrapError(err, fallbackMessage = 'An unexpected error occurred') {
+    if (err instanceof OPCError)
+        return err;
+    if (err instanceof Error)
+        return new OPCError(err.message, { cause: err });
+    return new OPCError(typeof err === 'string' ? err : fallbackMessage);
+}
+/**
+ * Format error for user display (no stack traces).
+ */
+function formatErrorForUser(err) {
+    if (err instanceof OPCError)
+        return err.toUserMessage();
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/security.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Security Hardening Module - v1.0.0
+ * Input sanitization, CORS, security headers, API key rotation.
+ */
+import type { Request, Response, NextFunction } from 'express';
+export declare function sanitizeInput(input: string): string;
+export declare function detectInjection(input: string): {
+    safe: boolean;
+    threats: string[];
+};
+export interface SecurityHeadersConfig {
+    contentSecurityPolicy?: string;
+    enableHSTS?: boolean;
+    frameDeny?: boolean;
+    xssProtection?: boolean;
+    noSniff?: boolean;
+    referrerPolicy?: string;
+}
+export declare function securityHeaders(config?: SecurityHeadersConfig): (_req: Request, res: Response, next: NextFunction) => void;
+export interface CORSConfig {
+    origins?: string[];
+    methods?: string[];
+    allowHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+export declare function corsMiddleware(config?: CORSConfig): (req: Request, res: Response, next: NextFunction) => void;
+export interface APIKeyEntry {
+    key: string;
+    label?: string;
+    createdAt: number;
+    expiresAt?: number;
+    active: boolean;
+}
+export declare class APIKeyManager {
+    private keys;
+    addKey(key: string, opts?: {
+        label?: string;
+        expiresAt?: number;
+    }): void;
+    revokeKey(key: string): boolean;
+    isValid(key: string): boolean;
+    rotateKey(oldKey: string, newKey: string): boolean;
+    listActive(): APIKeyEntry[];
+    cleanup(): number;
+}
+export declare function inputValidation(): (req: Request, res: Response, next: NextFunction) => void;
+//# sourceMappingURL=security.d.ts.map

package/dist/core/security.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Security Hardening Module - v1.0.0
+ * Input sanitization, CORS, security headers, API key rotation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIKeyManager = void 0;
+exports.sanitizeInput = sanitizeInput;
+exports.detectInjection = detectInjection;
+exports.securityHeaders = securityHeaders;
+exports.corsMiddleware = corsMiddleware;
+exports.inputValidation = inputValidation;
+// ── Input Sanitization ──────────────────────────────────────
+const XSS_PATTERNS = [
+    /<script\b[^>]*>[\s\S]*?<\/script>/gi,
+    /javascript:/gi,
+    /on\w+\s*=/gi,
+    /<iframe\b/gi,
+    /<object\b/gi,
+    /<embed\b/gi,
+    /<form\b/gi,
+];
+const SQL_PATTERNS = [
+    /(\b(SELECT|INSERT|UPDATE|DELETE|DROP|UNION|ALTER|CREATE|EXEC)\b.*\b(FROM|INTO|TABLE|SET|WHERE|ALL)\b)/gi,
+    /(--|;)\s*(DROP|ALTER|DELETE)/gi,
+];
+function sanitizeInput(input) {
+    let clean = input;
+    for (const pattern of XSS_PATTERNS) {
+        clean = clean.replace(pattern, '');
+    }
+    // Encode dangerous HTML entities
+    clean = clean.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    return clean;
+}
+function detectInjection(input) {
+    const threats = [];
+    for (const pattern of XSS_PATTERNS) {
+        if (pattern.test(input))
+            threats.push('xss');
+        pattern.lastIndex = 0;
+    }
+    for (const pattern of SQL_PATTERNS) {
+        if (pattern.test(input))
+            threats.push('sql_injection');
+        pattern.lastIndex = 0;
+    }
+    return { safe: threats.length === 0, threats: [...new Set(threats)] };
+}
+function securityHeaders(config) {
+    const csp = config?.contentSecurityPolicy ?? "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'";
+    return (_req, res, next) => {
+        res.setHeader('Content-Security-Policy', csp);
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Frame-Options', config?.frameDeny !== false ? 'DENY' : 'SAMEORIGIN');
+        res.setHeader('X-XSS-Protection', '1; mode=block');
+        res.setHeader('Referrer-Policy', config?.referrerPolicy ?? 'strict-origin-when-cross-origin');
+        if (config?.enableHSTS !== false) {
+            res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
+        }
+        res.removeHeader('X-Powered-By');
+        next();
+    };
+}
+function corsMiddleware(config) {
+    const origins = config?.origins ?? ['*'];
+    const methods = config?.methods ?? ['GET', 'POST', 'OPTIONS'];
+    const headers = config?.allowHeaders ?? ['Content-Type', 'Authorization'];
+    return (req, res, next) => {
+        const origin = req.headers.origin ?? '';
+        if (origins.includes('*') || origins.includes(origin)) {
+            res.setHeader('Access-Control-Allow-Origin', origins.includes('*') ? '*' : origin);
+        }
+        res.setHeader('Access-Control-Allow-Methods', methods.join(', '));
+        res.setHeader('Access-Control-Allow-Headers', headers.join(', '));
+        if (config?.credentials)
+            res.setHeader('Access-Control-Allow-Credentials', 'true');
+        if (config?.maxAge)
+            res.setHeader('Access-Control-Max-Age', String(config.maxAge));
+        if (req.method === 'OPTIONS') {
+            res.status(204).end();
+            return;
+        }
+        next();
+    };
+}
+class APIKeyManager {
+    keys = [];
+    addKey(key, opts) {
+        this.keys.push({ key, label: opts?.label, createdAt: Date.now(), expiresAt: opts?.expiresAt, active: true });
+    }
+    revokeKey(key) {
+        const entry = this.keys.find(k => k.key === key);
+        if (entry) {
+            entry.active = false;
+            return true;
+        }
+        return false;
+    }
+    isValid(key) {
+        const entry = this.keys.find(k => k.key === key);
+        if (!entry || !entry.active)
+            return false;
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+            entry.active = false;
+            return false;
+        }
+        return true;
+    }
+    rotateKey(oldKey, newKey) {
+        const entry = this.keys.find(k => k.key === oldKey && k.active);
+        if (!entry)
+            return false;
+        entry.active = false;
+        this.addKey(newKey, { label: entry.label });
+        return true;
+    }
+    listActive() {
+        return this.keys.filter(k => k.active && (!k.expiresAt || Date.now() <= k.expiresAt));
+    }
+    cleanup() {
+        const before = this.keys.length;
+        this.keys = this.keys.filter(k => k.active && (!k.expiresAt || Date.now() <= k.expiresAt));
+        return before - this.keys.length;
+    }
+}
+exports.APIKeyManager = APIKeyManager;
+// ── Input Validation Middleware ──────────────────────────────
+function inputValidation() {
+    return (req, res, next) => {
+        if (req.body?.message && typeof req.body.message === 'string') {
+            const check = detectInjection(req.body.message);
+            if (!check.safe) {
+                res.status(400).json({ error: 'Input contains potentially unsafe content', threats: check.threats });
+                return;
+            }
+            // Limit message size
+            if (req.body.message.length > 100_000) {
+                res.status(413).json({ error: 'Message too large (max 100KB)' });
+                return;
+            }
+        }
+        next();
+    };
+}
+//# sourceMappingURL=security.js.map

package/dist/core/watch.d.ts

@@ -0,0 +1,73 @@
+import { EventEmitter } from 'events';
+/**
+ * ProcessWatcher — Background process output monitoring with pattern matching.
+ *
+ * Inspired by Hermes Agent's watch_patterns feature.
+ * Set patterns to watch for in background process output and get callbacks
+ * when they match — no polling needed.
+ *
+ * Usage:
+ *   const watcher = new ProcessWatcher();
+ *   watcher.watch(childProcess.stdout, {
+ *     patterns: [
+ *       { regex: /listening on port (\d+)/, label: 'server-ready' },
+ *       { regex: /error|Error|ERROR/, label: 'error-detected' },
+ *       { regex: /build completed/, label: 'build-done', once: true },
+ *     ],
+ *     onMatch: (match) => console.log(`[${match.label}] ${match.line}`),
+ *   });
+ */
+export interface WatchPattern {
+    /** Regex to match against each line of output */
+    regex: RegExp;
+    /** Human-readable label for this pattern */
+    label: string;
+    /** If true, auto-remove after first match */
+    once?: boolean;
+}
+export interface WatchMatch {
+    /** Pattern label */
+    label: string;
+    /** The full line that matched */
+    line: string;
+    /** Regex match groups */
+    groups: string[];
+    /** Timestamp of match */
+    timestamp: number;
+    /** Stream source */
+    stream: 'stdout' | 'stderr';
+}
+export interface WatchOptions {
+    /** Patterns to match */
+    patterns: WatchPattern[];
+    /** Callback on match */
+    onMatch: (match: WatchMatch) => void;
+    /** Optional: max matches to keep in history (default: 100) */
+    maxHistory?: number;
+}
+export declare class ProcessWatcher extends EventEmitter {
+    private watchers;
+    private watcherIdCounter;
+    /**
+     * Start watching a readable stream for patterns.
+     * Returns a watcher ID that can be used to stop watching.
+     */
+    watch(stream: NodeJS.ReadableStream, options: WatchOptions, streamName?: 'stdout' | 'stderr'): string;
+    /**
+     * Watch both stdout and stderr of a ChildProcess.
+     */
+    watchProcess(proc: {
+        stdout?: NodeJS.ReadableStream | null;
+        stderr?: NodeJS.ReadableStream | null;
+    }, options: WatchOptions): string[];
+    /** Stop a specific watcher */
+    unwatch(id: string): void;
+    /** Get match history for a watcher */
+    getHistory(id: string): WatchMatch[];
+    /** Add a pattern to an existing watcher */
+    addPattern(id: string, pattern: WatchPattern): void;
+    /** Remove a pattern by label from a watcher */
+    removePattern(id: string, label: string): void;
+    private matchLine;
+}
+//# sourceMappingURL=watch.d.ts.map

package/dist/core/watch.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessWatcher = void 0;
+const events_1 = require("events");
+class ProcessWatcher extends events_1.EventEmitter {
+    watchers = new Map();
+    watcherIdCounter = 0;
+    /**
+     * Start watching a readable stream for patterns.
+     * Returns a watcher ID that can be used to stop watching.
+     */
+    watch(stream, options, streamName = 'stdout') {
+        const id = `watcher_${++this.watcherIdCounter}`;
+        const state = {
+            patterns: [...options.patterns],
+            onMatch: options.onMatch,
+            history: [],
+            maxHistory: options.maxHistory ?? 100,
+        };
+        this.watchers.set(id, state);
+        let buffer = '';
+        const onData = (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                this.matchLine(id, line, streamName);
+            }
+        };
+        stream.on('data', onData);
+        stream.on('end', () => {
+            // Process remaining buffer
+            if (buffer)
+                this.matchLine(id, buffer, streamName);
+            this.watchers.delete(id);
+            this.emit('watcher:end', id);
+        });
+        return id;
+    }
+    /**
+     * Watch both stdout and stderr of a ChildProcess.
+     */
+    watchProcess(proc, options) {
+        const ids = [];
+        if (proc.stdout)
+            ids.push(this.watch(proc.stdout, options, 'stdout'));
+        if (proc.stderr)
+            ids.push(this.watch(proc.stderr, options, 'stderr'));
+        return ids;
+    }
+    /** Stop a specific watcher */
+    unwatch(id) {
+        this.watchers.delete(id);
+    }
+    /** Get match history for a watcher */
+    getHistory(id) {
+        return this.watchers.get(id)?.history ?? [];
+    }
+    /** Add a pattern to an existing watcher */
+    addPattern(id, pattern) {
+        const state = this.watchers.get(id);
+        if (state)
+            state.patterns.push(pattern);
+    }
+    /** Remove a pattern by label from a watcher */
+    removePattern(id, label) {
+        const state = this.watchers.get(id);
+        if (state) {
+            state.patterns = state.patterns.filter(p => p.label !== label);
+        }
+    }
+    matchLine(watcherId, line, stream) {
+        const state = this.watchers.get(watcherId);
+        if (!state)
+            return;
+        const toRemove = [];
+        for (let i = 0; i < state.patterns.length; i++) {
+            const pattern = state.patterns[i];
+            const m = line.match(pattern.regex);
+            if (m) {
+                const match = {
+                    label: pattern.label,
+                    line,
+                    groups: m.slice(1),
+                    timestamp: Date.now(),
+                    stream,
+                };
+                state.history.push(match);
+                if (state.history.length > state.maxHistory) {
+                    state.history.shift();
+                }
+                state.onMatch(match);
+                this.emit('match', match);
+                if (pattern.once) {
+                    toRemove.push(i);
+                }
+            }
+        }
+        // Remove once-patterns in reverse order
+        for (let i = toRemove.length - 1; i >= 0; i--) {
+            state.patterns.splice(toRemove[i], 1);
+        }
+    }
+}
+exports.ProcessWatcher = ProcessWatcher;
+//# sourceMappingURL=watch.js.map

package/dist/index.d.ts

@@ -80,4 +80,15 @@ export type { CacheConfig, CacheEntry } from './core/cache';
 export { getSupportedLocales } from './i18n';
 export { createDataAnalystConfig } from './templates/data-analyst';
 export { createTeacherConfig } from './templates/teacher';
+export { OPCError, ProviderError, ValidationError, ConfigError, ChannelError, PluginError, RateLimitError, SecurityError, TimeoutError, wrapError, formatErrorForUser } from './core/errors';
+export { sanitizeInput, detectInjection, securityHeaders, corsMiddleware, APIKeyManager, inputValidation } from './core/security';
+export type { SecurityHeadersConfig, CORSConfig, APIKeyEntry } from './core/security';
+export { createLoggingPlugin, createAnalyticsPlugin, createRateLimitPlugin } from './plugins';
+export type { PluginManifest } from './plugins';
+export { FeishuChannel } from './channels/feishu';
+export type { FeishuChannelConfig } from './channels/feishu';
+export { DiscordChannel } from './channels/discord';
+export type { DiscordChannelConfig } from './channels/discord';
+export { ProcessWatcher } from './core/watch';
+export type { WatchPattern, WatchMatch, WatchOptions } from './core/watch';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmailChannel = exports.compose = exports.AgentPipeline = exports.Orchestrator = exports.getActiveSessions = exports.createAuthMiddleware = exports.installAgent = exports.publishAgent = exports.deployToHermes = exports.KnowledgeBase = exports.addMessages = exports.detectLocale = exports.getLocale = exports.setLocale = exports.t = exports.LazyLoader = exports.RequestBatcher = exports.ConnectionPool = exports.VersionManager = exports.WebhookChannel = exports.VoiceChannel = exports.HITLManager = exports.AgentRegistry = exports.WorkflowEngine = exports.Analytics = exports.Sandbox = exports.PluginManager = exports.createMCPTool = exports.MCPToolRegistry = exports.Room = exports.SUPPORTED_PROVIDERS = exports.createProvider = exports.MRGConfigReader = exports.ValueTracker = exports.TrustManager = exports.DeepBrainMemoryStore = exports.InMemoryStore = exports.SkillRegistry = exports.BaseSkill = exports.WebSocketChannel = exports.TelegramChannel = exports.WebChannel = exports.BaseChannel = exports.OADSchema = exports.validateOAD = exports.loadOAD = exports.Logger = exports.truncateOutput = exports.AgentRuntime = exports.BaseAgent = void 0;
-exports.createTeacherConfig = exports.createDataAnalystConfig = exports.getSupportedLocales = exports.LLMCache = exports.RateLimiter = exports.AnalyticsEngine = exports.formatReport = exports.loadTestCases = exports.runTests = exports.DocumentSkill = exports.SchedulerSkill = exports.WebhookTriggerSkill = exports.HttpSkill = exports.TextAnalysisTool = exports.JsonTransformTool = exports.DateTimeTool = exports.CalculatorTool = exports.WeChatChannel = exports.SlackChannel = void 0;
+exports.ProcessWatcher = exports.DiscordChannel = exports.FeishuChannel = exports.createRateLimitPlugin = exports.createAnalyticsPlugin = exports.createLoggingPlugin = exports.inputValidation = exports.APIKeyManager = exports.corsMiddleware = exports.securityHeaders = exports.detectInjection = exports.sanitizeInput = exports.formatErrorForUser = exports.wrapError = exports.TimeoutError = exports.SecurityError = exports.RateLimitError = exports.PluginError = exports.ChannelError = exports.ConfigError = exports.ValidationError = exports.ProviderError = exports.OPCError = exports.createTeacherConfig = exports.createDataAnalystConfig = exports.getSupportedLocales = exports.LLMCache = exports.RateLimiter = exports.AnalyticsEngine = exports.formatReport = exports.loadTestCases = exports.runTests = exports.DocumentSkill = exports.SchedulerSkill = exports.WebhookTriggerSkill = exports.HttpSkill = exports.TextAnalysisTool = exports.JsonTransformTool = exports.DateTimeTool = exports.CalculatorTool = exports.WeChatChannel = exports.SlackChannel = void 0;
 // OPC Agent — Open Agent Framework
 var agent_1 = require("./core/agent");
 Object.defineProperty(exports, "BaseAgent", { enumerable: true, get: function () { return agent_1.BaseAgent; } });
@@ -132,4 +132,35 @@ var data_analyst_1 = require("./templates/data-analyst");
 Object.defineProperty(exports, "createDataAnalystConfig", { enumerable: true, get: function () { return data_analyst_1.createDataAnalystConfig; } });
 var teacher_1 = require("./templates/teacher");
 Object.defineProperty(exports, "createTeacherConfig", { enumerable: true, get: function () { return teacher_1.createTeacherConfig; } });
+// v1.0.0 modules
+var errors_1 = require("./core/errors");
+Object.defineProperty(exports, "OPCError", { enumerable: true, get: function () { return errors_1.OPCError; } });
+Object.defineProperty(exports, "ProviderError", { enumerable: true, get: function () { return errors_1.ProviderError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });
+Object.defineProperty(exports, "ConfigError", { enumerable: true, get: function () { return errors_1.ConfigError; } });
+Object.defineProperty(exports, "ChannelError", { enumerable: true, get: function () { return errors_1.ChannelError; } });
+Object.defineProperty(exports, "PluginError", { enumerable: true, get: function () { return errors_1.PluginError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "SecurityError", { enumerable: true, get: function () { return errors_1.SecurityError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_1.TimeoutError; } });
+Object.defineProperty(exports, "wrapError", { enumerable: true, get: function () { return errors_1.wrapError; } });
+Object.defineProperty(exports, "formatErrorForUser", { enumerable: true, get: function () { return errors_1.formatErrorForUser; } });
+var security_1 = require("./core/security");
+Object.defineProperty(exports, "sanitizeInput", { enumerable: true, get: function () { return security_1.sanitizeInput; } });
+Object.defineProperty(exports, "detectInjection", { enumerable: true, get: function () { return security_1.detectInjection; } });
+Object.defineProperty(exports, "securityHeaders", { enumerable: true, get: function () { return security_1.securityHeaders; } });
+Object.defineProperty(exports, "corsMiddleware", { enumerable: true, get: function () { return security_1.corsMiddleware; } });
+Object.defineProperty(exports, "APIKeyManager", { enumerable: true, get: function () { return security_1.APIKeyManager; } });
+Object.defineProperty(exports, "inputValidation", { enumerable: true, get: function () { return security_1.inputValidation; } });
+var plugins_2 = require("./plugins");
+Object.defineProperty(exports, "createLoggingPlugin", { enumerable: true, get: function () { return plugins_2.createLoggingPlugin; } });
+Object.defineProperty(exports, "createAnalyticsPlugin", { enumerable: true, get: function () { return plugins_2.createAnalyticsPlugin; } });
+Object.defineProperty(exports, "createRateLimitPlugin", { enumerable: true, get: function () { return plugins_2.createRateLimitPlugin; } });
+// v1.1.0 modules
+var feishu_1 = require("./channels/feishu");
+Object.defineProperty(exports, "FeishuChannel", { enumerable: true, get: function () { return feishu_1.FeishuChannel; } });
+var discord_1 = require("./channels/discord");
+Object.defineProperty(exports, "DiscordChannel", { enumerable: true, get: function () { return discord_1.DiscordChannel; } });
+var watch_1 = require("./core/watch");
+Object.defineProperty(exports, "ProcessWatcher", { enumerable: true, get: function () { return watch_1.ProcessWatcher; } });
 //# sourceMappingURL=index.js.map

package/dist/plugins/index.d.ts

@@ -1,9 +1,14 @@
-import type { ISkill, IChannel } from '../core/types';
+import type { ISkill, IChannel, Message } from '../core/types';
 import type { MCPTool } from '../tools/mcp';
 /**
- * Plugin lifecycle hooks.
+ * Plugin lifecycle hooks - v1.0.0
  */
 export interface PluginHooks {
+    onInit?: () => Promise<void>;
+    onMessage?: (message: Message) => Promise<Message | void>;
+    onResponse?: (message: Message, response: Message) => Promise<Message | void>;
+    onError?: (error: Error, context?: Record<string, unknown>) => Promise<void>;
+    onShutdown?: () => Promise<void>;
     beforeInit?: () => Promise<void>;
     afterInit?: () => Promise<void>;
     beforeMessage?: (message: {
@@ -17,7 +22,14 @@ export interface PluginHooks {
     beforeShutdown?: () => Promise<void>;
 }
 /**
- * Plugin interface — extend agent with skills, tools, channels, and lifecycle hooks.
+ * Plugin manifest in OAD: plugins: [{ name, config }]
+ */
+export interface PluginManifest {
+    name: string;
+    config?: Record<string, unknown>;
+}
+/**
+ * Plugin interface - extend agent with skills, tools, channels, and lifecycle hooks.
  */
 export interface IPlugin {
     name: string;
@@ -30,6 +42,7 @@ export interface IPlugin {
 }
 export declare class PluginManager {
     private plugins;
+    private logger;
     register(plugin: IPlugin): void;
     unregister(name: string): void;
     get(name: string): IPlugin | undefined;
@@ -40,8 +53,16 @@ export declare class PluginManager {
     }[];
     has(name: string): boolean;
     runHook(hookName: keyof PluginHooks, ...args: unknown[]): Promise<void>;
+    runOnInit(): Promise<void>;
+    runOnMessage(message: Message): Promise<Message>;
+    runOnResponse(message: Message, response: Message): Promise<Message>;
+    runOnError(error: Error, context?: Record<string, unknown>): Promise<void>;
+    runOnShutdown(): Promise<void>;
     getAllSkills(): ISkill[];
     getAllTools(): MCPTool[];
     getAllChannels(): IChannel[];
 }
+export declare function createLoggingPlugin(): IPlugin;
+export declare function createAnalyticsPlugin(): IPlugin;
+export declare function createRateLimitPlugin(maxPerMinute?: number): IPlugin;
 //# sourceMappingURL=index.d.ts.map