opc-agent 1.2.1 → 1.3.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/streaming.d.ts

@@ -1,56 +0,0 @@
-import { EventEmitter } from 'events';
-export interface StreamChunk {
-    id: string;
-    type: 'text' | 'tool_call' | 'error' | 'done';
-    data: string;
-    timestamp: number;
-    metadata?: Record<string, unknown>;
-}
-export interface StreamOptions {
-    /** High-water mark for backpressure (default 64 chunks). */
-    highWaterMark?: number;
-    /** Heartbeat interval in ms to keep connection alive (default 15000). */
-    heartbeatInterval?: number;
-}
-export declare class StreamableResponse extends EventEmitter {
-    readonly id: string;
-    private chunks;
-    private ended;
-    private paused;
-    private buffer;
-    private highWaterMark;
-    constructor(id: string, options?: StreamOptions);
-    /** Push a chunk. Returns false if backpressure threshold reached. */
-    push(chunk: StreamChunk): boolean;
-    /** Resume after backpressure — flush buffered chunks. */
-    resume(): void;
-    end(): void;
-    getChunks(): StreamChunk[];
-    /** Collect all text chunks into a single string. */
-    getText(): string;
-    get isEnded(): boolean;
-    get isPaused(): boolean;
-    get length(): number;
-}
-export declare class StreamingManager {
-    private streams;
-    private counter;
-    /** Create a new stream. */
-    createStream(options?: StreamOptions): StreamableResponse;
-    /** Write a text chunk to a stream. */
-    writeChunk(streamId: string, data: string, metadata?: Record<string, unknown>): boolean;
-    /** End a stream. */
-    endStream(streamId: string): void;
-    /** Get an existing stream. */
-    getStream(streamId: string): StreamableResponse | undefined;
-    /** Format a chunk as an SSE event string. */
-    static formatSSE(chunk: StreamChunk): string;
-    /** Pipe a stream to an SSE-compatible HTTP response (Express-style). */
-    static pipeSSE(stream: StreamableResponse, res: {
-        write(data: string): boolean;
-        end(): void;
-        setHeader?(name: string, value: string): void;
-    }, options?: StreamOptions): void;
-    get activeCount(): number;
-}
-//# sourceMappingURL=streaming.d.ts.map

package/dist/core/streaming.js

