opc-agent 2.1.0 → 3.0.1

package/dist/channels/voice.d.ts

@@ -22,15 +22,74 @@ export interface VoiceChannelConfig {
     sampleRate?: number;
     language?: string;
 }
+export interface VoiceConfig {
+    sttProvider: 'whisper' | 'web-speech' | 'deepgram';
+    ttsProvider: 'edge-tts' | 'openai-tts' | 'elevenlabs';
+    sttApiKey?: string;
+    ttsApiKey?: string;
+    voice?: string;
+    language?: string;
+}
+export declare class WhisperSTTProvider implements STTProvider {
+    name: string;
+    private apiKey;
+    constructor(apiKey: string);
+    transcribe(audio: Buffer, options?: STTOptions): Promise<string>;
+}
+export declare class DeepgramSTTProvider implements STTProvider {
+    name: string;
+    private apiKey;
+    constructor(apiKey: string);
+    transcribe(audio: Buffer, options?: STTOptions): Promise<string>;
+}
+export declare class EdgeTTSProvider implements TTSProvider {
+    name: string;
+    private defaultVoice;
+    constructor(voice?: string);
+    synthesize(text: string, options?: TTSOptions): Promise<Buffer>;
+}
+export declare class OpenAITTSProvider implements TTSProvider {
+    name: string;
+    private apiKey;
+    private defaultVoice;
+    constructor(apiKey: string, voice?: string);
+    synthesize(text: string, options?: TTSOptions): Promise<Buffer>;
+}
+export declare class ElevenLabsTTSProvider implements TTSProvider {
+    name: string;
+    private apiKey;
+    private defaultVoice;
+    constructor(apiKey: string, voice?: string);
+    synthesize(text: string, options?: TTSOptions): Promise<Buffer>;
+}
+export declare function createVoiceProviders(config: VoiceConfig): {
+    stt?: STTProvider;
+    tts?: TTSProvider;
+};
 export declare class VoiceChannel extends BaseChannel {
     type: string;
     private config;
     private logger;
     private running;
+    private conversationActive;
     constructor(config?: VoiceChannelConfig);
     start(): Promise<void>;
     stop(): Promise<void>;
     isRunning(): boolean;
+    /** Transcribe audio to text */
+    transcribe(audio: Buffer, format?: string): Promise<string>;
+    /** Synthesize text to audio */
+    synthesize(text: string, voice?: string): Promise<Buffer>;
+    /** Start real-time conversation mode */
+    startConversation(onMessage: (text: string) => Promise<string>): Promise<void>;
+    /** Process a single turn in conversation mode */
+    processConversationTurn(audio: Buffer, onMessage: (text: string) => Promise<string>): Promise<{
+        text: string;
+        response: string;
+        audioResponse?: Buffer;
+    }>;
+    stopConversation(): void;
+    isConversationActive(): boolean;
     /** Process audio input: STT → Agent → TTS */
     processAudio(audio: Buffer): Promise<{
         text: string;

package/dist/channels/voice.js

@@ -1,14 +1,324 @@
 "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.VoiceChannel = void 0;
+exports.VoiceChannel = exports.ElevenLabsTTSProvider = exports.OpenAITTSProvider = exports.EdgeTTSProvider = exports.DeepgramSTTProvider = exports.WhisperSTTProvider = void 0;
+exports.createVoiceProviders = createVoiceProviders;
 const index_1 = require("./index");
 const logger_1 = require("../core/logger");
+const https = __importStar(require("https"));
+// ── Whisper STT Provider ────────────────────────────────────
+class WhisperSTTProvider {
+    name = 'whisper';
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async transcribe(audio, options) {
+        const FormData = (await Promise.resolve(`${'form-data'}`).then(s => __importStar(require(s))).catch(() => null));
+        // Build multipart form data manually
+        const boundary = '----OPCBoundary' + Date.now().toString(36);
+        const parts = [];
+        // file field
+        parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="audio.wav"\r\nContent-Type: audio/wav\r\n\r\n`));
+        parts.push(audio);
+        parts.push(Buffer.from('\r\n'));
+        // model field
+        parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="model"\r\n\r\nwhisper-1\r\n`));
+        // language field
+        if (options?.language) {
+            parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="language"\r\n\r\n${options.language}\r\n`));
+        }
+        parts.push(Buffer.from(`--${boundary}--\r\n`));
+        const body = Buffer.concat(parts);
+        return new Promise((resolve, reject) => {
+            const req = https.request({
+                hostname: 'api.openai.com',
+                path: '/v1/audio/transcriptions',
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                    'Content-Length': body.length,
+                },
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => {
+                    try {
+                        const data = JSON.parse(Buffer.concat(chunks).toString());
+                        resolve(data.text ?? '');
+                    }
+                    catch (e) {
+                        reject(new Error('Failed to parse Whisper response'));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    }
+}
+exports.WhisperSTTProvider = WhisperSTTProvider;
+// ── Deepgram STT Provider ───────────────────────────────────
+class DeepgramSTTProvider {
+    name = 'deepgram';
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async transcribe(audio, options) {
+        const lang = options?.language ?? 'en';
+        return new Promise((resolve, reject) => {
+            const req = https.request({
+                hostname: 'api.deepgram.com',
+                path: `/v1/listen?language=${lang}&model=nova-2`,
+                method: 'POST',
+                headers: {
+                    'Authorization': `Token ${this.apiKey}`,
+                    'Content-Type': 'audio/wav',
+                    'Content-Length': audio.length,
+                },
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => {
+                    try {
+                        const data = JSON.parse(Buffer.concat(chunks).toString());
+                        const transcript = data?.results?.channels?.[0]?.alternatives?.[0]?.transcript ?? '';
+                        resolve(transcript);
+                    }
+                    catch {
+                        reject(new Error('Failed to parse Deepgram response'));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(audio);
+            req.end();
+        });
+    }
+}
+exports.DeepgramSTTProvider = DeepgramSTTProvider;
+// ── Edge TTS Provider (free, no API key) ────────────────────
+class EdgeTTSProvider {
+    name = 'edge-tts';
+    defaultVoice;
+    constructor(voice) {
+        this.defaultVoice = voice ?? 'en-US-AriaNeural';
+    }
+    async synthesize(text, options) {
+        const WebSocket = (await Promise.resolve(`${'ws'}`).then(s => __importStar(require(s))).catch(() => null))?.default;
+        if (!WebSocket) {
+            throw new Error('ws package required for Edge TTS. Install with: npm i ws');
+        }
+        const voice = options?.voice ?? this.defaultVoice;
+        const requestId = [...Array(32)].map(() => Math.random().toString(16)[2]).join('');
+        const timestamp = new Date().toISOString();
+        const endpoint = `wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1?TrustedClientToken=6A5AA1D4EAFF4E9FB37E23D68491D6F4&ConnectionId=${requestId}`;
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(endpoint, {
+                headers: {
+                    'Origin': 'chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold',
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                },
+            });
+            const audioChunks = [];
+            let headerSent = false;
+            ws.on('open', () => {
+                // Send config
+                ws.send(`Content-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":"false","wordBoundaryEnabled":"false"},"outputFormat":"audio-24khz-48kbitrate-mono-mp3"}}}}`);
+                // Send SSML
+                const ssml = `<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' xml:lang='en-US'><voice name='${voice}'>${escapeXml(text)}</voice></speak>`;
+                ws.send(`X-RequestId:${requestId}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${timestamp}\r\nPath:ssml\r\n\r\n${ssml}`);
+            });
+            ws.on('message', (data) => {
+                if (typeof data === 'string' || (Buffer.isBuffer(data) && data.toString().includes('Path:turn.end'))) {
+                    if (typeof data === 'string' && data.includes('Path:turn.end')) {
+                        ws.close();
+                        resolve(Buffer.concat(audioChunks));
+                    }
+                }
+                else if (Buffer.isBuffer(data)) {
+                    // Binary message — extract audio after header
+                    const headerEnd = data.indexOf(Buffer.from('\r\n\r\n'));
+                    if (headerEnd !== -1) {
+                        audioChunks.push(data.slice(headerEnd + 4));
+                    }
+                }
+            });
+            ws.on('error', (err) => {
+                reject(new Error(`Edge TTS WebSocket error: ${err.message}`));
+            });
+            ws.on('close', () => {
+                if (audioChunks.length > 0) {
+                    resolve(Buffer.concat(audioChunks));
+                }
+            });
+            // Timeout
+            setTimeout(() => {
+                ws.close();
+                if (audioChunks.length > 0) {
+                    resolve(Buffer.concat(audioChunks));
+                }
+                else {
+                    reject(new Error('Edge TTS timeout'));
+                }
+            }, 30000);
+        });
+    }
+}
+exports.EdgeTTSProvider = EdgeTTSProvider;
+function escapeXml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+}
+// ── OpenAI TTS Provider ─────────────────────────────────────
+class OpenAITTSProvider {
+    name = 'openai-tts';
+    apiKey;
+    defaultVoice;
+    constructor(apiKey, voice) {
+        this.apiKey = apiKey;
+        this.defaultVoice = voice ?? 'alloy';
+    }
+    async synthesize(text, options) {
+        const voice = options?.voice ?? this.defaultVoice;
+        const body = JSON.stringify({
+            model: 'tts-1',
+            input: text,
+            voice,
+            speed: options?.speed ?? 1.0,
+        });
+        return new Promise((resolve, reject) => {
+            const req = https.request({
+                hostname: 'api.openai.com',
+                path: '/v1/audio/speech',
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => resolve(Buffer.concat(chunks)));
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    }
+}
+exports.OpenAITTSProvider = OpenAITTSProvider;
+// ── ElevenLabs TTS Provider ─────────────────────────────────
+class ElevenLabsTTSProvider {
+    name = 'elevenlabs';
+    apiKey;
+    defaultVoice;
+    constructor(apiKey, voice) {
+        this.apiKey = apiKey;
+        this.defaultVoice = voice ?? '21m00Tcm4TlvDq8ikWAM'; // Rachel
+    }
+    async synthesize(text, options) {
+        const voiceId = options?.voice ?? this.defaultVoice;
+        const body = JSON.stringify({
+            text,
+            model_id: 'eleven_monolingual_v1',
+        });
+        return new Promise((resolve, reject) => {
+            const req = https.request({
+                hostname: 'api.elevenlabs.io',
+                path: `/v1/text-to-speech/${voiceId}`,
+                method: 'POST',
+                headers: {
+                    'xi-api-key': this.apiKey,
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => resolve(Buffer.concat(chunks)));
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    }
+}
+exports.ElevenLabsTTSProvider = ElevenLabsTTSProvider;
+// ── Voice Config Factory ────────────────────────────────────
+function createVoiceProviders(config) {
+    let stt;
+    let tts;
+    switch (config.sttProvider) {
+        case 'whisper':
+            if (config.sttApiKey)
+                stt = new WhisperSTTProvider(config.sttApiKey);
+            break;
+        case 'deepgram':
+            if (config.sttApiKey)
+                stt = new DeepgramSTTProvider(config.sttApiKey);
+            break;
+        case 'web-speech':
+            // Browser only — not available in Node.js
+            break;
+    }
+    switch (config.ttsProvider) {
+        case 'edge-tts':
+            tts = new EdgeTTSProvider(config.voice);
+            break;
+        case 'openai-tts':
+            if (config.ttsApiKey)
+                tts = new OpenAITTSProvider(config.ttsApiKey, config.voice);
+            break;
+        case 'elevenlabs':
+            if (config.ttsApiKey)
+                tts = new ElevenLabsTTSProvider(config.ttsApiKey, config.voice);
+            break;
+    }
+    return { stt, tts };
+}
 // ── Voice Channel ───────────────────────────────────────────
 class VoiceChannel extends index_1.BaseChannel {
     type = 'voice';
     config;
     logger = new logger_1.Logger('voice-channel');
     running = false;
+    conversationActive = false;
     constructor(config) {
         super();
         this.config = config ?? {};
@@ -22,11 +332,51 @@ class VoiceChannel extends index_1.BaseChannel {
     }
     async stop() {
         this.running = false;
+        this.conversationActive = false;
         this.logger.info('Voice channel stopped');
     }
     isRunning() {
         return this.running;
     }
+    /** Transcribe audio to text */
+    async transcribe(audio, format) {
+        if (!this.config.sttProvider) {
+            throw new Error('No STT provider configured');
+        }
+        return this.config.sttProvider.transcribe(audio, { language: this.config.language });
+    }
+    /** Synthesize text to audio */
+    async synthesize(text, voice) {
+        if (!this.config.ttsProvider) {
+            throw new Error('No TTS provider configured');
+        }
+        return this.config.ttsProvider.synthesize(text, { voice });
+    }
+    /** Start real-time conversation mode */
+    async startConversation(onMessage) {
+        if (!this.running)
+            await this.start();
+        this.conversationActive = true;
+        this.logger.info('Conversation mode started');
+        // In a real implementation, this would set up a microphone stream.
+        // For now, expose the conversation loop for programmatic use.
+    }
+    /** Process a single turn in conversation mode */
+    async processConversationTurn(audio, onMessage) {
+        const text = await this.transcribe(audio);
+        const response = await onMessage(text);
+        let audioResponse;
+        if (this.config.ttsProvider) {
+            audioResponse = await this.synthesize(response);
+        }
+        return { text, response, audioResponse };
+    }
+    stopConversation() {
+        this.conversationActive = false;
+    }
+    isConversationActive() {
+        return this.conversationActive;
+    }
     /** Process audio input: STT → Agent → TTS */
     async processAudio(audio) {
         if (!this.handler)

package/dist/cli.js

@@ -57,6 +57,7 @@ const analytics_engine_1 = require("./core/analytics-engine");
 const testing_1 = require("./testing");
 const openclaw_1 = require("./deploy/openclaw");
 const hermes_1 = require("./deploy/hermes");
+const index_1 = require("./deploy/index");
 const workflow_1 = require("./core/workflow");
 const versioning_1 = require("./core/versioning");
 const providers_1 = require("./providers");
@@ -977,9 +978,70 @@ program
     .option('-t, --target <target>', 'Deploy target', 'openclaw')
     .option('-o, --output <dir>', 'Output directory')
     .option('--install', 'Also register in OpenClaw config')
+    .option('--docker', 'Generate Dockerfile + docker-compose.yml')
+    .option('--railway', 'Deploy to Railway')
+    .option('--fly', 'Deploy to Fly.io')
+    .option('--local', 'Deploy locally via Docker Compose')
+    .option('-p, --port <port>', 'Port number', '3000')
+    .option('--replicas <n>', 'Number of replicas', '1')
     .action(async (opts) => {
+    const deployer = new index_1.AgentDeployer();
+    const agentDir = path.resolve(opts.output || '.');
+    // New deploy modes
+    if (opts.docker) {
+        console.log(`\n${icon.rocket} ${color.bold('Generating Docker deployment files')}\n`);
+        const result = await deployer.generateFiles(agentDir, { port: parseInt(opts.port), replicas: parseInt(opts.replicas) });
+        console.log(`${icon.success} ${result.message}`);
+        for (const f of (result.files || []))
+            console.log(`   ${icon.file} ${f}`);
+        console.log();
+        return;
+    }
+    if (opts.railway) {
+        console.log(`\n${icon.rocket} ${color.bold('Deploying to Railway')}\n`);
+        const result = await deployer.deployRailway(agentDir);
+        if (result.success) {
+            console.log(`${icon.success} ${result.message}`);
+            if (result.url)
+                console.log(`   URL: ${color.cyan(result.url)}`);
+        }
+        else {
+            console.error(`${icon.error} ${result.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    if (opts.fly) {
+        console.log(`\n${icon.rocket} ${color.bold('Deploying to Fly.io')}\n`);
+        const result = await deployer.deployFly(agentDir);
+        if (result.success) {
+            console.log(`${icon.success} ${result.message}`);
+            if (result.url)
+                console.log(`   URL: ${color.cyan(result.url)}`);
+        }
+        else {
+            console.error(`${icon.error} ${result.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    if (opts.local) {
+        console.log(`\n${icon.rocket} ${color.bold('Deploying locally via Docker')}\n`);
+        const result = await deployer.deployLocal(agentDir, { port: parseInt(opts.port), replicas: parseInt(opts.replicas) });
+        if (result.success) {
+            console.log(`${icon.success} ${result.message}`);
+            if (result.url)
+                console.log(`   URL: ${color.cyan(result.url)}`);
+        }
+        else {
+            console.error(`${icon.error} ${result.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    // Legacy deploy modes
     if (opts.target !== 'openclaw' && opts.target !== 'hermes') {
-        console.error(`${icon.error} Unknown target: ${color.bold(opts.target)}. Supported: openclaw, hermes`);
+        console.error(`${icon.error} Unknown target: ${color.bold(opts.target)}. Supported: openclaw, hermes, --docker, --railway, --fly, --local`);
         process.exit(1);
     }
     try {
@@ -1974,6 +2036,82 @@ program
     }
     console.log(`\n${color.bold('Summary:')} ${allPassed}/${allTotal} passed (${allTotal ? Math.round(allPassed / allTotal * 100) : 0}%)`);
 });
+// ── Guardrails command ────────────────────────────────────────
+const guardrailsCmd = program.command('guardrails').description('Guardrail utilities');
+guardrailsCmd
+    .command('test <message>')
+    .description('Test guardrails against a message')
+    .option('-c, --config <file>', 'OAD config file with guardrails')
+    .action(async (message, opts) => {
+    const { GuardrailManager, createGuardrailsFromConfig } = await Promise.resolve().then(() => __importStar(require('./security/guardrails')));
+    let manager;
+    if (opts.config) {
+        const raw = fs.readFileSync(opts.config, 'utf-8');
+        const doc = yaml.load(raw);
+        manager = createGuardrailsFromConfig(doc.spec?.guardrails ?? {});
+    }
+    else {
+        // Default: all built-in rules
+        manager = new GuardrailManager({
+            input: [
+                { name: 'pii-detector', type: 'regex', action: 'redact' },
+                { name: 'prompt-injection', type: 'keyword', action: 'block' },
+                { name: 'toxicity', type: 'keyword', action: 'block' },
+                { name: 'compliance-filter', type: 'keyword', action: 'block' },
+            ],
+            output: [],
+        });
+    }
+    console.log(color.bold('Testing guardrails against:'), message);
+    console.log();
+    const result = await manager.checkInput(message);
+    if (result.passed) {
+        console.log(color.green('✓ PASSED — no violations'));
+    }
+    else {
+        if (result.blocked)
+            console.log(color.red('✗ BLOCKED'));
+        if (result.warned)
+            console.log(color.yellow('⚠ WARNING'));
+        if (result.redacted) {
+            console.log(color.yellow('✎ REDACTED'));
+            console.log('  Redacted text:', result.redactedText);
+        }
+        for (const v of result.violations) {
+            console.log(`  [${v.action}] ${v.rule}: ${v.detail}`);
+        }
+    }
+});
+// ── Voice command ─────────────────────────────────────────────
+program
+    .command('voice')
+    .description('Voice conversation utilities')
+    .command('start')
+    .description('Start voice conversation (requires STT/TTS providers)')
+    .option('--stt <provider>', 'STT provider: whisper, deepgram', 'whisper')
+    .option('--tts <provider>', 'TTS provider: edge-tts, openai-tts, elevenlabs', 'edge-tts')
+    .option('--voice <name>', 'Voice name/id')
+    .option('--language <lang>', 'Language code', 'en')
+    .action(async (opts) => {
+    console.log(color.bold('🎤 Voice Conversation Mode'));
+    console.log(`  STT: ${opts.stt} | TTS: ${opts.tts} | Voice: ${opts.voice ?? 'default'} | Language: ${opts.language}`);
+    console.log(color.dim('  (Voice conversation requires audio input integration — use as library)'));
+    console.log();
+    console.log('To use voice in your agent:');
+    console.log(color.cyan(`
+  import { VoiceChannel, createVoiceProviders } from 'opc-agent';
+
+  const { stt, tts } = createVoiceProviders({
+    sttProvider: '${opts.stt}',
+    ttsProvider: '${opts.tts}',
+    voice: '${opts.voice ?? 'en-US-AriaNeural'}',
+    language: '${opts.language}',
+  });
+
+  const voice = new VoiceChannel({ sttProvider: stt, ttsProvider: tts });
+  await voice.start();
+`));
+});
 program.parse();
 // ── Keys command ──────────────────────────────────────────────
 const keys_1 = require("./security/keys");
@@ -2250,4 +2388,37 @@ mcpCmd
     }
     console.log();
 });
+mcpCmd
+    .command('list')
+    .description('List available pre-built MCP servers')
+    .action(() => {
+    const { listMCPServers } = require('./mcp/servers');
+    const servers = listMCPServers();
+    console.log(`\n${icon.gear} Available MCP Servers:\n`);
+    for (const s of servers) {
+        console.log(`  ${color.green(s.name.padEnd(14))} ${s.description} ${color.dim(`(${s.toolCount} tools, v${s.version})`)}`);
+    }
+    console.log(`\n  Total: ${servers.length} servers\n`);
+});
+mcpCmd
+    .command('start')
+    .argument('<name>', 'Server name (e.g. filesystem, github, calculator)')
+    .option('--port <port>', 'Start in HTTP+SSE mode on given port')
+    .description('Start a pre-built MCP server (stdio by default)')
+    .action(async (name, opts) => {
+    const { getMCPServer } = require('./mcp/servers');
+    const { MCPServer } = require('./protocols/mcp');
+    const config = getMCPServer(name);
+    const server = new MCPServer(config);
+    if (opts.port) {
+        const port = parseInt(opts.port) || 3100;
+        await server.serveHTTP(port);
+        console.log(`${icon.success} MCP server ${color.cyan(name)} running on http://localhost:${port}`);
+        console.log(`${icon.info} Tools: ${server.getToolCount()}`);
+    }
+    else {
+        console.error(`${icon.success} MCP server ${color.cyan(name)} (stdio) — ${server.getToolCount()} tools`);
+        await server.serveStdio();
+    }
+});
 //# sourceMappingURL=cli.js.map

package/dist/core/agent.d.ts

@@ -7,6 +7,7 @@ import { MCPToolRegistry } from '../tools/mcp';
 import { type SubAgentConfig, type SubAgentResult } from './subagent';
 import { Tracer } from '../telemetry';
 import { type BrainSeedConfig } from '../memory/seed-loader';
+import { GuardrailManager, type GuardrailConfig } from '../security/guardrails';
 export declare class BaseAgent extends EventEmitter implements IAgent {
     readonly name: string;
     private _state;
@@ -26,6 +27,7 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
     private tracer?;
     private brainSeedConfig?;
     private agentDir;
+    private guardrails?;
     constructor(options: {
         name: string;
         systemPrompt?: string;
@@ -48,6 +50,8 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
         autoLearn?: boolean;
         autoRecall?: boolean;
     }): void;
+    setGuardrails(config: GuardrailConfig): void;
+    getGuardrails(): GuardrailManager | undefined;
     getLongTermMemory(): any;
     getLongTermMemoryConfig(): {
         autoLearn: boolean;