opc-agent 2.1.0 → 3.0.1

package/dist/security/guardrails.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Guardrails Module - v2.1.0
+ * Input/output guardrails for LLM safety: PII, toxicity, injection, compliance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardrailManager = void 0;
+exports.createGuardrailsFromConfig = createGuardrailsFromConfig;
+// ── Built-in Patterns ───────────────────────────────────────
+const PII_PATTERNS = {
+    email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+    phone: /(\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g,
+    ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
+    creditCard: /\b(?:\d{4}[-\s]?){3}\d{4}\b/g,
+    ipAddress: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+};
+const INJECTION_PATTERNS = [
+    /ignore\s+(all\s+)?previous\s+instructions/i,
+    /ignore\s+(all\s+)?above\s+instructions/i,
+    /system\s*prompt\s*:/i,
+    /you\s+are\s+now\s+(?:a|an|the)\s+/i,
+    /act\s+as\s+(?:a|an)\s+/i,
+    /pretend\s+(?:you(?:'re|\s+are)\s+)?/i,
+    /new\s+instruction[s]?\s*:/i,
+    /override\s+(?:your\s+)?(?:instructions|rules|guidelines)/i,
+    /jailbreak/i,
+    /DAN\s+mode/i,
+];
+const TOXICITY_KEYWORDS = [
+    'kill yourself', 'kys', 'go die', 'hate you',
+    'stupid idiot', 'worthless', 'piece of shit',
+];
+const COMPLIANCE_PATTERNS = [
+    { pattern: /(?:you\s+should\s+)?(?:buy|sell|invest\s+in)\s+(?:stocks?|crypto|bitcoin)/i, label: 'financial advice' },
+    { pattern: /(?:you\s+(?:have|probably\s+have)|diagnos(?:e|is))\s+(?:\w+\s+){0,3}(?:disease|syndrome|disorder|cancer)/i, label: 'medical diagnosis' },
+    { pattern: /(?:legal(?:ly)?|sue|lawsuit|court)\s+(?:you\s+should|advice)/i, label: 'legal advice' },
+];
+// ── Rule Executors ──────────────────────────────────────────
+function checkPII(text, action) {
+    const violations = [];
+    let redacted = text;
+    for (const [type, pattern] of Object.entries(PII_PATTERNS)) {
+        const cloned = new RegExp(pattern.source, pattern.flags);
+        const matches = text.match(cloned);
+        if (matches) {
+            violations.push({ rule: 'pii-detector', action, detail: `Found ${type}: ${matches.length} match(es)` });
+            redacted = redacted.replace(cloned, '[REDACTED]');
+        }
+    }
+    return { violations, redactedText: redacted };
+}
+function checkInjection(text) {
+    const violations = [];
+    for (const pattern of INJECTION_PATTERNS) {
+        if (pattern.test(text)) {
+            violations.push({ rule: 'prompt-injection', action: 'block', detail: `Matched pattern: ${pattern.source}` });
+            break; // one is enough
+        }
+    }
+    return violations;
+}
+function checkToxicity(text, extraKeywords) {
+    const lower = text.toLowerCase();
+    const keywords = [...TOXICITY_KEYWORDS, ...(extraKeywords ?? [])];
+    for (const kw of keywords) {
+        if (lower.includes(kw.toLowerCase())) {
+            return [{ rule: 'toxicity', action: 'block', detail: `Matched keyword: "${kw}"` }];
+        }
+    }
+    return [];
+}
+function checkTopicRestriction(text, config) {
+    const denyTopics = config?.denyTopics ?? [];
+    const lower = text.toLowerCase();
+    for (const topic of denyTopics) {
+        if (lower.includes(topic.toLowerCase())) {
+            return [{ rule: 'topic-restrictor', action: 'block', detail: `Blocked topic: "${topic}"` }];
+        }
+    }
+    return [];
+}
+function checkLength(text, config) {
+    const maxChars = config?.maxChars ?? 10000;
+    if (text.length > maxChars) {
+        return [{ rule: 'length-limit', action: 'warn', detail: `Response length ${text.length} exceeds max ${maxChars}` }];
+    }
+    return [];
+}
+function checkLanguage(text, config) {
+    const allowed = config?.allowedLanguages ?? [];
+    if (allowed.length === 0)
+        return [];
+    // Simple heuristic: check if text contains CJK characters
+    const hasCJK = /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]/.test(text);
+    const hasLatin = /[a-zA-Z]{3,}/.test(text);
+    if (allowed.includes('en') && !allowed.includes('zh') && hasCJK && !hasLatin) {
+        return [{ rule: 'language-filter', action: 'block', detail: 'Non-allowed language detected' }];
+    }
+    if (allowed.includes('zh') && !allowed.includes('en') && hasLatin && !hasCJK) {
+        return [{ rule: 'language-filter', action: 'block', detail: 'Non-allowed language detected' }];
+    }
+    return [];
+}
+function checkCompliance(text) {
+    for (const { pattern, label } of COMPLIANCE_PATTERNS) {
+        if (pattern.test(text)) {
+            return [{ rule: 'compliance-filter', action: 'block', detail: `Potential ${label} detected` }];
+        }
+    }
+    return [];
+}
+// ── Guardrail Manager ───────────────────────────────────────
+class GuardrailManager {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async checkInput(message) {
+        return this.runRules(message, this.config.input ?? []);
+    }
+    async checkOutput(response) {
+        return this.runRules(response, this.config.output ?? []);
+    }
+    async runRules(text, rules) {
+        const allViolations = [];
+        let blocked = false;
+        let warned = false;
+        let redacted = false;
+        let redactedText = text;
+        let blockMessage = '';
+        for (const rule of rules) {
+            let violations = [];
+            switch (rule.name) {
+                case 'pii-detector': {
+                    const result = checkPII(text, rule.action);
+                    violations = result.violations;
+                    if (violations.length > 0 && rule.action === 'redact') {
+                        redacted = true;
+                        redactedText = result.redactedText;
+                    }
+                    break;
+                }
+                case 'prompt-injection':
+                    violations = checkInjection(text);
+                    break;
+                case 'toxicity':
+                    violations = checkToxicity(text, rule.config?.keywords);
+                    break;
+                case 'topic-restrictor':
+                    violations = checkTopicRestriction(text, rule.config);
+                    break;
+                case 'length-limit':
+                    violations = checkLength(text, rule.config);
+                    break;
+                case 'language-filter':
+                    violations = checkLanguage(text, rule.config);
+                    break;
+                case 'compliance-filter':
+                    violations = checkCompliance(text);
+                    break;
+                default:
+                    // Unknown rule — skip
+                    break;
+            }
+            if (violations.length > 0) {
+                // Override action from rule config
+                violations = violations.map(v => ({ ...v, action: rule.action }));
+                allViolations.push(...violations);
+                if (rule.action === 'block') {
+                    blocked = true;
+                    blockMessage = `Message blocked by ${rule.name}: ${violations[0].detail}`;
+                }
+                else if (rule.action === 'warn') {
+                    warned = true;
+                }
+            }
+        }
+        return {
+            passed: allViolations.length === 0,
+            blocked,
+            warned,
+            redacted,
+            message: blocked ? blockMessage : undefined,
+            redactedText: redacted ? redactedText : undefined,
+            violations: allViolations,
+        };
+    }
+}
+exports.GuardrailManager = GuardrailManager;
+// ── Factory from OAD config ─────────────────────────────────
+function createGuardrailsFromConfig(config) {
+    return new GuardrailManager({
+        input: config.input,
+        output: config.output,
+    });
+}
+//# sourceMappingURL=guardrails.js.map

package/dist/studio/server.d.ts

@@ -1,5 +1,28 @@
 import { IncomingMessage, ServerResponse } from 'http';
 import { Tracer } from '../telemetry';
+export interface WorkflowNode {
+    id: string;
+    type: 'agent' | 'tool' | 'condition' | 'loop' | 'parallel' | 'input' | 'output';
+    name: string;
+    x: number;
+    y: number;
+    config: Record<string, any>;
+}
+export interface WorkflowEdge {
+    id: string;
+    from: string;
+    to: string;
+    fromPort: string;
+    toPort: string;
+}
+export interface WorkflowDefinition {
+    id: string;
+    name: string;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    created: string;
+    updated: string;
+}
 interface StudioConfig {
     port: number;
     agentDir: string;
@@ -26,7 +49,13 @@ declare class StudioServer {
     private getMemoryStats;
     private getSkills;
     private getTools;
-    private getWorkflows;
+    private getWorkflowsDir;
+    private listWorkflows;
+    private getWorkflowById;
+    private saveWorkflow;
+    private deleteWorkflow;
+    private runWorkflow;
+    private topoSort;
     private getJobs;
     private getRecentLogs;
     private getAnalytics;
@@ -57,6 +86,7 @@ declare class StudioServer {
     private loadOAD;
     private loadPackageJson;
     serveStatic(req: IncomingMessage, res: ServerResponse, url: URL): void;
+    private handlePlaygroundChat;
     private readBody;
 }
 export { StudioServer, StudioConfig };

package/dist/studio/server.js

@@ -107,6 +107,28 @@ class StudioServer {
         const route = url.pathname.replace('/api/', '');
         try {
             let data;
+            // Dynamic workflow routes (parameterized)
+            if (route.match(/^workflows\/[^/]+\/run$/) && req.method === 'POST') {
+                const wfId = route.split('/')[1];
+                data = await this.runWorkflow(wfId);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^workflows\/[^/]+$/) && req.method === 'GET') {
+                const wfId = route.split('/')[1];
+                data = this.getWorkflowById(wfId);
+                res.writeHead(data.error ? 404 : 200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^workflows\/[^/]+$/) && req.method === 'DELETE') {
+                const wfId = route.split('/')[1];
+                data = this.deleteWorkflow(wfId);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
             switch (route) {
                 case 'modules':
                     data = await this.getModulesStatus();
@@ -139,7 +161,18 @@ class StudioServer {
                     data = await this.getTools();
                     break;
                 case 'workflows/list':
-                    data = await this.getWorkflows();
+                    data = this.listWorkflows();
+                    break;
+                case 'workflows':
+                    if (req.method === 'POST')
+                        data = await this.saveWorkflow(req);
+                    else if (req.method === 'GET')
+                        data = this.listWorkflows();
+                    else {
+                        res.writeHead(405);
+                        res.end();
+                        return;
+                    }
                     break;
                 case 'jobs/list':
                     data = await this.getJobs();
@@ -207,6 +240,16 @@ class StudioServer {
                 case 'telemetry/metrics':
                     data = this.tracer ? this.tracer.getMetrics() : [];
                     break;
+                case 'playground/chat':
+                    if (req.method === 'POST') {
+                        return this.handlePlaygroundChat(req, res);
+                    }
+                    res.writeHead(405);
+                    res.end();
+                    return;
+                case 'playground/models':
+                    data = { models: ['gpt-4o', 'gpt-4o-mini', 'claude-sonnet-4', 'claude-haiku', 'gemini-2.0-flash', 'deepseek-v3'] };
+                    break;
                 default:
                     res.writeHead(404, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ error: 'Not found' }));
@@ -347,9 +390,96 @@ class StudioServer {
             return { tools: [] };
         }
     }
-    async getWorkflows() {
+    getWorkflowsDir() {
+        const dir = (0, path_1.join)(this.config.agentDir, '.opc', 'workflows');
+        if (!(0, fs_1.existsSync)(dir))
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        return dir;
+    }
+    listWorkflows() {
+        const dir = this.getWorkflowsDir();
+        const files = require('fs').readdirSync(dir).filter((f) => f.endsWith('.json'));
+        const workflows = files.map((f) => {
+            try {
+                return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(dir, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean);
+        // Also include OAD-defined workflows
         const oad = this.loadOAD();
-        return { workflows: oad?.spec?.workflows || [] };
+        const oadWorkflows = (oad?.spec?.workflows || []).map((w, i) => ({
+            id: `oad-${i}`,
+            name: w.name || `Workflow ${i + 1}`,
+            nodes: [],
+            edges: [],
+            steps: w.steps,
+            source: 'oad',
+        }));
+        return { workflows: [...workflows, ...oadWorkflows] };
+    }
+    getWorkflowById(id) {
+        const filePath = (0, path_1.join)(this.getWorkflowsDir(), `${id}.json`);
+        if (!(0, fs_1.existsSync)(filePath))
+            return { error: 'Workflow not found' };
+        return JSON.parse((0, fs_1.readFileSync)(filePath, 'utf-8'));
+    }
+    async saveWorkflow(req) {
+        const body = await this.readBody(req);
+        const workflow = JSON.parse(body);
+        if (!workflow.id)
+            workflow.id = `wf-${Date.now()}`;
+        workflow.updated = new Date().toISOString();
+        if (!workflow.created)
+            workflow.created = workflow.updated;
+        const filePath = (0, path_1.join)(this.getWorkflowsDir(), `${workflow.id}.json`);
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(workflow, null, 2));
+        return { success: true, id: workflow.id };
+    }
+    deleteWorkflow(id) {
+        const filePath = (0, path_1.join)(this.getWorkflowsDir(), `${id}.json`);
+        if ((0, fs_1.existsSync)(filePath))
+            require('fs').unlinkSync(filePath);
+        return { success: true };
+    }
+    async runWorkflow(id) {
+        const wf = this.getWorkflowById(id);
+        if ('error' in wf)
+            return wf;
+        // Basic topological execution simulation
+        const results = {};
+        const sorted = this.topoSort(wf.nodes, wf.edges);
+        for (const node of sorted) {
+            results[node.id] = { type: node.type, name: node.name, status: 'completed', output: `[simulated output for ${node.name}]` };
+        }
+        return { workflowId: id, status: 'completed', results };
+    }
+    topoSort(nodes, edges) {
+        const nodeMap = new Map(nodes.map(n => [n.id, n]));
+        const inDegree = new Map();
+        const adj = new Map();
+        for (const n of nodes) {
+            inDegree.set(n.id, 0);
+            adj.set(n.id, []);
+        }
+        for (const e of edges) {
+            adj.get(e.from)?.push(e.to);
+            inDegree.set(e.to, (inDegree.get(e.to) || 0) + 1);
+        }
+        const queue = nodes.filter(n => (inDegree.get(n.id) || 0) === 0);
+        const result = [];
+        while (queue.length > 0) {
+            const node = queue.shift();
+            result.push(node);
+            for (const next of (adj.get(node.id) || [])) {
+                const d = (inDegree.get(next) || 1) - 1;
+                inDegree.set(next, d);
+                if (d === 0)
+                    queue.push(nodeMap.get(next));
+            }
+        }
+        return result;
     }
     async getJobs() {
         const oad = this.loadOAD();
@@ -612,6 +742,27 @@ class StudioServer {
         res.writeHead(200, { 'Content-Type': contentType });
         res.end(content);
     }
+    async handlePlaygroundChat(req, res) {
+        const body = JSON.parse(await this.readBody(req));
+        const { messages = [], model = 'gpt-4o', temperature = 0.7, systemPrompt } = body;
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+        });
+        // Simulated streaming response for playground demo
+        const allMsgs = systemPrompt ? [{ role: 'system', content: systemPrompt }, ...messages] : messages;
+        const lastMsg = allMsgs[allMsgs.length - 1]?.content || '';
+        const response = `This is a playground demo response to: "${lastMsg}"\n\nModel: ${model}, Temperature: ${temperature}\nMessages in context: ${allMsgs.length}`;
+        const words = response.split(' ');
+        for (let i = 0; i < words.length; i++) {
+            const chunk = (i === 0 ? '' : ' ') + words[i];
+            res.write(`data: ${JSON.stringify({ content: chunk })}\n\n`);
+        }
+        res.write('data: [DONE]\n\n');
+        res.end();
+    }
     readBody(req) {
         return new Promise((resolve, reject) => {
             let body = '';