opc-agent 2.0.2 → 3.0.0

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");
@@ -188,9 +189,21 @@ program
         fs.mkdirSync(dir, { recursive: true });
         fs.mkdirSync(path.join(dir, 'src', 'skills'), { recursive: true });
         fs.mkdirSync(path.join(dir, 'data'), { recursive: true });
+        fs.mkdirSync(path.join(dir, 'brain-seeds'), { recursive: true });
         // Get system prompt content
         const systemPromptContent = roleData.files['system-prompt.md'] || roleData.files['prompts/system.md'] || '';
-        // agent.yaml with role system prompt
+        // Generate brain-seeds/ files from role data
+        const brainSeedContent = roleData.files['brain-seed.md'] || '';
+        const industryMatch = brainSeedContent ? brainSeedContent.match(/# Industry Knowledge[\s\S]*?(?=# Job Knowledge|# Workstation Knowledge|$)/i) : null;
+        const jobMatch = brainSeedContent ? brainSeedContent.match(/# Job Knowledge[\s\S]*?(?=# Industry Knowledge|# Workstation Knowledge|$)/i) : null;
+        const workstationMatch = brainSeedContent ? brainSeedContent.match(/# Workstation Knowledge[\s\S]*?(?=# Industry Knowledge|# Job Knowledge|$)/i) : null;
+        fs.writeFileSync(path.join(dir, 'brain-seeds', 'industry.md'), industryMatch?.[0]?.trim() || `# Industry Knowledge\n\n## Overview\n\nAdd industry-specific knowledge for your domain.\n`);
+        fs.writeFileSync(path.join(dir, 'brain-seeds', 'job.md'), jobMatch?.[0]?.trim() || `# Job Knowledge\n\n## Core Skills\n\nAdd role-specific knowledge for ${roleDisplayName}.\n`);
+        // workstation.md: public workstation knowledge (tools, workflows, best practices)
+        // Company-specific knowledge belongs to Desk (closed-source), not here.
+        const workstationSeedFromRole = workstationMatch?.[0]?.trim() || '';
+        fs.writeFileSync(path.join(dir, 'brain-seeds', 'workstation.md'), workstationSeedFromRole || `# Workstation Knowledge\n\n## Tools & Environment\n\nCommon tools and setup for this workstation role.\n\n## Workflows\n\nStandard operating procedures and workflows.\n\n## Best Practices\n\nIndustry best practices for this role.\n`);
+        // agent.yaml with role system prompt and brain seeds
         const firstLine = systemPromptContent.split('\n').find((l) => l.trim() && !l.startsWith('#'))?.trim() || 'You are a helpful AI assistant.';
         fs.writeFileSync(path.join(dir, 'agent.yaml'), `apiVersion: opc/v1
 kind: Agent
@@ -212,6 +225,15 @@ spec:
     longTerm:
       provider: deepbrain
       database: ./data/brain.db
+  brain:
+    seeds:
+      - brain-seeds/industry.md
+      - brain-seeds/job.md
+      - brain-seeds/workstation.md
+    autoSeed: true
+    evolve:
+      enabled: true
+      direction: bottom-up
   skills: []
 `);
         // SOUL.md from system-prompt.md
@@ -292,8 +314,12 @@ export class EchoSkill extends BaseSkill {
         console.log(`   ${icon.file} agent.yaml       - Agent definition with role system prompt`);
         console.log(`   ${icon.file} SOUL.md          - Role personality (${systemPromptContent.split('\n').length} lines)`);
         console.log(`   ${icon.file} CONTEXT.md       - Role context & documentation`);
+        console.log(`   ${icon.file} brain-seeds/     - 3-tier brain seed knowledge`);
+        console.log(`     ${color.dim('├')} industry.md    - Industry knowledge`);
+        console.log(`     ${color.dim('├')} job.md         - Job/role knowledge`);
+        console.log(`     ${color.dim('└')} workstation.md - Workstation knowledge`);
         if (roleData.files['brain-seed.md']) {
-            console.log(`   ${icon.file} data/brain-seed.md - Role brain seed knowledge`);
+            console.log(`   ${icon.file} data/brain-seed.md - Role brain seed knowledge (legacy)`);
         }
         console.log(`   ${icon.file} src/index.ts     - Entry point`);
         console.log(`   ${icon.file} package.json     - Dependencies`);
@@ -952,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 {
@@ -1403,9 +1490,12 @@ program
     }
 });
 // ── Brain command ────────────────────────────────────────────
-program
+const brainCmd = program
     .command('brain')
-    .description('Show agent memory/brain status from DeepBrain')
+    .description('Manage agent brain (memory, seeds, evolve)');
+brainCmd
+    .command('status')
+    .description('Show brain stats (pages, tiers, last evolve)')
     .option('--url <url>', 'DeepBrain server URL', 'http://localhost:3333')
     .action(async (opts) => {
     console.log(`\n${icon.gear} ${color.bold('DeepBrain Status')} — ${color.dim(opts.url)}\n`);
@@ -1438,6 +1528,86 @@ program
         }
     }
 });