@@ -1,160 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamingManager = exports.StreamableResponse = void 0;
-const events_1 = require("events");
-// ─── StreamableResponse ──────────────────────────────────────
-class StreamableResponse extends events_1.EventEmitter {
-    id;
-    chunks = [];
-    ended = false;
-    paused = false;
-    buffer = [];
-    highWaterMark;
-    constructor(id, options) {
-        super();
-        this.id = id;
-        this.highWaterMark = options?.highWaterMark ?? 64;
-    }
-    /** Push a chunk. Returns false if backpressure threshold reached. */
-    push(chunk) {
-        if (this.ended)
-            return false;
-        this.chunks.push(chunk);
-        if (this.paused) {
-            this.buffer.push(chunk);
-            return this.buffer.length < this.highWaterMark;
-        }
-        this.emit('chunk', chunk);
-        if (this.chunks.length >= this.highWaterMark) {
-            this.paused = true;
-            this.emit('backpressure');
-            return false;
-        }
-        return true;
-    }
-    /** Resume after backpressure — flush buffered chunks. */
-    resume() {
-        if (!this.paused)
-            return;
-        this.paused = false;
-        const buffered = this.buffer.splice(0);
-        for (const chunk of buffered) {
-            this.emit('chunk', chunk);
-        }
-        this.emit('drain');
-    }
-    end() {
-        if (this.ended)
-            return;
-        this.ended = true;
-        if (this.paused)
-            this.resume();
-        this.emit('end');
-    }
-    getChunks() {
-        return [...this.chunks];
-    }
-    /** Collect all text chunks into a single string. */
-    getText() {
-        return this.chunks
-            .filter((c) => c.type === 'text')
-            .map((c) => c.data)
-            .join('');
-    }
-    get isEnded() {
-        return this.ended;
-    }
-    get isPaused() {
-        return this.paused;
-    }
-    get length() {
-        return this.chunks.length;
-    }
-}
-exports.StreamableResponse = StreamableResponse;
-// ─── StreamingManager ────────────────────────────────────────
-class StreamingManager {
-    streams = new Map();
-    counter = 0;
-    /** Create a new stream. */
-    createStream(options) {
-        const id = `stream_${++this.counter}_${Date.now()}`;
-        const stream = new StreamableResponse(id, options);
-        this.streams.set(id, stream);
-        stream.on('end', () => {
-            // Keep ended streams for a bit for late consumers, then clean up
-            setTimeout(() => this.streams.delete(id), 30_000);
-        });
-        return stream;
-    }
-    /** Write a text chunk to a stream. */
-    writeChunk(streamId, data, metadata) {
-        const stream = this.streams.get(streamId);
-        if (!stream)
-            return false;
-        return stream.push({
-            id: `chunk_${stream.length}`,
-            type: 'text',
-            data,
-            timestamp: Date.now(),
-            metadata,
-        });
-    }
-    /** End a stream. */
-    endStream(streamId) {
-        const stream = this.streams.get(streamId);
-        if (!stream)
-            return;
-        stream.push({
-            id: `chunk_${stream.length}`,
-            type: 'done',
-            data: '',
-            timestamp: Date.now(),
-        });
-        stream.end();
-    }
-    /** Get an existing stream. */
-    getStream(streamId) {
-        return this.streams.get(streamId);
-    }
-    /** Format a chunk as an SSE event string. */
-    static formatSSE(chunk) {
-        const lines = [];
-        lines.push(`event: ${chunk.type}`);
-        lines.push(`id: ${chunk.id}`);
-        const payload = JSON.stringify({ data: chunk.data, metadata: chunk.metadata });
-        lines.push(`data: ${payload}`);
-        lines.push('');
-        return lines.join('\n') + '\n';
-    }
-    /** Pipe a stream to an SSE-compatible HTTP response (Express-style). */
-    static pipeSSE(stream, res, options) {
-        res.setHeader?.('Content-Type', 'text/event-stream');
-        res.setHeader?.('Cache-Control', 'no-cache');
-        res.setHeader?.('Connection', 'keep-alive');
-        const heartbeatMs = options?.heartbeatInterval ?? 15_000;
-        const heartbeat = setInterval(() => {
-            res.write(': heartbeat\n\n');
-        }, heartbeatMs);
-        stream.on('chunk', (chunk) => {
-            const ok = res.write(StreamingManager.formatSSE(chunk));
-            if (!ok && stream.isPaused === false) {
-                // Downstream can't keep up — will resume on drain from stream
-            }
-        });
-        stream.on('end', () => {
-            clearInterval(heartbeat);
-            res.end();
-        });
-    }
-    get activeCount() {
-        let count = 0;
-        for (const s of this.streams.values()) {
-            if (!s.isEnded)
-                count++;
-        }
-        return count;
-    }
-}
-exports.StreamingManager = StreamingManager;
-//# sourceMappingURL=streaming.js.map

package/dist/tools/gateway.d.ts

@@ -1,28 +0,0 @@
-import type { MCPTool, MCPToolDefinition, MCPToolResult } from './mcp';
-export interface ToolGatewayConfig {
-    enabled: boolean;
-    endpoint: string;
-    apiKey: string;
-    enabledTools?: GatewayToolName[];
-    timeout?: number;
-}
-export type GatewayToolName = 'web-search' | 'image-gen' | 'tts' | 'browser';
-export declare class ToolGateway {
-    private config;
-    private availableTools;
-    private connected;
-    constructor(config: ToolGatewayConfig);
-    /** Discover available tools from the gateway endpoint. */
-    connect(): Promise<void>;
-    /** Load default tool definitions (used as fallback). */
-    private loadDefaults;
-    /** Invoke a tool through the gateway. */
-    invokeTool(name: GatewayToolName, input: Record<string, unknown>): Promise<MCPToolResult>;
-    /** Get all gateway tools as MCPTool instances for registry integration. */
-    getTools(): MCPTool[];
-    /** Get tool definitions (without execute). */
-    listTools(): MCPToolDefinition[];
-    get isConnected(): boolean;
-    get toolCount(): number;
-}
-//# sourceMappingURL=gateway.d.ts.map