opc-agent 0.7.0 → 0.9.0

package/dist/core/analytics-engine.js

@@ -0,0 +1,186 @@
+"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.AnalyticsEngine = void 0;
+/**
+ * Analytics Engine - Persistent analytics with JSON file storage.
+ * Tracks every message, LLM call, tool use, and error with timestamps.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class AnalyticsEngine {
+    dataDir;
+    eventsFile;
+    events = [];
+    constructor(dataDir = '.') {
+        this.dataDir = path.resolve(dataDir, 'data');
+        this.eventsFile = path.join(this.dataDir, 'analytics.json');
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.eventsFile)) {
+                const raw = fs.readFileSync(this.eventsFile, 'utf-8');
+                this.events = JSON.parse(raw);
+            }
+        }
+        catch {
+            this.events = [];
+        }
+    }
+    save() {
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+        }
+        // Keep last 10000 events to prevent unbounded growth
+        if (this.events.length > 10000) {
+            this.events = this.events.slice(-10000);
+        }
+        fs.writeFileSync(this.eventsFile, JSON.stringify(this.events, null, 2));
+    }
+    track(type, data) {
+        this.events.push({ type, timestamp: Date.now(), data });
+        this.save();
+    }
+    trackMessage(userId, responseTimeMs, tokensIn, tokensOut) {
+        this.track('message', { userId, responseTimeMs, tokensIn, tokensOut });
+    }
+    trackLLMCall(provider, model, tokensIn, tokensOut, latencyMs) {
+        this.track('llm_call', { provider, model, tokensIn, tokensOut, latencyMs });
+    }
+    trackToolUse(toolName, success, latencyMs) {
+        this.track('tool_use', { toolName, success, latencyMs });
+    }
+    trackError(error, context) {
+        this.track('error', { error, context });
+    }
+    getStats(fromTs, toTs) {
+        const now = Date.now();
+        const from = fromTs ?? 0;
+        const to = toTs ?? now;
+        const filtered = this.events.filter(e => e.timestamp >= from && e.timestamp <= to);
+        const messages = filtered.filter(e => e.type === 'message');
+        const llmCalls = filtered.filter(e => e.type === 'llm_call');
+        const toolUses = filtered.filter(e => e.type === 'tool_use');
+        const errors = filtered.filter(e => e.type === 'error');
+        // Avg response time
+        const totalResponseTime = messages.reduce((sum, e) => sum + (e.data.responseTimeMs ?? 0), 0);
+        const avgResponseTimeMs = messages.length > 0 ? Math.round(totalResponseTime / messages.length) : 0;
+        // Total tokens
+        const totalTokensIn = llmCalls.reduce((sum, e) => sum + (e.data.tokensIn ?? 0), 0);
+        const totalTokensOut = llmCalls.reduce((sum, e) => sum + (e.data.tokensOut ?? 0), 0);
+        // Top skills (from tool_use)
+        const skillCounts = {};
+        for (const e of toolUses) {
+            const name = e.data.toolName ?? 'unknown';
+            skillCounts[name] = (skillCounts[name] ?? 0) + 1;
+        }
+        const topSkills = Object.entries(skillCounts)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([name, count]) => ({ name, count }));
+        // Top errors
+        const errorCounts = {};
+        for (const e of errors) {
+            const msg = e.data.error ?? 'unknown';
+            errorCounts[msg] = (errorCounts[msg] ?? 0) + 1;
+        }
+        const topErrors = Object.entries(errorCounts)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([message, count]) => ({ message, count }));
+        // Messages per day
+        const messagesPerDay = {};
+        for (const e of messages) {
+            const day = new Date(e.timestamp).toISOString().slice(0, 10);
+            messagesPerDay[day] = (messagesPerDay[day] ?? 0) + 1;
+        }
+        return {
+            totalMessages: messages.length,
+            totalLLMCalls: llmCalls.length,
+            totalToolUses: toolUses.length,
+            totalErrors: errors.length,
+            avgResponseTimeMs,
+            totalTokens: { input: totalTokensIn, output: totalTokensOut, total: totalTokensIn + totalTokensOut },
+            topSkills,
+            topErrors,
+            messagesPerDay,
+            period: { from, to },
+        };
+    }
+    getRecentEvents(limit = 50) {
+        return this.events.slice(-limit);
+    }
+    clear() {
+        this.events = [];
+        this.save();
+    }
+    /**
+     * Format stats for CLI display.
+     */
+    static formatStats(stats) {
+        const lines = [];
+        lines.push('');
+        lines.push('══════════════════════════════════════════');
+        lines.push('  OPC Agent Analytics');
+        lines.push('══════════════════════════════════════════');
+        lines.push('');
+        lines.push(`  📨 Messages:        ${stats.totalMessages}`);
+        lines.push(`  🤖 LLM Calls:       ${stats.totalLLMCalls}`);
+        lines.push(`  🔧 Tool Uses:        ${stats.totalToolUses}`);
+        lines.push(`  ❌ Errors:           ${stats.totalErrors}`);
+        lines.push(`  ⏱  Avg Response:     ${stats.avgResponseTimeMs}ms`);
+        lines.push(`  🪙 Tokens:           ${stats.totalTokens.total} (in: ${stats.totalTokens.input}, out: ${stats.totalTokens.output})`);
+        lines.push('');
+        if (stats.topSkills.length > 0) {
+            lines.push('  Top Skills:');
+            for (const s of stats.topSkills.slice(0, 5)) {
+                lines.push(`    • ${s.name}: ${s.count}`);
+            }
+            lines.push('');
+        }
+        if (stats.topErrors.length > 0) {
+            lines.push('  Top Errors:');
+            for (const e of stats.topErrors.slice(0, 3)) {
+                lines.push(`    • ${e.message}: ${e.count}`);
+            }
+            lines.push('');
+        }
+        lines.push('──────────────────────────────────────────');
+        return lines.join('\n');
+    }
+}
+exports.AnalyticsEngine = AnalyticsEngine;
+//# sourceMappingURL=analytics-engine.js.map

