opc-agent 0.2.0 → 0.4.0

package/dist/core/sandbox.js

@@ -0,0 +1,118 @@
+"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.Sandbox = void 0;
+const path = __importStar(require("path"));
+const TRUST_RESTRICTIONS = {
+    sandbox: {
+        fileSystem: { read: ['.'], write: ['.'] },
+        network: { allowed: [] },
+        shell: false,
+    },
+    verified: {
+        fileSystem: { read: ['.', '..'], write: ['.'] },
+        network: { allowed: ['*.deepleaper.com', 'api.openai.com', 'api.deepseek.com'] },
+        shell: false,
+    },
+    certified: {
+        fileSystem: { read: ['*'], write: ['.', '..'] },
+        network: { allowed: ['*'] },
+        shell: true,
+    },
+    listed: {
+        fileSystem: { read: ['*'], write: ['*'] },
+        network: { allowed: ['*'] },
+        shell: true,
+    },
+};
+class Sandbox {
+    config;
+    restrictions;
+    constructor(config) {
+        this.config = config;
+        this.restrictions = {
+            ...TRUST_RESTRICTIONS[config.trustLevel] ?? TRUST_RESTRICTIONS.sandbox,
+        };
+        if (config.networkAllowlist) {
+            this.restrictions.network.allowed = config.networkAllowlist;
+        }
+        if (config.shellAllowed !== undefined) {
+            this.restrictions.shell = config.shellAllowed;
+        }
+    }
+    get trustLevel() {
+        return this.config.trustLevel;
+    }
+    getRestrictions() {
+        return { ...this.restrictions };
+    }
+    checkFileAccess(filePath, mode) {
+        const resolved = path.resolve(filePath);
+        const agentDir = path.resolve(this.config.agentDir);
+        const allowedPaths = mode === 'read' ? this.restrictions.fileSystem.read : this.restrictions.fileSystem.write;
+        if (allowedPaths.includes('*'))
+            return true;
+        for (const allowed of allowedPaths) {
+            const allowedResolved = path.resolve(this.config.agentDir, allowed);
+            if (resolved.startsWith(allowedResolved))
+                return true;
+        }
+        // Always allow access within agent's own directory
+        return resolved.startsWith(agentDir);
+    }
+    checkNetworkAccess(url) {
+        if (this.restrictions.network.allowed.includes('*'))
+            return true;
+        if (this.restrictions.network.allowed.length === 0)
+            return false;
+        try {
+            const hostname = new URL(url).hostname;
+            return this.restrictions.network.allowed.some((pattern) => {
+                if (pattern.startsWith('*.')) {
+                    return hostname.endsWith(pattern.slice(1));
+                }
+                return hostname === pattern;
+            });
+        }
+        catch {
+            return false;
+        }
+    }
+    checkShellAccess() {
+        return this.restrictions.shell;
+    }
+}
+exports.Sandbox = Sandbox;
+//# sourceMappingURL=sandbox.js.map

package/dist/core/versioning.d.ts

@@ -0,0 +1,29 @@
+export interface VersionEntry {
+    version: string;
+    timestamp: number;
+    description?: string;
+    oadSnapshot: string;
+}
+export interface Migration {
+    fromVersion: string;
+    toVersion: string;
+    migrate: (oad: Record<string, unknown>) => Record<string, unknown>;
+}
+export declare class VersionManager {
+    private versions;
+    private migrations;
+    private storePath;
+    private logger;
+    constructor(storePath?: string);
+    private load;
+    private save;
+    snapshot(version: string, oadYaml: string, description?: string): void;
+    list(): VersionEntry[];
+    get(version: string): VersionEntry | undefined;
+    getCurrent(): VersionEntry | undefined;
+    rollback(version: string): string | null;
+    registerMigration(migration: Migration): void;
+    migrate(oad: Record<string, unknown>, fromVersion: string, toVersion: string): Record<string, unknown>;
+    clear(): void;
+}
+//# sourceMappingURL=versioning.d.ts.map

package/dist/core/versioning.js

