opc-agent 2.1.0 → 3.0.0

package/dist/core/agent.js

@@ -8,6 +8,7 @@ const auto_learn_1 = require("../skills/auto-learn");
 const mcp_1 = require("../tools/mcp");
 const subagent_1 = require("./subagent");
 const seed_loader_1 = require("../memory/seed-loader");
+const guardrails_1 = require("../security/guardrails");
 class BaseAgent extends events_1.EventEmitter {
     name;
     _state = 'init';
@@ -27,6 +28,7 @@ class BaseAgent extends events_1.EventEmitter {
     tracer;
     brainSeedConfig;
     agentDir;
+    guardrails;
     constructor(options) {
         super();
         this.name = options.name;
@@ -56,6 +58,12 @@ class BaseAgent extends events_1.EventEmitter {
             };
         }
     }
+    setGuardrails(config) {
+        this.guardrails = new guardrails_1.GuardrailManager(config);
+    }
+    getGuardrails() {
+        return this.guardrails;
+    }
     getLongTermMemory() {
         return this.longTermMemory;
     }
@@ -163,6 +171,23 @@ class BaseAgent extends events_1.EventEmitter {
         }
         const sessionId = message.metadata?.sessionId ?? 'default';
         await this.memory.addMessage(sessionId, message);
+        // === Guardrails: check input ===
+        if (this.guardrails) {
+            const inputCheck = await this.guardrails.checkInput(message.content);
+            if (inputCheck.blocked) {
+                const blockedResponse = this.createResponse(inputCheck.message ?? 'Message blocked by guardrails.', message);
+                await this.memory.addMessage(sessionId, blockedResponse);
+                this.emit('message:out', blockedResponse);
+                if (rootSpan && this.tracer) {
+                    this.tracer.addEvent(rootSpan, 'guardrail.blocked', { rule: inputCheck.violations[0]?.rule ?? 'unknown' });
+                    this.tracer.endSpan(rootSpan, 'ok');
+                }
+                return blockedResponse;
+            }
+            if (inputCheck.redacted && inputCheck.redactedText) {
+                message = { ...message, content: inputCheck.redactedText };
+            }
+        }
         // === Recall from long-term memory ===
         let memoryContext = '';
         if (this.longTermMemory && this.longTermMemoryConfig.autoRecall) {
@@ -278,6 +303,16 @@ class BaseAgent extends events_1.EventEmitter {
                 timestamp: Date.now(),
             });
         }
+        // === Guardrails: check output ===
+        if (this.guardrails) {
+            const outputCheck = await this.guardrails.checkOutput(finalResponse);
+            if (outputCheck.blocked) {
+                finalResponse = outputCheck.message ?? 'Response blocked by guardrails.';
+            }
+            else if (outputCheck.redacted && outputCheck.redactedText) {
+                finalResponse = outputCheck.redactedText;
+            }
+        }
         const response = this.createResponse(finalResponse, message);
         await this.memory.addMessage(sessionId, response);
         this.emit('message:out', response);

package/dist/core/collaboration.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Multi-agent collaboration patterns
+ * @module core/collaboration
+ */
+import type { BaseAgent } from './agent';
+import type { Message } from './types';
+export interface DebateArgument {
+    agent: string;
+    round: number;
+    argument: string;
+}
+export interface DebateResult {
+    topic: string;
+    rounds: DebateArgument[];
+    summary: string;
+    judge?: string;
+}
+export interface VoteEntry {
+    agent: string;
+    choice: string;
+    confidence: number;
+}
+export interface VoteResult {
+    question: string;
+    votes: VoteEntry[];
+    winner: string;
+    tally: Record<string, number>;
+}
+export interface PipelineStageResult {
+    agent: string;
+    input: string;
+    output: string;
+    durationMs: number;
+}
+export interface PipelineResult {
+    stages: PipelineStageResult[];
+    finalOutput: string;
+    totalDurationMs: number;
+}
+export interface WorkerResult {
+    agent: string;
+    subtask: string;
+    result: string;
+}
+export interface HierarchyResult {
+    task: string;
+    subtasks: WorkerResult[];
+    synthesis: string;
+}
+export declare class DebatePattern {
+    private agents;
+    private rounds;
+    constructor(agents: BaseAgent[], rounds?: number);
+    debate(topic: string, judgeAgent?: BaseAgent): Promise<DebateResult>;
+}
+export declare class VotingPattern {
+    private agents;
+    constructor(agents: BaseAgent[]);
+    vote(question: string, options: string[]): Promise<VoteResult>;
+    weightedVote(question: string, options: string[]): Promise<VoteResult>;
+    private tallyVotes;
+}
+export declare class PipelinePattern {
+    private stages;
+    constructor(stages: {
+        agent: BaseAgent;
+        transform?: (input: string) => string;
+    }[]);
+    process(input: string): Promise<PipelineResult>;
+}
+export declare class HierarchyPattern {
+    private leader;
+    private workers;
+    constructor(leader: BaseAgent, workers: BaseAgent[]);
+    execute(task: string): Promise<HierarchyResult>;
+}
+export declare class SharedContext {
+    private store;
+    private listeners;
+    set(key: string, value: any): void;
+    get<T>(key: string): T | undefined;
+    getAll(): Record<string, any>;
+    onChange(key: string, callback: (value: any) => void): void;
+}
+export declare class ConversationProtocol {
+    roundRobin(agents: BaseAgent[], topic: string, rounds: number): Promise<Message[]>;
+    moderated(agents: BaseAgent[], moderator: BaseAgent, topic: string): Promise<Message[]>;
+}
+//# sourceMappingURL=collaboration.d.ts.map