package/dist/core/cache.d.ts

@@ -0,0 +1,47 @@
+export interface CacheEntry {
+    key: string;
+    value: string;
+    createdAt: number;
+    ttlMs: number;
+    hits: number;
+}
+export interface CacheConfig {
+    enabled: boolean;
+    ttlMs: number;
+    maxEntries: number;
+    dataDir: string;
+}
+export declare class LLMCache {
+    private cache;
+    private config;
+    private filePath;
+    private stats;
+    constructor(config?: Partial<CacheConfig>);
+    private load;
+    private save;
+    private isExpired;
+    /**
+     * Generate a cache key from messages and system prompt.
+     */
+    static makeKey(messages: Array<{
+        role: string;
+        content: string;
+    }>, systemPrompt?: string): string;
+    /**
+     * Get a cached response. Returns null if not found or expired.
+     */
+    get(key: string): string | null;
+    /**
+     * Set a cached response.
+     */
+    set(key: string, value: string, ttlMs?: number): void;
+    getStats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+        size: number;
+        hitRate: string;
+    };
+    clear(): void;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/core/cache.js

@@ -0,0 +1,156 @@
+"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.LLMCache = void 0;
+/**
+ * Caching Layer - Cache LLM responses with configurable TTL.
+ * Hash-based key from input messages + system prompt.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+class LLMCache {
+    cache = new Map();
+    config;
+    filePath;
+    stats = { hits: 0, misses: 0, evictions: 0 };
+    constructor(config) {
+        this.config = {
+            enabled: config?.enabled ?? true,
+            ttlMs: config?.ttlMs ?? 3600_000, // 1 hour default
+            maxEntries: config?.maxEntries ?? 1000,
+            dataDir: config?.dataDir ?? '.',
+        };
+        this.filePath = path.join(this.config.dataDir, 'data', 'cache.json');
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const raw = fs.readFileSync(this.filePath, 'utf-8');
+                const entries = JSON.parse(raw);
+                for (const entry of entries) {
+                    if (!this.isExpired(entry)) {
+                        this.cache.set(entry.key, entry);
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    save() {
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const entries = Array.from(this.cache.values());
+        fs.writeFileSync(this.filePath, JSON.stringify(entries));
+    }
+    isExpired(entry) {
+        return Date.now() - entry.createdAt > entry.ttlMs;
+    }
+    /**
+     * Generate a cache key from messages and system prompt.
+     */
+    static makeKey(messages, systemPrompt) {
+        const payload = JSON.stringify({ systemPrompt, messages: messages.map(m => ({ role: m.role, content: m.content })) });
+        return crypto.createHash('sha256').update(payload).digest('hex').slice(0, 16);
+    }
+    /**
+     * Get a cached response. Returns null if not found or expired.
+     */
+    get(key) {
+        if (!this.config.enabled)
+            return null;
+        const entry = this.cache.get(key);
+        if (!entry || this.isExpired(entry)) {
+            if (entry) {
+                this.cache.delete(key);
+                this.stats.evictions++;
+            }
+            this.stats.misses++;
+            return null;
+        }
+        entry.hits++;
+        this.stats.hits++;
+        return entry.value;
+    }
+    /**
+     * Set a cached response.
+     */
+    set(key, value, ttlMs) {
+        if (!this.config.enabled)
+            return;
+        // Evict oldest if at capacity
+        if (this.cache.size >= this.config.maxEntries) {
+            let oldestKey = null;
+            let oldestTime = Infinity;
+            for (const [k, v] of this.cache) {
+                if (v.createdAt < oldestTime) {
+                    oldestTime = v.createdAt;
+                    oldestKey = k;
+                }
+            }
+            if (oldestKey) {
+                this.cache.delete(oldestKey);
+                this.stats.evictions++;
+            }
+        }
+        this.cache.set(key, {
+            key,
+            value,
+            createdAt: Date.now(),
+            ttlMs: ttlMs ?? this.config.ttlMs,
+            hits: 0,
+        });
+        this.save();
+    }
+    getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        return {
+            ...this.stats,
+            size: this.cache.size,
+            hitRate: total > 0 ? `${((this.stats.hits / total) * 100).toFixed(1)}%` : '0%',
+        };
+    }
+    clear() {
+        this.cache.clear();
+        this.stats = { hits: 0, misses: 0, evictions: 0 };
+        this.save();
+    }
+}
+exports.LLMCache = LLMCache;
+//# sourceMappingURL=cache.js.map