@@ -0,0 +1,114 @@
+"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.VersionManager = void 0;
+const fs = __importStar(require("fs"));
+const logger_1 = require("./logger");
+// ── Version Manager ─────────────────────────────────────────
+class VersionManager {
+    versions = [];
+    migrations = [];
+    storePath;
+    logger = new logger_1.Logger('versioning');
+    constructor(storePath) {
+        this.storePath = storePath ?? '.opc-versions.json';
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.storePath)) {
+                const data = JSON.parse(fs.readFileSync(this.storePath, 'utf-8'));
+                this.versions = data.versions ?? [];
+            }
+        }
+        catch {
+            this.versions = [];
+        }
+    }
+    save() {
+        fs.writeFileSync(this.storePath, JSON.stringify({ versions: this.versions }, null, 2));
+    }
+    snapshot(version, oadYaml, description) {
+        this.versions.push({
+            version,
+            timestamp: Date.now(),
+            description,
+            oadSnapshot: oadYaml,
+        });
+        this.save();
+        this.logger.info('Version snapshot saved', { version });
+    }
+    list() {
+        return [...this.versions];
+    }
+    get(version) {
+        return this.versions.find(v => v.version === version);
+    }
+    getCurrent() {
+        return this.versions[this.versions.length - 1];
+    }
+    rollback(version) {
+        const entry = this.get(version);
+        if (!entry) {
+            this.logger.warn('Version not found', { version });
+            return null;
+        }
+        this.logger.info('Rolling back to version', { version });
+        return entry.oadSnapshot;
+    }
+    registerMigration(migration) {
+        this.migrations.push(migration);
+    }
+    migrate(oad, fromVersion, toVersion) {
+        let current = fromVersion;
+        let result = { ...oad };
+        while (current !== toVersion) {
+            const migration = this.migrations.find(m => m.fromVersion === current);
+            if (!migration) {
+                throw new Error(`No migration path from ${current} to ${toVersion}`);
+            }
+            result = migration.migrate(result);
+            current = migration.toVersion;
+            this.logger.info('Migration applied', { from: migration.fromVersion, to: migration.toVersion });
+        }
+        return result;
+    }
+    clear() {
+        this.versions = [];
+        this.save();
+    }
+}
+exports.VersionManager = VersionManager;
+//# sourceMappingURL=versioning.js.map

package/dist/core/workflow.d.ts

@@ -0,0 +1,59 @@
+import { EventEmitter } from 'events';
+import type { AgentContext, ISkill, IAgent } from './types';
+export type StepType = 'skill' | 'tool' | 'agent' | 'condition' | 'parallel';
+export interface WorkflowStep {
+    id: string;
+    type: StepType;
+    name: string;
+    config?: Record<string, unknown>;
+    /** For condition steps */
+    condition?: string;
+    branches?: {
+        if: WorkflowStep[];
+        else?: WorkflowStep[];
+    };
+    /** For parallel steps */
+    parallel?: WorkflowStep[];
+    /** Timeout in ms */
+    timeout?: number;
+    /** Retry count */
+    retries?: number;
+}
+export interface WorkflowDefinition {
+    name: string;
+    description?: string;
+    version?: string;
+    steps: WorkflowStep[];
+    onError?: 'stop' | 'skip' | 'retry';
+}
+export interface StepResult {
+    stepId: string;
+    status: 'success' | 'skipped' | 'error';
+    output?: string;
+    error?: string;
+    durationMs: number;
+}
+export interface WorkflowResult {
+    workflow: string;
+    status: 'completed' | 'failed' | 'partial';
+    steps: StepResult[];
+    totalDurationMs: number;
+}
+export declare class WorkflowEngine extends EventEmitter {
+    private workflows;
+    private skills;
+    private agents;
+    private logger;
+    registerWorkflow(workflow: WorkflowDefinition): void;
+    unregisterWorkflow(name: string): void;
+    getWorkflow(name: string): WorkflowDefinition | undefined;
+    listWorkflows(): WorkflowDefinition[];
+    registerSkill(skill: ISkill): void;
+    registerAgent(agent: IAgent): void;
+    run(name: string, context: AgentContext, input?: string): Promise<WorkflowResult>;
+    private executeSteps;
+    private executeSingleStep;
+    private executeStepAction;
+    private evaluateCondition;
+}
+//# sourceMappingURL=workflow.d.ts.map

