opc-agent 0.3.0 → 0.5.0

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/deploy/openclaw.d.ts

@@ -0,0 +1,14 @@
+import type { OADDocument } from '../schema/oad';
+export interface DeployOptions {
+    oad: OADDocument;
+    outputDir: string;
+    install?: boolean;
+}
+export interface DeployResult {
+    outputDir: string;
+    files: string[];
+    installed: boolean;
+    configPath?: string;
+}
+export declare function deployToOpenClaw(options: DeployOptions): DeployResult;
+//# sourceMappingURL=openclaw.d.ts.map

package/dist/deploy/openclaw.js

@@ -0,0 +1,208 @@
+"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.deployToOpenClaw = deployToOpenClaw;
+/**
+ * OpenClaw Deployer - Convert OAD → OpenClaw agent workspace
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function generateIdentityMd(oad) {
+    const m = oad.metadata;
+    return `# IDENTITY.md
+
+- **Name:** ${m.name}
+- **Version:** ${m.version}
+- **Description:** ${m.description ?? 'An AI agent'}
+- **Author:** ${m.author ?? 'Unknown'}
+- **License:** ${m.license}
+`;
+}
+function generateSoulMd(oad) {
+    const prompt = oad.spec.systemPrompt ?? 'You are a helpful AI assistant.';
+    return `# SOUL.md - ${oad.metadata.name}
+
+## System Prompt
+
+${prompt}
+
+## Model Configuration
+
+- **Model:** ${oad.spec.model}
+- **Provider:** ${oad.spec.provider?.default ?? 'deepseek'}
+`;
+}
+function generateAgentsMd(oad) {
+    const skills = oad.spec.skills;
+    const memory = oad.spec.memory;
+    const dtv = oad.spec.dtv;
+    let md = `# AGENTS.md - ${oad.metadata.name}\n\n`;
+    // Skills
+    md += `## Skills\n\n`;
+    if (skills.length === 0) {
+        md += `No skills configured.\n\n`;
+    }
+    else {
+        for (const sk of skills) {
+            md += `### ${sk.name}\n`;
+            if (sk.description)
+                md += `${sk.description}\n`;
+            if (sk.config)
+                md += `\nConfig:\n\`\`\`json\n${JSON.stringify(sk.config, null, 2)}\n\`\`\`\n`;
+            md += `\n`;
+        }
+    }
+    // Memory
+    md += `## Memory\n\n`;
+    if (memory) {
+        md += `- Short-term: ${memory.shortTerm ? 'enabled' : 'disabled'}\n`;
+        const lt = memory.longTerm;
+        if (typeof lt === 'object' && lt) {
+            md += `- Long-term: ${lt.provider} (collection: ${lt.collection ?? 'default'})\n`;
+        }
+        else {
+            md += `- Long-term: ${lt ? 'enabled' : 'disabled'}\n`;
+        }
+    }
+    else {
+        md += `Default memory settings.\n`;
+    }
+    md += `\n`;
+    // DTV
+    if (dtv) {
+        md += `## Trust & Value\n\n`;
+        md += `- Trust Level: ${dtv.trust?.level ?? 'sandbox'}\n`;
+        if (dtv.value?.metrics?.length) {
+            md += `- Metrics: ${dtv.value.metrics.join(', ')}\n`;
+        }
+        md += `\n`;
+    }
+    return md;
+}
+function generateUserMd(oad) {
+    return `# USER.md
+
+- **Name:** (your name)
+- **Role:** User
+- **Notes:** Configure this file with your preferences for ${oad.metadata.name}.
+`;
+}
+function generateMemoryMd(oad) {
+    return `# MEMORY.md - ${oad.metadata.name}
+
+## Persistent Knowledge
+
+(Agent will store learned information here)
+
+## User Preferences
+
+(Discovered user preferences will be noted here)
+`;
+}
+function generateOpenClawConfig(oad, agentDir) {
+    const channels = oad.spec.channels;
+    const channelConfig = {};
+    for (const ch of channels) {
+        if (ch.type === 'telegram') {
+            channelConfig.telegram = {
+                enabled: true,
+                note: 'Configure bot token in OpenClaw gateway settings',
+            };
+        }
+        else if (ch.type === 'web' || ch.type === 'websocket') {
+            channelConfig.web = { enabled: true, port: ch.port ?? 3000 };
+        }
+    }
+    return {
+        name: oad.metadata.name,
+        workspace: agentDir,
+        channels: channelConfig,
+    };
+}
+function deployToOpenClaw(options) {
+    const { oad, outputDir, install } = options;
+    const files = [];
+    // Create output directory
+    fs.mkdirSync(outputDir, { recursive: true });
+    // Generate all workspace files
+    const fileMap = {
+        'IDENTITY.md': generateIdentityMd(oad),
+        'SOUL.md': generateSoulMd(oad),
+        'AGENTS.md': generateAgentsMd(oad),
+        'USER.md': generateUserMd(oad),
+        'MEMORY.md': generateMemoryMd(oad),
+    };
+    for (const [name, content] of Object.entries(fileMap)) {
+        const filePath = path.join(outputDir, name);
+        fs.writeFileSync(filePath, content, 'utf-8');
+        files.push(name);
+    }
+    // Generate suggested channel config
+    const channelSuggestion = generateOpenClawConfig(oad, outputDir);
+    const configNote = path.join(outputDir, 'openclaw-config-suggestion.json');
+    fs.writeFileSync(configNote, JSON.stringify(channelSuggestion, null, 2), 'utf-8');
+    files.push('openclaw-config-suggestion.json');
+    const result = { outputDir, files, installed: false };
+    // Install mode: register in openclaw.json
+    if (install) {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        const configPath = path.join(homeDir, '.openclaw', 'openclaw.json');
+        if (fs.existsSync(configPath)) {
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                if (!config.agents)
+                    config.agents = {};
+                const agentId = oad.metadata.name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+                config.agents[agentId] = {
+                    workspace: outputDir,
+                    description: oad.metadata.description ?? '',
+                };
+                fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+                result.installed = true;
+                result.configPath = configPath;
+            }
+            catch (err) {
+                // Config exists but couldn't be updated - not fatal
+                console.error(`Warning: Could not update ${configPath}:`, err);
+            }
+        }
+        else {
+            console.error(`Warning: OpenClaw config not found at ${configPath}`);
+            console.error(`Run 'openclaw init' first, then re-run with --install`);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=openclaw.js.map

package/dist/index.d.ts

@@ -26,6 +26,19 @@ 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';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addMessages = exports.detectLocale = exports.getLocale = exports.setLocale = exports.t = 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;
+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; } });
@@ -51,6 +51,23 @@ 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; } });