opc-agent 1.3.1 → 1.3.2

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/.github/workflows/ci.yml

@@ -1,24 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [18, 20, 22]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-      - run: npm ci
-      - run: npm run build --if-present
-      - run: npx vitest run --reporter=verbose
-        env:
-          CI: true

package/dist/traces/index.d.ts

@@ -1,49 +0,0 @@
-/**
- * OPC Agent Traces — Structured logging for agent actions.
- *
- * Collects traces that can be fed to DeepBrain's learn() API.
- * Inspired by OpenTelemetry spans.
- */
-export interface Span {
-    traceId: string;
-    spanId: string;
-    name: string;
-    startTime: Date;
-    endTime?: Date;
-    attributes: Record<string, string | number | boolean>;
-    events: SpanEvent[];
-    status: 'ok' | 'error' | 'unset';
-}
-export interface SpanEvent {
-    name: string;
-    timestamp: Date;
-    attributes?: Record<string, string | number | boolean>;
-}
-export interface TraceExporter {
-    export(spans: Span[]): Promise<void>;
-}
-/** In-memory buffer that holds spans until flushed */
-export declare class TraceCollector {
-    private spans;
-    private exporters;
-    private maxBufferSize;
-    constructor(maxBufferSize?: number);
-    addExporter(exporter: TraceExporter): void;
-    startSpan(name: string, attributes?: Record<string, string | number | boolean>): Span;
-    endSpan(span: Span, status?: 'ok' | 'error'): void;
-    addEvent(span: Span, name: string, attributes?: Record<string, string | number | boolean>): void;
-    flush(): Promise<number>;
-    getBufferedSpans(): readonly Span[];
-    get bufferedCount(): number;
-}
-/** Console exporter for development */
-export declare class ConsoleExporter implements TraceExporter {
-    export(spans: Span[]): Promise<void>;
-}
-/** DeepBrain exporter — sends traces to DeepBrain learn() */
-export declare class DeepBrainExporter implements TraceExporter {
-    private learnEndpoint;
-    constructor(deepbrainUrl?: string);
-    export(spans: Span[]): Promise<void>;
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/traces/index.js

@@ -1,102 +0,0 @@
-"use strict";
-/**
- * OPC Agent Traces — Structured logging for agent actions.
- *
- * Collects traces that can be fed to DeepBrain's learn() API.
- * Inspired by OpenTelemetry spans.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeepBrainExporter = exports.ConsoleExporter = exports.TraceCollector = void 0;
-/** In-memory buffer that holds spans until flushed */
-class TraceCollector {
-    spans = [];
-    exporters = [];
-    maxBufferSize;
-    constructor(maxBufferSize = 100) {
-        this.maxBufferSize = maxBufferSize;
-    }
-    addExporter(exporter) {
-        this.exporters.push(exporter);
-    }
-    startSpan(name, attributes = {}) {
-        const span = {
-            traceId: crypto.randomUUID(),
-            spanId: crypto.randomUUID().slice(0, 16),
-            name,
-            startTime: new Date(),
-            attributes,
-            events: [],
-            status: 'unset',
-        };
-        this.spans.push(span);
-        if (this.spans.length >= this.maxBufferSize) {
-            this.flush().catch(() => { }); // Best effort
-        }
-        return span;
-    }
-    endSpan(span, status = 'ok') {
-        span.endTime = new Date();
-        span.status = status;
-    }
-    addEvent(span, name, attributes) {
-        span.events.push({ name, timestamp: new Date(), attributes });
-    }
-    async flush() {
-        const toExport = [...this.spans];
-        this.spans = [];
-        for (const exporter of this.exporters) {
-            await exporter.export(toExport);
-        }
-        return toExport.length;
-    }
-    getBufferedSpans() {
-        return this.spans;
-    }
-    get bufferedCount() {
-        return this.spans.length;
-    }
-}
-exports.TraceCollector = TraceCollector;
-/** Console exporter for development */
-class ConsoleExporter {
-    async export(spans) {
-        for (const span of spans) {
-            const duration = span.endTime
-                ? `${span.endTime.getTime() - span.startTime.getTime()}ms`
-                : 'ongoing';
-            console.log(`[TRACE] ${span.name} (${duration}) [${span.status}]`);
-        }
-    }
-}
-exports.ConsoleExporter = ConsoleExporter;
-/** DeepBrain exporter — sends traces to DeepBrain learn() */
-class DeepBrainExporter {
-    learnEndpoint;
-    constructor(deepbrainUrl = 'http://localhost:3333') {
-        this.learnEndpoint = `${deepbrainUrl}/api/learn`;
-    }
-    async export(spans) {
-        for (const span of spans) {
-            try {
-                await fetch(this.learnEndpoint, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        action: span.name,
-                        result: span.status === 'ok' ? 'success' : 'error',
-                        context: {
-                            ...span.attributes,
-                            duration: span.endTime ? span.endTime.getTime() - span.startTime.getTime() : null,
-                            events: span.events.map(e => e.name),
-                        },
-                    }),
-                });
-            }
-            catch {
-                // Best effort — don't break agent if brain is down
-            }
-        }
-    }
-}
-exports.DeepBrainExporter = DeepBrainExporter;
-//# sourceMappingURL=index.js.map