package/dist/core/workflow.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowEngine = void 0;
+const events_1 = require("events");
+const logger_1 = require("./logger");
+// ── Workflow Engine ─────────────────────────────────────────
+class WorkflowEngine extends events_1.EventEmitter {
+    workflows = new Map();
+    skills = new Map();
+    agents = new Map();
+    logger = new logger_1.Logger('workflow');
+    registerWorkflow(workflow) {
+        this.workflows.set(workflow.name, workflow);
+        this.logger.info('Workflow registered', { name: workflow.name, steps: workflow.steps.length });
+    }
+    unregisterWorkflow(name) {
+        this.workflows.delete(name);
+    }
+    getWorkflow(name) {
+        return this.workflows.get(name);
+    }
+    listWorkflows() {
+        return Array.from(this.workflows.values());
+    }
+    registerSkill(skill) {
+        this.skills.set(skill.name, skill);
+    }
+    registerAgent(agent) {
+        this.agents.set(agent.name, agent);
+    }
+    async run(name, context, input) {
+        const workflow = this.workflows.get(name);
+        if (!workflow)
+            throw new Error(`Workflow "${name}" not found`);
+        const startTime = Date.now();
+        const results = [];
+        let failed = false;
+        this.emit('workflow:start', { name, input });
+        try {
+            await this.executeSteps(workflow.steps, context, input ?? '', results, workflow.onError ?? 'stop');
+        }
+        catch (err) {
+            failed = true;
+            this.logger.error('Workflow failed', { name, error: err.message });
+        }
+        const result = {
+            workflow: name,
+            status: failed ? 'failed' : results.some(r => r.status === 'error') ? 'partial' : 'completed',
+            steps: results,
+            totalDurationMs: Date.now() - startTime,
+        };
+        this.emit('workflow:end', result);
+        return result;
+    }
+    async executeSteps(steps, context, input, results, onError) {
+        let currentInput = input;
+        for (const step of steps) {
+            const stepStart = Date.now();
+            try {
+                if (step.type === 'parallel' && step.parallel) {
+                    const parallelResults = await Promise.all(step.parallel.map(s => this.executeSingleStep(s, context, currentInput)));
+                    const combined = parallelResults.map(r => r.output ?? '').join('\n');
+                    for (const r of parallelResults)
+                        results.push(r);
+                    currentInput = combined;
+                }
+                else if (step.type === 'condition' && step.branches) {
+                    const conditionMet = this.evaluateCondition(step.condition ?? '', currentInput, context);
+                    const branch = conditionMet ? step.branches.if : (step.branches.else ?? []);
+                    results.push({
+                        stepId: step.id,
+                        status: 'success',
+                        output: `condition=${conditionMet}`,
+                        durationMs: Date.now() - stepStart,
+                    });
+                    currentInput = await this.executeSteps(branch, context, currentInput, results, onError);
+                }
+                else {
+                    const result = await this.executeSingleStep(step, context, currentInput);
+                    results.push(result);
+                    if (result.status === 'success' && result.output) {
+                        currentInput = result.output;
+                    }
+                    if (result.status === 'error' && onError === 'stop') {
+                        throw new Error(`Step "${step.id}" failed: ${result.error}`);
+                    }
+                }
+            }
+            catch (err) {
+                if (onError === 'stop')
+                    throw err;
+                // skip: continue
+            }
+        }
+        return currentInput;
+    }
+    async executeSingleStep(step, context, input) {
+        const startTime = Date.now();
+        let retries = step.retries ?? 0;
+        while (true) {
+            try {
+                const output = await this.executeStepAction(step, context, input);
+                return {
+                    stepId: step.id,
+                    status: 'success',
+                    output,
+                    durationMs: Date.now() - startTime,
+                };
+            }
+            catch (err) {
+                if (retries > 0) {
+                    retries--;
+                    continue;
+                }
+                return {
+                    stepId: step.id,
+                    status: 'error',
+                    error: err.message,
+                    durationMs: Date.now() - startTime,
+                };
+            }
+        }
+    }
+    async executeStepAction(step, context, input) {
+        const message = {
+            id: `wf_${step.id}_${Date.now()}`,
+            role: 'user',
+            content: input,
+            timestamp: Date.now(),
+            metadata: { workflowStep: step.id },
+        };
+        switch (step.type) {
+            case 'skill': {
+                const skill = this.skills.get(step.name);
+                if (!skill)
+                    throw new Error(`Skill "${step.name}" not found`);
+                const result = await skill.execute(context, message);
+                return result.response ?? '';
+            }
+            case 'agent': {
+                const agent = this.agents.get(step.name);
+                if (!agent)
+                    throw new Error(`Agent "${step.name}" not found`);
+                const response = await agent.handleMessage(message);
+                return response.content;
+            }
+            case 'tool': {
+                // Tools are executed via config callback
+                const toolFn = step.config?.handler;
+                if (toolFn)
+                    return await toolFn(input);
+                return `[tool:${step.name}] executed`;
+            }
+            default:
+                return input;
+        }
+    }
+    evaluateCondition(condition, input, _context) {
+        // Simple condition evaluator: supports "contains:keyword", "length>N", "true", "false"
+        if (condition === 'true')
+            return true;
+        if (condition === 'false')
+            return false;
+        if (condition.startsWith('contains:')) {
+            return input.toLowerCase().includes(condition.slice(9).toLowerCase());
+        }
+        if (condition.startsWith('length>')) {
+            return input.length > parseInt(condition.slice(7), 10);
+        }
+        return !!condition;
+    }
+}
+exports.WorkflowEngine = WorkflowEngine;
+//# sourceMappingURL=workflow.js.map

