opc-agent 1.3.2 → 1.4.0

package/tests/workflow.test.ts

@@ -1,143 +1,143 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { WorkflowEngine, WorkflowDefinition } from '../src/core/workflow';
-import { BaseSkill } from '../src/skills/base';
-import type { AgentContext, Message, SkillResult, MemoryStore } from '../src/core/types';
-
-class EchoSkill extends BaseSkill {
-  name = 'echo';
-  description = 'Echo input';
-  async execute(_ctx: AgentContext, msg: Message): Promise<SkillResult> {
-    return this.match(`echo:${msg.content}`, 1.0);
-  }
-}
-
-class UpperSkill extends BaseSkill {
-  name = 'upper';
-  description = 'Uppercase';
-  async execute(_ctx: AgentContext, msg: Message): Promise<SkillResult> {
-    return this.match(msg.content.toUpperCase(), 1.0);
-  }
-}
-
-class FailSkill extends BaseSkill {
-  name = 'fail';
-  description = 'Always fails';
-  async execute(): Promise<SkillResult> {
-    throw new Error('intentional failure');
-  }
-}
-
-const mockMemory: MemoryStore = {
-  get: async () => null,
-  set: async () => {},
-  getConversation: async () => [],
-  addMessage: async () => {},
-  clear: async () => {},
-};
-
-const mockContext: AgentContext = {
-  agentName: 'test',
-  sessionId: 'test-session',
-  messages: [],
-  memory: mockMemory,
-  metadata: {},
-};
-
-describe('WorkflowEngine', () => {
-  let engine: WorkflowEngine;
-
-  beforeEach(() => {
-    engine = new WorkflowEngine();
-    engine.registerSkill(new EchoSkill());
-    engine.registerSkill(new UpperSkill());
-    engine.registerSkill(new FailSkill());
-  });
-
-  it('should register and list workflows', () => {
-    const wf: WorkflowDefinition = { name: 'test', steps: [] };
-    engine.registerWorkflow(wf);
-    expect(engine.listWorkflows()).toHaveLength(1);
-    expect(engine.getWorkflow('test')).toBeDefined();
-  });
-
-  it('should run sequential steps', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'seq',
-      steps: [
-        { id: 's1', type: 'skill', name: 'echo' },
-        { id: 's2', type: 'skill', name: 'upper' },
-      ],
-    };
-    engine.registerWorkflow(wf);
-    const result = await engine.run('seq', mockContext, 'hello');
-    expect(result.status).toBe('completed');
-    expect(result.steps).toHaveLength(2);
-  });
-
-  it('should handle parallel steps', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'par',
-      steps: [{
-        id: 'p1', type: 'parallel', name: 'parallel',
-        parallel: [
-          { id: 's1', type: 'skill', name: 'echo' },
-          { id: 's2', type: 'skill', name: 'upper' },
-        ],
-      }],
-    };
-    engine.registerWorkflow(wf);
-    const result = await engine.run('par', mockContext, 'test');
-    expect(result.status).toBe('completed');
-  });
-
-  it('should handle conditional branching', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'cond',
-      steps: [{
-        id: 'c1', type: 'condition', name: 'check',
-        condition: 'contains:hello',
-        branches: {
-          if: [{ id: 's1', type: 'skill', name: 'echo' }],
-          else: [{ id: 's2', type: 'skill', name: 'upper' }],
-        },
-      }],
-    };
-    engine.registerWorkflow(wf);
-    const r1 = await engine.run('cond', mockContext, 'hello world');
-    expect(r1.steps.find(s => s.stepId === 's1')).toBeDefined();
-  });
-
-  it('should handle step failures with stop policy', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'fail-wf',
-      onError: 'stop',
-      steps: [
-        { id: 's1', type: 'skill', name: 'fail' },
-        { id: 's2', type: 'skill', name: 'echo' },
-      ],
-    };
-    engine.registerWorkflow(wf);
-    const result = await engine.run('fail-wf', mockContext, 'test');
-    expect(result.status).toBe('failed');
-  });
-
-  it('should retry failed steps', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'retry-wf',
-      steps: [{ id: 's1', type: 'skill', name: 'fail', retries: 2 }],
-    };
-    engine.registerWorkflow(wf);
-    const result = await engine.run('retry-wf', mockContext, 'test');
-    expect(result.steps[0].status).toBe('error');
-  });
-
-  it('should throw on unknown workflow', async () => {
-    await expect(engine.run('nonexistent', mockContext)).rejects.toThrow();
-  });
-
-  it('should unregister workflows', () => {
-    engine.registerWorkflow({ name: 'temp', steps: [] });
-    engine.unregisterWorkflow('temp');
-    expect(engine.getWorkflow('temp')).toBeUndefined();
-  });
-});
+import { describe, it, expect, beforeEach } from 'vitest';
+import { WorkflowEngine, WorkflowDefinition } from '../src/core/workflow';
+import { BaseSkill } from '../src/skills/base';
+import type { AgentContext, Message, SkillResult, MemoryStore } from '../src/core/types';
+
+class EchoSkill extends BaseSkill {
+  name = 'echo';
+  description = 'Echo input';
+  async execute(_ctx: AgentContext, msg: Message): Promise<SkillResult> {
+    return this.match(`echo:${msg.content}`, 1.0);
+  }
+}
+
+class UpperSkill extends BaseSkill {
+  name = 'upper';
+  description = 'Uppercase';
+  async execute(_ctx: AgentContext, msg: Message): Promise<SkillResult> {
+    return this.match(msg.content.toUpperCase(), 1.0);
+  }
+}
+
+class FailSkill extends BaseSkill {
+  name = 'fail';
+  description = 'Always fails';
+  async execute(): Promise<SkillResult> {
+    throw new Error('intentional failure');
+  }
+}
+
+const mockMemory: MemoryStore = {
+  get: async () => null,
+  set: async () => {},
+  getConversation: async () => [],
+  addMessage: async () => {},
+  clear: async () => {},
+};
+
+const mockContext: AgentContext = {
+  agentName: 'test',
+  sessionId: 'test-session',
+  messages: [],
+  memory: mockMemory,
+  metadata: {},
+};
+
+describe('WorkflowEngine', () => {
+  let engine: WorkflowEngine;
+
+  beforeEach(() => {
+    engine = new WorkflowEngine();
+    engine.registerSkill(new EchoSkill());
+    engine.registerSkill(new UpperSkill());
+    engine.registerSkill(new FailSkill());
+  });
+
+  it('should register and list workflows', () => {
+    const wf: WorkflowDefinition = { name: 'test', steps: [] };
+    engine.registerWorkflow(wf);
+    expect(engine.listWorkflows()).toHaveLength(1);
+    expect(engine.getWorkflow('test')).toBeDefined();
+  });
+
+  it('should run sequential steps', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'seq',
+      steps: [
+        { id: 's1', type: 'skill', name: 'echo' },
+        { id: 's2', type: 'skill', name: 'upper' },
+      ],
+    };
+    engine.registerWorkflow(wf);
+    const result = await engine.run('seq', mockContext, 'hello');
+    expect(result.status).toBe('completed');
+    expect(result.steps).toHaveLength(2);
+  });
+
+  it('should handle parallel steps', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'par',
+      steps: [{
+        id: 'p1', type: 'parallel', name: 'parallel',
+        parallel: [
+          { id: 's1', type: 'skill', name: 'echo' },
+          { id: 's2', type: 'skill', name: 'upper' },
+        ],
+      }],
+    };
+    engine.registerWorkflow(wf);
+    const result = await engine.run('par', mockContext, 'test');
+    expect(result.status).toBe('completed');
+  });
+
+  it('should handle conditional branching', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'cond',
+      steps: [{
+        id: 'c1', type: 'condition', name: 'check',
+        condition: 'contains:hello',
+        branches: {
+          if: [{ id: 's1', type: 'skill', name: 'echo' }],
+          else: [{ id: 's2', type: 'skill', name: 'upper' }],
+        },
+      }],
+    };
+    engine.registerWorkflow(wf);
+    const r1 = await engine.run('cond', mockContext, 'hello world');
+    expect(r1.steps.find(s => s.stepId === 's1')).toBeDefined();
+  });
+
+  it('should handle step failures with stop policy', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'fail-wf',
+      onError: 'stop',
+      steps: [
+        { id: 's1', type: 'skill', name: 'fail' },
+        { id: 's2', type: 'skill', name: 'echo' },
+      ],
+    };
+    engine.registerWorkflow(wf);
+    const result = await engine.run('fail-wf', mockContext, 'test');
+    expect(result.status).toBe('failed');
+  });
+
+  it('should retry failed steps', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'retry-wf',
+      steps: [{ id: 's1', type: 'skill', name: 'fail', retries: 2 }],
+    };
+    engine.registerWorkflow(wf);
+    const result = await engine.run('retry-wf', mockContext, 'test');
+    expect(result.steps[0].status).toBe('error');
+  });
+
+  it('should throw on unknown workflow', async () => {
+    await expect(engine.run('nonexistent', mockContext)).rejects.toThrow();
+  });
+
+  it('should unregister workflows', () => {
+    engine.registerWorkflow({ name: 'temp', steps: [] });
+    engine.unregisterWorkflow('temp');
+    expect(engine.getWorkflow('temp')).toBeUndefined();
+  });
+});