package/dist/core/compose.d.ts

@@ -0,0 +1,35 @@
+import type { AgentContext, Message } from './types';
+/**
+ * Agent Composition — v0.8.0
+ * Combine multiple agents into a pipeline: Agent A output → Agent B input.
+ * Configurable in OAD: `compose: [agent-a, agent-b]`
+ */
+export type AgentHandler = (context: AgentContext, message: Message) => Promise<Message>;
+export interface ComposableAgent {
+    id: string;
+    name: string;
+    handler: AgentHandler;
+}
+export interface ComposeOptions {
+    /** Stop pipeline if any agent returns empty content */
+    stopOnEmpty?: boolean;
+    /** Transform output between agents */
+    transform?: (output: Message, nextAgentId: string) => Message;
+    /** Timeout per agent in ms */
+    timeoutMs?: number;
+}
+export declare class AgentPipeline {
+    private agents;
+    private options;
+    constructor(agents: ComposableAgent[], options?: ComposeOptions);
+    /** Run the pipeline sequentially: each agent's output becomes the next agent's input */
+    execute(context: AgentContext, initialMessage: Message): Promise<Message>;
+    /** Get the pipeline agent IDs in order */
+    getAgentIds(): string[];
+}
+/**
+ * Create a pipeline from an array of composable agents.
+ * Usage in OAD: `compose: [agent-a, agent-b, agent-c]`
+ */
+export declare function compose(agents: ComposableAgent[], options?: ComposeOptions): AgentPipeline;
+//# sourceMappingURL=compose.d.ts.map