package/src/traces/index.ts

@@ -1,132 +0,0 @@
-/**
- * OPC Agent Traces — Structured logging for agent actions.
- * 
- * Collects traces that can be fed to DeepBrain's learn() API.
- * Inspired by OpenTelemetry spans.
- */
-
-export interface Span {
-  traceId: string;
-  spanId: string;
-  name: string;
-  startTime: Date;
-  endTime?: Date;
-  attributes: Record<string, string | number | boolean>;
-  events: SpanEvent[];
-  status: 'ok' | 'error' | 'unset';
-}
-
-export interface SpanEvent {
-  name: string;
-  timestamp: Date;
-  attributes?: Record<string, string | number | boolean>;
-}
-
-export interface TraceExporter {
-  export(spans: Span[]): Promise<void>;
-}
-
-/** In-memory buffer that holds spans until flushed */
-export class TraceCollector {
-  private spans: Span[] = [];
-  private exporters: TraceExporter[] = [];
-  private maxBufferSize: number;
-
-  constructor(maxBufferSize = 100) {
-    this.maxBufferSize = maxBufferSize;
-  }
-
-  addExporter(exporter: TraceExporter): void {
-    this.exporters.push(exporter);
-  }
-
-  startSpan(name: string, attributes: Record<string, string | number | boolean> = {}): Span {
-    const span: Span = {
-      traceId: crypto.randomUUID(),
-      spanId: crypto.randomUUID().slice(0, 16),
-      name,
-      startTime: new Date(),
-      attributes,
-      events: [],
-      status: 'unset',
-    };
-    this.spans.push(span);
-    
-    if (this.spans.length >= this.maxBufferSize) {
-      this.flush().catch(() => {}); // Best effort
-    }
-    
-    return span;
-  }
-
-  endSpan(span: Span, status: 'ok' | 'error' = 'ok'): void {
-    span.endTime = new Date();
-    span.status = status;
-  }
-
-  addEvent(span: Span, name: string, attributes?: Record<string, string | number | boolean>): void {
-    span.events.push({ name, timestamp: new Date(), attributes });
-  }
-
-  async flush(): Promise<number> {
-    const toExport = [...this.spans];
-    this.spans = [];
-    
-    for (const exporter of this.exporters) {
-      await exporter.export(toExport);
-    }
-    
-    return toExport.length;
-  }
-
-  getBufferedSpans(): readonly Span[] {
-    return this.spans;
-  }
-
-  get bufferedCount(): number {
-    return this.spans.length;
-  }
-}
-
-/** Console exporter for development */
-export class ConsoleExporter implements TraceExporter {
-  async export(spans: Span[]): Promise<void> {
-    for (const span of spans) {
-      const duration = span.endTime 
-        ? `${span.endTime.getTime() - span.startTime.getTime()}ms`
-        : 'ongoing';
-      console.log(`[TRACE] ${span.name} (${duration}) [${span.status}]`);
-    }
-  }
-}
-
-/** DeepBrain exporter — sends traces to DeepBrain learn() */
-export class DeepBrainExporter implements TraceExporter {
-  private learnEndpoint: string;
-
-  constructor(deepbrainUrl: string = 'http://localhost:3333') {
-    this.learnEndpoint = `${deepbrainUrl}/api/learn`;
-  }
-
-  async export(spans: Span[]): Promise<void> {
-    for (const span of spans) {
-      try {
-        await fetch(this.learnEndpoint, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            action: span.name,
-            result: span.status === 'ok' ? 'success' : 'error',
-            context: {
-              ...span.attributes,
-              duration: span.endTime ? span.endTime.getTime() - span.startTime.getTime() : null,
-              events: span.events.map(e => e.name),
-            },
-          }),
-        });
-      } catch {
-        // Best effort — don't break agent if brain is down
-      }
-    }
-  }
-}