package/tsconfig.json

@@ -1,19 +1,19 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "lib": ["ES2022"],
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -1,9 +1,9 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['tests/**/*.test.ts'],
-  },
-});
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+  },
+});

package/dist/core/dashboard.d.ts

@@ -1,35 +0,0 @@
-export interface DashboardConfig {
-    /** Enable the dashboard (default: false) */
-    enabled: boolean;
-    /** HTTP port (default: 4100) */
-    port?: number;
-    /** Bind address (default: 127.0.0.1 for security) */
-    host?: string;
-    /** Enable CORS (default: false) */
-    cors?: boolean;
-}
-interface SessionSummary {
-    id: string;
-    channel: string;
-    messages: number;
-    lastActive: number;
-    status: 'active' | 'idle' | 'closed';
-}
-export declare class Dashboard {
-    private app;
-    private server;
-    private config;
-    private startTime;
-    private stats;
-    constructor(config: DashboardConfig);
-    private setupRoutes;
-    private getState;
-    trackSession(session: SessionSummary): void;
-    trackToolCall(toolName: string): void;
-    trackChannel(name: string, connected: boolean, messages?: number): void;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    private renderHTML;
-}
-export {};
-//# sourceMappingURL=dashboard.d.ts.map

package/dist/core/dashboard.js