package/dist/core/compose.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentPipeline = void 0;
+exports.compose = compose;
+class AgentPipeline {
+    agents = [];
+    options;
+    constructor(agents, options = {}) {
+        this.agents = agents;
+        this.options = options;
+    }
+    /** Run the pipeline sequentially: each agent's output becomes the next agent's input */
+    async execute(context, initialMessage) {
+        let currentMessage = initialMessage;
+        for (const agent of this.agents) {
+            if (this.options.stopOnEmpty && !currentMessage.content.trim()) {
+                break;
+            }
+            // Apply transform if provided
+            if (this.options.transform) {
+                currentMessage = this.options.transform(currentMessage, agent.id);
+            }
+            if (this.options.timeoutMs) {
+                const result = await Promise.race([
+                    agent.handler(context, currentMessage),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Agent ${agent.id} timed out`)), this.options.timeoutMs)),
+                ]);
+                currentMessage = result;
+            }
+            else {
+                currentMessage = await agent.handler(context, currentMessage);
+            }
+        }
+        return currentMessage;
+    }
+    /** Get the pipeline agent IDs in order */
+    getAgentIds() {
+        return this.agents.map((a) => a.id);
+    }
+}
+exports.AgentPipeline = AgentPipeline;
+/**
+ * Create a pipeline from an array of composable agents.
+ * Usage in OAD: `compose: [agent-a, agent-b, agent-c]`
+ */
+function compose(agents, options) {
+    return new AgentPipeline(agents, options);
+}
+//# sourceMappingURL=compose.js.map

package/dist/core/orchestrator.d.ts

@@ -0,0 +1,68 @@
+import { EventEmitter } from 'events';
+import type { AgentContext, Message } from './types';
+/**
+ * Multi-Agent Orchestrator — v0.8.0
+ * Routes messages to specialized sub-agents, supports parallel execution and handoffs.
+ */
+export interface AgentNode {
+    id: string;
+    name: string;
+    description: string;
+    /** Patterns or intents this agent handles */
+    routes: string[];
+    /** Function that processes a message and returns a response */
+    handler: (context: AgentContext, message: Message) => Promise<Message>;
+    /** Priority for routing conflicts (higher wins) */
+    priority?: number;
+}
+export interface OrchestratorWorkflow {
+    name: string;
+    description?: string;
+    /** Ordered list of agent IDs for sequential execution */
+    steps?: string[];
+    /** List of agent IDs for parallel execution */
+    parallel?: string[];
+    /** Router config: auto-route based on message content */
+    router?: {
+        agents: string[];
+        fallback?: string;
+    };
+}
+export interface HandoffRequest {
+    fromAgent: string;
+    toAgent: string;
+    context: AgentContext;
+    reason: string;
+}
+export interface OrchestratorConfig {
+    agents: AgentNode[];
+    workflows?: OrchestratorWorkflow[];
+    defaultWorkflow?: string;
+    maxParallel?: number;
+}
+export declare class Orchestrator extends EventEmitter {
+    private agents;
+    private workflows;
+    private defaultWorkflow?;
+    private maxParallel;
+    constructor(config: OrchestratorConfig);
+    /** Register a new agent node */
+    registerAgent(agent: AgentNode): void;
+    /** Unregister an agent */
+    unregisterAgent(id: string): void;
+    /** Route a message to the best-matching agent */
+    route(message: Message): AgentNode | undefined;
+    /** Execute a single agent */
+    executeAgent(agentId: string, context: AgentContext, message: Message): Promise<Message>;
+    /** Run multiple agents in parallel */
+    executeParallel(agentIds: string[], context: AgentContext, message: Message): Promise<Map<string, Message>>;
+    /** Execute a named workflow */
+    executeWorkflow(workflowName: string, context: AgentContext, message: Message): Promise<Message[]>;
+    /** Hand off conversation from one agent to another */
+    handoff(request: HandoffRequest): Promise<Message>;
+    /** Process an incoming message using the default workflow or routing */
+    process(context: AgentContext, message: Message): Promise<Message[]>;
+    getAgents(): AgentNode[];
+    getWorkflows(): OrchestratorWorkflow[];
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/core/orchestrator.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orchestrator = void 0;
+const events_1 = require("events");
+class Orchestrator extends events_1.EventEmitter {
+    agents = new Map();
+    workflows = new Map();
+    defaultWorkflow;
+    maxParallel;
+    constructor(config) {
+        super();
+        this.maxParallel = config.maxParallel ?? 5;
+        this.defaultWorkflow = config.defaultWorkflow;
+        for (const agent of config.agents) {
+            this.agents.set(agent.id, agent);
+        }
+        for (const wf of config.workflows ?? []) {
+            this.workflows.set(wf.name, wf);
+        }
+    }
+    /** Register a new agent node */
+    registerAgent(agent) {
+        this.agents.set(agent.id, agent);
+        this.emit('agent:registered', agent.id);
+    }
+    /** Unregister an agent */
+    unregisterAgent(id) {
+        this.agents.delete(id);
+        this.emit('agent:unregistered', id);
+    }
+    /** Route a message to the best-matching agent */
+    route(message) {
+        const content = message.content.toLowerCase();
+        let bestMatch;
+        let bestPriority = -1;
+        for (const agent of this.agents.values()) {
+            for (const route of agent.routes) {
+                if (content.includes(route.toLowerCase()) || new RegExp(route, 'i').test(content)) {
+                    const priority = agent.priority ?? 0;
+                    if (priority > bestPriority) {
+                        bestMatch = agent;
+                        bestPriority = priority;
+                    }
+                    break;
+                }
+            }
+        }
+        return bestMatch;
+    }
+    /** Execute a single agent */
+    async executeAgent(agentId, context, message) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            throw new Error(`Agent not found: ${agentId}`);
+        this.emit('agent:execute', agentId, message);
+        const result = await agent.handler(context, message);
+        this.emit('agent:complete', agentId, result);
+        return result;
+    }
+    /** Run multiple agents in parallel */
+    async executeParallel(agentIds, context, message) {
+        const results = new Map();
+        const batches = [];
+        // Batch by maxParallel
+        for (let i = 0; i < agentIds.length; i += this.maxParallel) {
+            batches.push(agentIds.slice(i, i + this.maxParallel));
+        }
+        for (const batch of batches) {
+            const promises = batch.map(async (id) => {
+                const result = await this.executeAgent(id, context, message);
+                results.set(id, result);
+            });
+            await Promise.all(promises);
+        }
+        return results;
+    }
+    /** Execute a named workflow */
+    async executeWorkflow(workflowName, context, message) {
+        const wf = this.workflows.get(workflowName);
+        if (!wf)
+            throw new Error(`Workflow not found: ${workflowName}`);
+        const results = [];
+        // Sequential steps
+        if (wf.steps) {
+            let currentMessage = message;
+            for (const agentId of wf.steps) {
+                const result = await this.executeAgent(agentId, context, currentMessage);
+                results.push(result);
+                currentMessage = result; // chain output → next input
+            }
+        }
+        // Parallel execution
+        if (wf.parallel) {
+            const parallelResults = await this.executeParallel(wf.parallel, context, message);
+            results.push(...parallelResults.values());
+        }
+        // Router-based
+        if (wf.router) {
+            const matched = this.route(message);
+            const targetId = matched && wf.router.agents.includes(matched.id)
+                ? matched.id
+                : wf.router.fallback;
+            if (targetId) {
+                const result = await this.executeAgent(targetId, context, message);
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    /** Hand off conversation from one agent to another */
+    async handoff(request) {
+        this.emit('agent:handoff', request);
+        const { toAgent, context } = request;
+        const lastMessage = context.messages[context.messages.length - 1];
+        if (!lastMessage)
+            throw new Error('No message in context for handoff');
+        return this.executeAgent(toAgent, context, lastMessage);
+    }
+    /** Process an incoming message using the default workflow or routing */
+    async process(context, message) {
+        if (this.defaultWorkflow) {
+            return this.executeWorkflow(this.defaultWorkflow, context, message);
+        }
+        // Fallback: route to single agent
+        const agent = this.route(message);
+        if (agent) {
+            const result = await this.executeAgent(agent.id, context, message);
+            return [result];
+        }
+        return [{
+                id: `orch-${Date.now()}`,
+                role: 'assistant',
+                content: 'No agent available to handle this request.',
+                timestamp: Date.now(),
+            }];
+    }
+    getAgents() {
+        return Array.from(this.agents.values());
+    }
+    getWorkflows() {
+        return Array.from(this.workflows.values());
+    }
+}
+exports.Orchestrator = Orchestrator;
+//# sourceMappingURL=orchestrator.js.map