package/dist/i18n/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Internationalization (i18n) support for OPC Agent.
+ */
+export type Locale = 'en' | 'zh-CN';
+export interface I18nMessages {
+    [key: string]: string;
+}
+export declare function setLocale(locale: Locale): void;
+export declare function getLocale(): Locale;
+export declare function t(key: string, params?: Record<string, string>): string;
+export declare function detectLocale(): Locale;
+export declare function addMessages(locale: Locale, newMessages: I18nMessages): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/i18n/index.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLocale = setLocale;
+exports.getLocale = getLocale;
+exports.t = t;
+exports.detectLocale = detectLocale;
+exports.addMessages = addMessages;
+const messages = {
+    'en': {
+        'agent.started': 'Agent "{name}" started successfully',
+        'agent.stopped': 'Agent "{name}" stopped',
+        'agent.error': 'An error occurred: {error}',
+        'agent.greeting': 'Hello! How can I help you?',
+        'agent.farewell': 'Goodbye! Have a great day.',
+        'agent.notUnderstood': 'I\'m not sure I understand. Could you rephrase?',
+        'agent.handoff': 'Let me connect you with a human agent.',
+        'cli.init.success': 'Created agent project: {name}',
+        'cli.build.success': 'Build successful: {name} v{version}',
+        'cli.test.pass': 'All tests passed',
+        'cli.stats.title': 'Agent Analytics',
+        'cli.stats.messages': 'Messages Processed',
+        'cli.stats.avgTime': 'Avg Response Time',
+        'cli.stats.errors': 'Errors',
+        'cli.stats.uptime': 'Uptime',
+        'plugin.loaded': 'Plugin "{name}" loaded',
+        'plugin.error': 'Plugin "{name}" failed: {error}',
+    },
+    'zh-CN': {
+        'agent.started': '智能体 "{name}" 启动成功',
+        'agent.stopped': '智能体 "{name}" 已停止',
+        'agent.error': '发生错误: {error}',
+        'agent.greeting': '您好！有什么可以帮您的？',
+        'agent.farewell': '再见！祝您愉快。',
+        'agent.notUnderstood': '抱歉，我没有理解您的意思。能换个方式描述吗？',
+        'agent.handoff': '我来为您转接人工客服。',
+        'cli.init.success': '已创建智能体项目: {name}',
+        'cli.build.success': '构建成功: {name} v{version}',
+        'cli.test.pass': '所有测试通过',
+        'cli.stats.title': '智能体分析',
+        'cli.stats.messages': '已处理消息',
+        'cli.stats.avgTime': '平均响应时间',
+        'cli.stats.errors': '错误数',
+        'cli.stats.uptime': '运行时间',
+        'plugin.loaded': '插件 "{name}" 已加载',
+        'plugin.error': '插件 "{name}" 失败: {error}',
+    },
+};
+let currentLocale = 'en';
+function setLocale(locale) {
+    currentLocale = locale;
+}
+function getLocale() {
+    return currentLocale;
+}
+function t(key, params) {
+    let msg = messages[currentLocale]?.[key] ?? messages['en']?.[key] ?? key;
+    if (params) {
+        for (const [k, v] of Object.entries(params)) {
+            msg = msg.replace(new RegExp(`\\{${k}\\}`, 'g'), v);
+        }
+    }
+    return msg;
+}
+function detectLocale() {
+    const env = process.env.LANG ?? process.env.LC_ALL ?? process.env.LANGUAGE ?? '';
+    if (env.startsWith('zh'))
+        return 'zh-CN';
+    return 'en';
+}
+function addMessages(locale, newMessages) {
+    messages[locale] = { ...messages[locale], ...newMessages };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -17,4 +17,29 @@ export { TrustManager } from './dtv/trust';
 export { ValueTracker } from './dtv/value';
 export { MRGConfigReader } from './dtv/data';
 export { createProvider, SUPPORTED_PROVIDERS } from './providers';
+export { Room } from './core/room';
+export type { RoomMessage } from './core/room';
+export { MCPToolRegistry, createMCPTool } from './tools/mcp';
+export type { MCPTool, MCPToolDefinition, MCPToolResult } from './tools/mcp';
+export { PluginManager } from './plugins';
+export type { IPlugin, PluginHooks } from './plugins';
+export { Sandbox } from './core/sandbox';
+export type { SandboxConfig, SandboxRestrictions } from './core/sandbox';
+export { Analytics } from './analytics';
+export { WorkflowEngine } from './core/workflow';
+export type { WorkflowDefinition, WorkflowStep, WorkflowResult, StepResult } from './core/workflow';
+export { AgentRegistry } from './core/a2a';
+export type { A2ARequest, A2AResponse, AgentCapability, AgentRegistration } from './core/a2a';
+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 { WebhookChannel } from './channels/webhook';
+export type { WebhookConfig, WebhookPayload } from './channels/webhook';
+export { VersionManager } from './core/versioning';
+export type { VersionEntry, Migration } from './core/versioning';
+export { ConnectionPool, RequestBatcher, LazyLoader } from './core/performance';
+export type { AnalyticsSnapshot } from './analytics';
+export { t, setLocale, getLocale, detectLocale, addMessages } from './i18n';
+export type { Locale } from './i18n';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.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;
 // OPC Agent — Open Agent Framework
 var agent_1 = require("./core/agent");
 Object.defineProperty(exports, "BaseAgent", { enumerable: true, get: function () { return agent_1.BaseAgent; } });
@@ -39,4 +39,39 @@ Object.defineProperty(exports, "MRGConfigReader", { enumerable: true, get: funct
 var providers_1 = require("./providers");
 Object.defineProperty(exports, "createProvider", { enumerable: true, get: function () { return providers_1.createProvider; } });
 Object.defineProperty(exports, "SUPPORTED_PROVIDERS", { enumerable: true, get: function () { return providers_1.SUPPORTED_PROVIDERS; } });
+// v0.3.0 new modules
+var room_1 = require("./core/room");
+Object.defineProperty(exports, "Room", { enumerable: true, get: function () { return room_1.Room; } });
+var mcp_1 = require("./tools/mcp");
+Object.defineProperty(exports, "MCPToolRegistry", { enumerable: true, get: function () { return mcp_1.MCPToolRegistry; } });
+Object.defineProperty(exports, "createMCPTool", { enumerable: true, get: function () { return mcp_1.createMCPTool; } });
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "PluginManager", { enumerable: true, get: function () { return plugins_1.PluginManager; } });
+var sandbox_1 = require("./core/sandbox");
+Object.defineProperty(exports, "Sandbox", { enumerable: true, get: function () { return sandbox_1.Sandbox; } });
+var analytics_1 = require("./analytics");
+Object.defineProperty(exports, "Analytics", { enumerable: true, get: function () { return analytics_1.Analytics; } });
+// v0.4.0 modules
+var workflow_1 = require("./core/workflow");
+Object.defineProperty(exports, "WorkflowEngine", { enumerable: true, get: function () { return workflow_1.WorkflowEngine; } });
+var a2a_1 = require("./core/a2a");
+Object.defineProperty(exports, "AgentRegistry", { enumerable: true, get: function () { return a2a_1.AgentRegistry; } });
+var hitl_1 = require("./core/hitl");
+Object.defineProperty(exports, "HITLManager", { enumerable: true, get: function () { return hitl_1.HITLManager; } });
+var voice_1 = require("./channels/voice");
+Object.defineProperty(exports, "VoiceChannel", { enumerable: true, get: function () { return voice_1.VoiceChannel; } });
+var webhook_1 = require("./channels/webhook");
+Object.defineProperty(exports, "WebhookChannel", { enumerable: true, get: function () { return webhook_1.WebhookChannel; } });
+var versioning_1 = require("./core/versioning");
+Object.defineProperty(exports, "VersionManager", { enumerable: true, get: function () { return versioning_1.VersionManager; } });
+var performance_1 = require("./core/performance");
+Object.defineProperty(exports, "ConnectionPool", { enumerable: true, get: function () { return performance_1.ConnectionPool; } });
+Object.defineProperty(exports, "RequestBatcher", { enumerable: true, get: function () { return performance_1.RequestBatcher; } });
+Object.defineProperty(exports, "LazyLoader", { enumerable: true, get: function () { return performance_1.LazyLoader; } });
+var i18n_1 = require("./i18n");
+Object.defineProperty(exports, "t", { enumerable: true, get: function () { return i18n_1.t; } });
+Object.defineProperty(exports, "setLocale", { enumerable: true, get: function () { return i18n_1.setLocale; } });
+Object.defineProperty(exports, "getLocale", { enumerable: true, get: function () { return i18n_1.getLocale; } });
+Object.defineProperty(exports, "detectLocale", { enumerable: true, get: function () { return i18n_1.detectLocale; } });
+Object.defineProperty(exports, "addMessages", { enumerable: true, get: function () { return i18n_1.addMessages; } });
 //# sourceMappingURL=index.js.map