@@ -1,157 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dashboard = void 0;
-const express_1 = __importDefault(require("express"));
-// ─── Dashboard Server ────────────────────────────────────────
-class Dashboard {
-    app = (0, express_1.default)();
-    server = null;
-    config;
-    startTime = Date.now();
-    stats = {
-        sessions: new Map(),
-        toolInvocations: new Map(),
-        channelStats: new Map(),
-    };
-    constructor(config) {
-        this.config = {
-            enabled: config.enabled,
-            port: config.port ?? 4100,
-            host: config.host ?? '127.0.0.1',
-            cors: config.cors ?? false,
-        };
-        this.setupRoutes();
-    }
-    setupRoutes() {
-        if (this.config.cors) {
-            this.app.use((_req, res, next) => {
-                res.header('Access-Control-Allow-Origin', '*');
-                res.header('Access-Control-Allow-Headers', 'Content-Type');
-                next();
-            });
-        }
-        this.app.use(express_1.default.json());
-        // Health check
-        this.app.get('/api/health', (_req, res) => {
-            res.json({ status: 'ok', uptime: Date.now() - this.startTime });
-        });
-        // Overview state
-        this.app.get('/api/state', (_req, res) => {
-            res.json(this.getState());
-        });
-        // Sessions
-        this.app.get('/api/sessions', (_req, res) => {
-            res.json([...this.stats.sessions.values()]);
-        });
-        // Tools
-        this.app.get('/api/tools', (_req, res) => {
-            const tools = [];
-            for (const [name, stat] of this.stats.toolInvocations) {
-                tools.push({ name, type: 'builtin', enabled: true, invocations: stat.count, lastUsed: stat.lastUsed });
-            }
-            res.json(tools);
-        });
-        // Channels
-        this.app.get('/api/channels', (_req, res) => {
-            const channels = [];
-            for (const [name, stat] of this.stats.channelStats) {
-                channels.push({ name, type: name, connected: stat.connected, messageCount: stat.messages });
-            }
-            res.json(channels);
-        });
-        // Simple HTML dashboard
-        this.app.get('/', (_req, res) => {
-            res.send(this.renderHTML());
-        });
-    }
-    getState() {
-        return {
-            agent: { name: 'opc-agent', version: '1.3.0', status: 'running', uptime: Date.now() - this.startTime },
-            sessions: [...this.stats.sessions.values()],
-            tools: [...this.stats.toolInvocations.entries()].map(([name, s]) => ({
-                name, type: 'builtin', enabled: true, invocations: s.count, lastUsed: s.lastUsed,
-            })),
-            channels: [...this.stats.channelStats.entries()].map(([name, s]) => ({
-                name, type: name, connected: s.connected, messageCount: s.messages,
-            })),
-            memory: { provider: 'unknown', entries: 0 },
-            modelAuth: { providers: [] },
-        };
-    }
-    // ─── Event Tracking ──────────────────────────────────────
-    trackSession(session) {
-        this.stats.sessions.set(session.id, session);
-    }
-    trackToolCall(toolName) {
-        const existing = this.stats.toolInvocations.get(toolName) ?? { count: 0, lastUsed: 0 };
-        existing.count++;
-        existing.lastUsed = Date.now();
-        this.stats.toolInvocations.set(toolName, existing);
-    }
-    trackChannel(name, connected, messages) {
-        const existing = this.stats.channelStats.get(name) ?? { connected: false, messages: 0 };
-        existing.connected = connected;
-        if (messages !== undefined)
-            existing.messages = messages;
-        this.stats.channelStats.set(name, existing);
-    }
-    // ─── Lifecycle ───────────────────────────────────────────
-    async start() {
-        if (!this.config.enabled)
-            return;
-        return new Promise((resolve) => {
-            this.server = this.app.listen(this.config.port, this.config.host, () => {
-                console.log(`[dashboard] http://${this.config.host}:${this.config.port}`);
-                resolve();
-            });
-        });
-    }
-    async stop() {
-        return new Promise((resolve) => {
-            if (this.server)
-                this.server.close(() => resolve());
-            else
-                resolve();
-        });
-    }
-    renderHTML() {
-        return `<!DOCTYPE html>
-<html><head><meta charset="utf-8"><title>OPC Agent Dashboard</title>
-<meta name="viewport" content="width=device-width,initial-scale=1">
-<style>
-*{box-sizing:border-box;margin:0;padding:0}
-body{font-family:system-ui,-apple-system,sans-serif;background:#0a0a0f;color:#e0e0e0;padding:24px}
-h1{font-size:1.5rem;margin-bottom:20px;color:#7c9aff}
-.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:16px}
-.card{background:#14141f;border:1px solid #2a2a3a;border-radius:12px;padding:20px}
-.card h2{font-size:0.85rem;text-transform:uppercase;letter-spacing:1px;color:#888;margin-bottom:12px}
-.stat{font-size:2rem;font-weight:700;color:#7c9aff}
-.sub{font-size:0.8rem;color:#666;margin-top:4px}
-#data{margin-top:20px;font-family:monospace;font-size:0.75rem;color:#555;white-space:pre-wrap}
-</style></head><body>
-<h1>⚡ OPC Agent Dashboard</h1>
-<div class="grid">
-  <div class="card"><h2>Status</h2><div class="stat" id="status">Loading…</div><div class="sub" id="uptime"></div></div>
-  <div class="card"><h2>Sessions</h2><div class="stat" id="sessions">-</div></div>
-  <div class="card"><h2>Tools</h2><div class="stat" id="tools">-</div></div>
-  <div class="card"><h2>Channels</h2><div class="stat" id="channels">-</div></div>
-</div>
-<div id="data"></div>
-<script>
-async function poll(){try{const r=await fetch('/api/state');const d=await r.json();
-document.getElementById('status').textContent=d.agent.status;
-document.getElementById('uptime').textContent='Uptime: '+Math.floor(d.agent.uptime/1000)+'s';
-document.getElementById('sessions').textContent=d.sessions.length;
-document.getElementById('tools').textContent=d.tools.length;
-document.getElementById('channels').textContent=d.channels.length;
-document.getElementById('data').textContent=JSON.stringify(d,null,2);
-}catch(e){document.getElementById('status').textContent='offline'}}
-poll();setInterval(poll,5000);
-</script></body></html>`;
-    }
-}
-exports.Dashboard = Dashboard;
-//# sourceMappingURL=dashboard.js.map