package/dist/core/collaboration.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * Multi-agent collaboration patterns
+ * @module core/collaboration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationProtocol = exports.SharedContext = exports.HierarchyPattern = exports.PipelinePattern = exports.VotingPattern = exports.DebatePattern = void 0;
+// ─── Helper ─────────────────────────────────────────────────
+function makeMsg(role, content) {
+    return { id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, role, content, timestamp: Date.now() };
+}
+async function agentChat(agent, prompt) {
+    const response = await agent.handleMessage(makeMsg('user', prompt));
+    return response.content;
+}
+// ─── DebatePattern ──────────────────────────────────────────
+class DebatePattern {
+    agents;
+    rounds;
+    constructor(agents, rounds = 3) {
+        this.agents = agents;
+        this.rounds = rounds;
+    }
+    async debate(topic, judgeAgent) {
+        const allArgs = [];
+        let context = '';
+        for (let round = 1; round <= this.rounds; round++) {
+            for (const agent of this.agents) {
+                const prompt = round === 1
+                    ? `Debate topic: "${topic}". Present your argument.`
+                    : `Debate topic: "${topic}". Previous arguments:\n${context}\nPresent your counter-argument for round ${round}.`;
+                const argument = await agentChat(agent, prompt);
+                allArgs.push({ agent: agent.name, round, argument });
+                context += `\n[${agent.name} round ${round}]: ${argument}`;
+            }
+        }
+        const judge = judgeAgent ?? this.agents[0];
+        const summaryPrompt = `You are the judge. Summarize and decide the winner of this debate on "${topic}":\n${context}`;
+        const summary = await agentChat(judge, summaryPrompt);
+        return { topic, rounds: allArgs, summary, judge: judge.name };
+    }
+}
+exports.DebatePattern = DebatePattern;
+// ─── VotingPattern ──────────────────────────────────────────
+class VotingPattern {
+    agents;
+    constructor(agents) {
+        this.agents = agents;
+    }
+    async vote(question, options) {
+        const votes = [];
+        const optionList = options.map((o, i) => `${i + 1}. ${o}`).join('\n');
+        for (const agent of this.agents) {
+            const prompt = `Question: "${question}"\nOptions:\n${optionList}\nRespond with ONLY the exact text of your chosen option.`;
+            const raw = await agentChat(agent, prompt);
+            const choice = options.find(o => raw.includes(o)) ?? raw.trim();
+            votes.push({ agent: agent.name, choice, confidence: 1 });
+        }
+        return this.tallyVotes(question, votes);
+    }
+    async weightedVote(question, options) {
+        const votes = [];
+        const optionList = options.map((o, i) => `${i + 1}. ${o}`).join('\n');
+        for (const agent of this.agents) {
+            const prompt = `Question: "${question}"\nOptions:\n${optionList}\nRespond in format: CHOICE|CONFIDENCE(0-1)`;
+            const raw = await agentChat(agent, prompt);
+            const parts = raw.split('|');
+            const choiceRaw = parts[0]?.trim() ?? '';
+            const choice = options.find(o => choiceRaw.includes(o)) ?? choiceRaw;
+            const confidence = Math.min(1, Math.max(0, parseFloat(parts[1] ?? '0.5') || 0.5));
+            votes.push({ agent: agent.name, choice, confidence });
+        }
+        return this.tallyVotes(question, votes);
+    }
+    tallyVotes(question, votes) {
+        const tally = {};
+        for (const v of votes) {
+            tally[v.choice] = (tally[v.choice] ?? 0) + v.confidence;
+        }
+        const winner = Object.entries(tally).sort((a, b) => b[1] - a[1])[0]?.[0] ?? '';
+        return { question, votes, winner, tally };
+    }
+}
+exports.VotingPattern = VotingPattern;
+// ─── PipelinePattern ────────────────────────────────────────
+class PipelinePattern {
+    stages;
+    constructor(stages) {
+        this.stages = stages;
+    }
+    async process(input) {
+        const stageResults = [];
+        let current = input;
+        const t0 = Date.now();
+        for (const stage of this.stages) {
+            const stageInput = stage.transform ? stage.transform(current) : current;
+            const start = Date.now();
+            const output = await agentChat(stage.agent, stageInput);
+            stageResults.push({ agent: stage.agent.name, input: stageInput, output, durationMs: Date.now() - start });
+            current = output;
+        }
+        return { stages: stageResults, finalOutput: current, totalDurationMs: Date.now() - t0 };
+    }
+}
+exports.PipelinePattern = PipelinePattern;
+// ─── HierarchyPattern ───────────────────────────────────────
+class HierarchyPattern {
+    leader;
+    workers;
+    constructor(leader, workers) {
+        this.leader = leader;
+        this.workers = workers;
+    }
+    async execute(task) {
+        // Leader decomposes
+        const decomposePrompt = `Decompose this task into ${this.workers.length} subtasks (one per line, no numbering): "${task}"`;
+        const decomposition = await agentChat(this.leader, decomposePrompt);
+        const subtasks = decomposition.split('\n').map(s => s.trim()).filter(Boolean);
+        // Workers execute in parallel
+        const workerResults = await Promise.all(this.workers.map(async (worker, i) => {
+            const subtask = subtasks[i] ?? subtasks[subtasks.length - 1] ?? task;
+            const result = await agentChat(worker, `Complete this subtask: "${subtask}"`);
+            return { agent: worker.name, subtask, result };
+        }));
+        // Leader synthesizes
+        const synthPrompt = `Original task: "${task}"\nSubtask results:\n${workerResults.map(r => `[${r.agent}] ${r.subtask}: ${r.result}`).join('\n')}\nSynthesize a final answer.`;
+        const synthesis = await agentChat(this.leader, synthPrompt);
+        return { task, subtasks: workerResults, synthesis };
+    }
+}
+exports.HierarchyPattern = HierarchyPattern;
+// ─── SharedContext ───────────────────────────────────────────
+class SharedContext {
+    store = new Map();
+    listeners = new Map();
+    set(key, value) {
+        this.store.set(key, value);
+        const cbs = this.listeners.get(key);
+        if (cbs)
+            cbs.forEach(cb => cb(value));
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    getAll() {
+        const result = {};
+        for (const [k, v] of this.store)
+            result[k] = v;
+        return result;
+    }
+    onChange(key, callback) {
+        const existing = this.listeners.get(key) ?? [];
+        existing.push(callback);
+        this.listeners.set(key, existing);
+    }
+}
+exports.SharedContext = SharedContext;
+// ─── ConversationProtocol ───────────────────────────────────
+class ConversationProtocol {
+    async roundRobin(agents, topic, rounds) {
+        const messages = [];
+        let context = `Topic: "${topic}"`;
+        for (let round = 0; round < rounds; round++) {
+            for (const agent of agents) {
+                const prompt = `${context}\n\nIt's your turn to contribute to this discussion. Be concise.`;
+                const content = await agentChat(agent, prompt);
+                const msg = makeMsg('assistant', content);
+                msg.agent = agent.name;
+                messages.push(msg);
+                context += `\n[${agent.name}]: ${content}`;
+            }
+        }
+        return messages;
+    }
+    async moderated(agents, moderator, topic) {
+        const messages = [];
+        let context = `Topic: "${topic}"`;
+        // Moderator opens
+        const opening = await agentChat(moderator, `You are moderating a discussion on "${topic}". Introduce the topic and ask the first question.`);
+        const openMsg = makeMsg('assistant', opening);
+        openMsg.agent = moderator.name;
+        messages.push(openMsg);
+        context += `\n[Moderator ${moderator.name}]: ${opening}`;
+        // Each agent responds
+        for (const agent of agents) {
+            const content = await agentChat(agent, `${context}\n\nRespond to the moderator's question.`);
+            const msg = makeMsg('assistant', content);
+            msg.agent = agent.name;
+            messages.push(msg);
+            context += `\n[${agent.name}]: ${content}`;
+        }
+        // Moderator summarizes
+        const summary = await agentChat(moderator, `${context}\n\nSummarize the discussion and provide closing remarks.`);
+        const closeMsg = makeMsg('assistant', summary);
+        closeMsg.agent = moderator.name;
+        messages.push(closeMsg);
+        return messages;
+    }
+}
+exports.ConversationProtocol = ConversationProtocol;
+//# sourceMappingURL=collaboration.js.map

package/dist/deploy/index.d.ts

@@ -0,0 +1,40 @@
+export interface DeployOptions {
+    port?: number;
+    env?: Record<string, string>;
+    platform?: 'docker' | 'railway' | 'fly' | 'render';
+    replicas?: number;
+}
+export interface DeployResult {
+    platform: string;
+    success: boolean;
+    url?: string;
+    message: string;
+    files?: string[];
+}
+export declare class AgentDeployer {
+    /**
+     * Generate Dockerfile for the agent
+     */
+    generateDockerfile(agentDir: string, options?: DeployOptions): Promise<string>;
+    /**
+     * Generate docker-compose.yml
+     */
+    generateCompose(agentDir: string, options?: DeployOptions): Promise<string>;
+    /**
+     * Deploy to Railway (via CLI)
+     */
+    deployRailway(agentDir: string): Promise<DeployResult>;
+    /**
+     * Deploy to Fly.io
+     */
+    deployFly(agentDir: string): Promise<DeployResult>;
+    /**
+     * Deploy locally via Docker
+     */
+    deployLocal(agentDir: string, options?: DeployOptions): Promise<DeployResult>;
+    /**
+     * Generate deployment files without deploying
+     */
+    generateFiles(agentDir: string, options?: DeployOptions): Promise<DeployResult>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/deploy/index.js

@@ -0,0 +1,261 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentDeployer = void 0;
+/**
+ * AgentDeployer - Deploy agents to Docker, Railway, Fly.io
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+class AgentDeployer {
+    /**
+     * Generate Dockerfile for the agent
+     */
+    async generateDockerfile(agentDir, options) {
+        const port = options?.port || 3000;
+        const pkgPath = path.join(agentDir, 'package.json');
+        let startCmd = 'node src/index.js';
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.scripts?.start) {
+                    startCmd = pkg.scripts.start;
+                }
+                if (pkg.main) {
+                    startCmd = `node ${pkg.main}`;
+                }
+            }
+            catch { }
+        }
+        return `FROM node:22-slim
+WORKDIR /app
+
+# Install dependencies
+COPY package*.json ./
+RUN npm ci --production
+
+# Copy source
+COPY . .
+
+# Build if needed
+RUN if [ -f "tsconfig.json" ]; then npx tsc || true; fi
+
+EXPOSE ${port}
+
+ENV NODE_ENV=production
+ENV PORT=${port}
+
+CMD ["${startCmd.split(' ')[0]}", ${startCmd.split(' ').slice(1).map(s => `"${s}"`).join(', ')}]
+`;
+    }
+    /**
+     * Generate docker-compose.yml
+     */
+    async generateCompose(agentDir, options) {
+        const port = options?.port || 3000;
+        const replicas = options?.replicas || 1;
+        const agentName = path.basename(agentDir).toLowerCase().replace(/[^a-z0-9-]/g, '-') || 'opc-agent';
+        const envLines = options?.env
+            ? Object.entries(options.env).map(([k, v]) => `      - ${k}=${v}`).join('\n')
+            : '';
+        return `version: "3.8"
+
+services:
+  ${agentName}:
+    build: .
+    ports:
+      - "${port}:${port}"
+    environment:
+      - NODE_ENV=production
+      - PORT=${port}
+${envLines ? envLines + '\n' : ''}    restart: unless-stopped
+${replicas > 1 ? `    deploy:\n      replicas: ${replicas}` : ''}
+    volumes:
+      - agent-data:/app/data
+
+volumes:
+  agent-data:
+`;
+    }
+    /**
+     * Deploy to Railway (via CLI)
+     */
+    async deployRailway(agentDir) {
+        try {
+            (0, child_process_1.execSync)('railway version', { stdio: 'pipe' });
+        }
+        catch {
+            return { platform: 'railway', success: false, message: 'Railway CLI not installed. Run: npm i -g @railway/cli' };
+        }
+        try {
+            // Ensure Dockerfile exists
+            const dockerfilePath = path.join(agentDir, 'Dockerfile');
+            if (!fs.existsSync(dockerfilePath)) {
+                const content = await this.generateDockerfile(agentDir);
+                fs.writeFileSync(dockerfilePath, content);
+            }
+            const output = (0, child_process_1.execSync)('railway up --detach', { cwd: agentDir, encoding: 'utf-8' });
+            const urlMatch = output.match(/(https:\/\/[^\s]+)/);
+            return {
+                platform: 'railway',
+                success: true,
+                url: urlMatch?.[1],
+                message: 'Deployed to Railway successfully'
+            };
+        }
+        catch (e) {
+            return { platform: 'railway', success: false, message: e.message };
+        }
+    }
+    /**
+     * Deploy to Fly.io
+     */
+    async deployFly(agentDir) {
+        try {
+            (0, child_process_1.execSync)('fly version', { stdio: 'pipe' });
+        }
+        catch {
+            return { platform: 'fly', success: false, message: 'Fly CLI not installed. Run: curl -L https://fly.io/install.sh | sh' };
+        }
+        try {
+            const agentName = path.basename(agentDir).toLowerCase().replace(/[^a-z0-9-]/g, '-');
+            // Generate fly.toml if not exists
+            const flyTomlPath = path.join(agentDir, 'fly.toml');
+            if (!fs.existsSync(flyTomlPath)) {
+                fs.writeFileSync(flyTomlPath, `app = "${agentName}"
+primary_region = "sjc"
+
+[build]
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+
+[checks]
+  [checks.alive]
+    type = "tcp"
+    port = 3000
+`);
+            }
+            // Ensure Dockerfile exists
+            const dockerfilePath = path.join(agentDir, 'Dockerfile');
+            if (!fs.existsSync(dockerfilePath)) {
+                const content = await this.generateDockerfile(agentDir);
+                fs.writeFileSync(dockerfilePath, content);
+            }
+            const output = (0, child_process_1.execSync)('fly deploy', { cwd: agentDir, encoding: 'utf-8' });
+            return {
+                platform: 'fly',
+                success: true,
+                url: `https://${agentName}.fly.dev`,
+                message: 'Deployed to Fly.io successfully'
+            };
+        }
+        catch (e) {
+            return { platform: 'fly', success: false, message: e.message };
+        }
+    }
+    /**
+     * Deploy locally via Docker
+     */
+    async deployLocal(agentDir, options) {
+        try {
+            (0, child_process_1.execSync)('docker version', { stdio: 'pipe' });
+        }
+        catch {
+            return { platform: 'docker', success: false, message: 'Docker not installed or not running' };
+        }
+        const files = [];
+        // Generate Dockerfile
+        const dockerfilePath = path.join(agentDir, 'Dockerfile');
+        if (!fs.existsSync(dockerfilePath)) {
+            fs.writeFileSync(dockerfilePath, await this.generateDockerfile(agentDir, options));
+            files.push('Dockerfile');
+        }
+        // Generate docker-compose.yml
+        const composePath = path.join(agentDir, 'docker-compose.yml');
+        if (!fs.existsSync(composePath)) {
+            fs.writeFileSync(composePath, await this.generateCompose(agentDir, options));
+            files.push('docker-compose.yml');
+        }
+        try {
+            (0, child_process_1.execSync)('docker compose up -d --build', { cwd: agentDir, stdio: 'inherit' });
+            const port = options?.port || 3000;
+            return {
+                platform: 'docker',
+                success: true,
+                url: `http://localhost:${port}`,
+                message: 'Running locally via Docker',
+                files
+            };
+        }
+        catch (e) {
+            return { platform: 'docker', success: false, message: e.message, files };
+        }
+    }
+    /**
+     * Generate deployment files without deploying
+     */
+    async generateFiles(agentDir, options) {
+        const files = [];
+        const port = options?.port || 3000;
+        const dockerfile = await this.generateDockerfile(agentDir, options);
+        fs.writeFileSync(path.join(agentDir, 'Dockerfile'), dockerfile);
+        files.push('Dockerfile');
+        const compose = await this.generateCompose(agentDir, options);
+        fs.writeFileSync(path.join(agentDir, 'docker-compose.yml'), compose);
+        files.push('docker-compose.yml');
+        // Generate .dockerignore
+        const dockerignore = `node_modules
+.git
+.env
+*.log
+dist
+`;
+        fs.writeFileSync(path.join(agentDir, '.dockerignore'), dockerignore);
+        files.push('.dockerignore');
+        return {
+            platform: 'docker',
+            success: true,
+            message: `Generated ${files.length} deployment files`,
+            files,
+        };
+    }
+}
+exports.AgentDeployer = AgentDeployer;
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -35,7 +35,8 @@ export type { A2ARequest, A2AResponse, AgentCapability, AgentRegistration, Agent
 export { HITLManager } from './core/hitl';
 export type { ApprovalRequest, ApprovalResponse, HITLConfig } from './core/hitl';
 export { VoiceChannel } from './channels/voice';
-export type { VoiceChannelConfig, STTProvider, TTSProvider } from './channels/voice';
+export type { VoiceChannelConfig, STTProvider, TTSProvider, VoiceConfig } from './channels/voice';
+export { WhisperSTTProvider, DeepgramSTTProvider, EdgeTTSProvider, OpenAITTSProvider, ElevenLabsTTSProvider, createVoiceProviders } from './channels/voice';
 export { WebhookChannel } from './channels/webhook';
 export type { WebhookConfig, WebhookPayload } from './channels/webhook';
 export { VersionManager } from './core/versioning';
@@ -90,6 +91,8 @@ export type { PluginManifest, Plugin } from './plugins';
 export { loggerPlugin } from './plugins/logger';
 export { rateLimiterPlugin, createRateLimiterPlugin as createEnhancedRateLimiterPlugin } from './plugins/rate-limiter';
 export { contentFilterPlugin, createContentFilterPlugin } from './plugins/content-filter';
+export { GuardrailManager, createGuardrailsFromConfig } from './security/guardrails';
+export type { GuardrailConfig, GuardrailRule, GuardrailResult, GuardrailViolation } from './security/guardrails';
 export { FeishuChannel } from './channels/feishu';
 export type { FeishuChannelConfig } from './channels/feishu';
 export { DiscordChannel } from './channels/discord';
@@ -124,5 +127,8 @@ export { AgentEvaluator } from './eval';
 export type { EvalCase, EvalResult, EvalSuite, EvalReport } from './eval';
 export { AGUIServer, AGUIEventEmitter, AGUIClient } from './protocols/agui';
 export { AGUI_EVENT_TYPES, isValidEventType } from './protocols/agui';
+export { DebatePattern, VotingPattern, PipelinePattern, HierarchyPattern, SharedContext, ConversationProtocol } from './core/collaboration';
+export type { DebateResult, DebateArgument, VoteResult, VoteEntry, PipelineResult, PipelineStageResult, HierarchyResult, WorkerResult } from './core/collaboration';
 export type { AGUIEvent, AGUIEventType, AGUIMessage, AGUIRunRequest, AGUIToolCall, AGUIToolDefinition, TextMessageStartEvent, TextMessageContentEvent, TextMessageEndEvent, ToolCallStartEvent, ToolCallArgsEvent, ToolCallEndEvent, StateSnapshotEvent, StateDeltaEvent, MessagesSnapshotEvent, RunStartedEvent, RunFinishedEvent, RunErrorEvent, StepStartedEvent, StepFinishedEvent, CustomEvent, } from './protocols/agui';
+export { SlackTool, EmailSendTool, WebhookTool, NotionTool, GitHubTool, JiraTool, CalendarTool, TrelloTool, WebSearchTool, WebScraperTool, DatabaseTool, VectorSearchTool, CodeExecutionTool, GitTool, NpmTool, ImageGenerationTool, PDFReaderTool, CSVAnalyzerTool, SummarizerTool, TranslatorTool, getAllIntegrationTools, getIntegrationTool, } from './tools/integrations';
 //# sourceMappingURL=index.d.ts.map