+brainCmd
+    .command('seed')
+    .description('Import brain seed files into memory')
+    .option('-f, --file <file>', 'OAD file', 'agent.yaml')
+    .option('--status', 'Check if seeds have been imported')
+    .option('--reset', 'Re-import seeds (clear marker and re-seed)')
+    .action(async (opts) => {
+    const { BrainSeedLoader } = require('./memory/seed-loader');
+    let config = {};
+    try {
+        config = yaml.load(fs.readFileSync(opts.file, 'utf-8'));
+    }
+    catch { /* ignore */ }
+    const brainConfig = config?.spec?.brain;
+    if (!brainConfig?.seeds?.length) {
+        console.log(`${icon.info} No brain seeds configured in ${opts.file}.`);
+        console.log(`  Add spec.brain.seeds to your agent.yaml.`);
+        return;
+    }
+    const loader = new BrainSeedLoader(process.cwd(), {
+        seeds: brainConfig.seeds,
+        autoSeed: brainConfig.autoSeed !== false,
+    });
+    if (opts.status) {
+        const seeded = await loader.isSeeded();
+        console.log(`\n  Brain seed status: ${seeded ? color.green('seeded ✔') : color.yellow('not seeded')}`);
+        console.log(`  Seeds configured: ${brainConfig.seeds.map((s) => color.cyan(s)).join(', ')}\n`);
+        return;
+    }
+    if (opts.reset) {
+        const markerPath = path.resolve(process.cwd(), '.brain-seeded');
+        if (fs.existsSync(markerPath)) {
+            fs.unlinkSync(markerPath);
+            console.log(`  ${icon.success} Cleared seed marker.`);
+        }
+    }
+    if (await loader.isSeeded() && !opts.reset) {
+        console.log(`${icon.info} Brain already seeded. Use --reset to re-import.`);
+        return;
+    }
+    console.log(`\n${icon.gear} Importing brain seeds...\n`);
+    // Use a simple mock brain that logs imports (real usage would connect to DeepBrain)
+    const pages = [];
+    const mockBrain = {
+        learn: async (content, meta) => { pages.push(meta?.slug || 'unknown'); },
+    };
+    const result = await loader.seedBrain(mockBrain);
+    await loader.markSeeded();
+    console.log(`  ${icon.success} Imported ${color.bold(String(result.imported))} pages from ${brainConfig.seeds.length} seed files.`);
+    for (const p of result.pages) {
+        console.log(`    ${color.dim('•')} ${p}`);
+    }
+    console.log();
+});
+brainCmd
+    .command('evolve')
+    .description('Trigger manual knowledge evolution cycle')
+    .option('--dry-run', 'Show what would be promoted without doing it')
+    .action(async (opts) => {
+    const { KnowledgeEvolver } = require('./memory/seed-loader');
+    const evolver = new KnowledgeEvolver();
+    console.log(`\n${icon.gear} ${color.bold('Knowledge Evolution')}\n`);
+    console.log(`  ${icon.info} Checking for promotion candidates...`);
+    // Would connect to real brain in production
+    const result = await evolver.checkPromotion(null);
+    if (result.candidates.length === 0) {
+        console.log(`  ${icon.info} No knowledge ready for promotion yet.\n`);
+    }
+    else {
+        for (const c of result.candidates) {
+            console.log(`  ${color.cyan(c.slug)} → ${c.fromTier} → ${c.toTier} (confidence: ${(c.confidence * 100).toFixed(0)}%)`);
+        }
+        if (opts.dryRun) {
+            console.log(`\n  ${icon.info} Dry run — no changes made.\n`);
+        }
+        else {
+            console.log(`\n  ${icon.success} Promoted ${result.promoted} knowledge entries.\n`);
+        }
+    }
+});
 // ── Logs command ─────────────────────────────────────────────
 program
     .command('logs')
@@ -1866,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");
@@ -2142,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

@@ -6,6 +6,8 @@ import type { MCPTool } from '../tools/mcp';
 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;
@@ -23,6 +25,9 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
     private longTermMemory?;
     private longTermMemoryConfig;
     private tracer?;
+    private brainSeedConfig?;
+    private agentDir;
+    private guardrails?;
     constructor(options: {
         name: string;
         systemPrompt?: string;
@@ -38,11 +43,15 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
         };
         maxToolRounds?: number;
         tracer?: Tracer;
+        agentDir?: string;
+        brainSeedConfig?: BrainSeedConfig;
     });
     setLongTermMemory(brain: any, config?: {
         autoLearn?: boolean;
         autoRecall?: boolean;
     }): void;
+    setGuardrails(config: GuardrailConfig): void;
+    getGuardrails(): GuardrailManager | undefined;
     getLongTermMemory(): any;
     getLongTermMemoryConfig(): {
         autoLearn: boolean;

package/dist/core/agent.js

@@ -7,6 +7,8 @@ const providers_1 = require("../providers");
 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';
@@ -24,6 +26,9 @@ class BaseAgent extends events_1.EventEmitter {
     longTermMemory;
     longTermMemoryConfig = { autoLearn: true, autoRecall: true };
     tracer;
+    brainSeedConfig;
+    agentDir;
+    guardrails;
     constructor(options) {
         super();
         this.name = options.name;
@@ -41,6 +46,8 @@ class BaseAgent extends events_1.EventEmitter {
             this.skillLearner = new auto_learn_1.SkillLearner(options.skillsDir);
         }
         this.tracer = options.tracer;
+        this.agentDir = options.agentDir ?? process.cwd();
+        this.brainSeedConfig = options.brainSeedConfig;
     }
     setLongTermMemory(brain, config) {
         this.longTermMemory = brain;
@@ -51,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;
     }
@@ -93,6 +106,15 @@ class BaseAgent extends events_1.EventEmitter {
         if (this.skillLearner) {
             await this.skillLearner.loadLearnedSkills();
         }
+        // Auto-seed brain if configured
+        if (this.brainSeedConfig?.autoSeed && this.longTermMemory) {
+            const loader = new seed_loader_1.BrainSeedLoader(this.agentDir, this.brainSeedConfig);
+            if (!await loader.isSeeded()) {
+                const result = await loader.seedBrain(this.longTermMemory);
+                this.emit('brain:seeded', result);
+                await loader.markSeeded();
+            }
+        }
         this.transition('ready');
     }
     async start() {
@@ -149,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) {
@@ -264,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