package/dist/core/priority.d.ts

@@ -1,52 +0,0 @@
-export interface PriorityConfig {
-    /** Enable priority mode (default: false) */
-    enabled: boolean;
-    /** Provider-specific priority settings */
-    providers?: PriorityProviderConfig[];
-    /** Default priority tier */
-    defaultTier?: PriorityTier;
-}
-export type PriorityTier = 'standard' | 'fast' | 'batch';
-export interface PriorityProviderConfig {
-    provider: string;
-    tier: PriorityTier;
-    /** Custom endpoint override for priority routing */
-    endpoint?: string;
-    /** Supported models for this tier */
-    models?: string[];
-}
-interface PriorityHeaders {
-    [key: string]: string;
-}
-export declare class PriorityRouter {
-    private config;
-    private runtimeTier;
-    constructor(config: PriorityConfig);
-    /** Toggle fast mode on/off at runtime */
-    toggle(): PriorityTier;
-    /** Set specific tier */
-    setTier(tier: PriorityTier): void;
-    /** Get current tier */
-    getTier(): PriorityTier;
-    /** Check if fast mode is active */
-    isFast(): boolean;
-    /**
-     * Get priority headers for a provider + model combination.
-     * Returns empty object if provider doesn't support priority or model isn't eligible.
-     */
-    getHeaders(provider: string, model: string): PriorityHeaders;
-    /**
-     * Get effective endpoint for a provider, allowing priority-specific routing.
-     */
-    getEndpoint(provider: string, defaultEndpoint: string): string;
-    private getEffectiveTier;
-    private isModelEligible;
-    /** Status summary for dashboard / CLI */
-    status(): {
-        tier: PriorityTier;
-        enabled: boolean;
-        providers: string[];
-    };
-}
-export {};
-//# sourceMappingURL=priority.d.ts.map