opc-agent 0.3.0 → 0.4.0

package/dist/templates/financial-advisor.d.ts

@@ -0,0 +1,15 @@
+import { BaseSkill } from '../skills/base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+import type { OADDocument } from '../schema/oad';
+export declare class BudgetAnalysisSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(_context: AgentContext, message: Message): Promise<SkillResult>;
+}
+export declare class FinancialPlanningSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(_context: AgentContext, message: Message): Promise<SkillResult>;
+}
+export declare function createFinancialAdvisorConfig(): OADDocument;
+//# sourceMappingURL=financial-advisor.d.ts.map

package/dist/templates/financial-advisor.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinancialPlanningSkill = exports.BudgetAnalysisSkill = void 0;
+exports.createFinancialAdvisorConfig = createFinancialAdvisorConfig;
+const base_1 = require("../skills/base");
+class BudgetAnalysisSkill extends base_1.BaseSkill {
+    name = 'budget-analysis';
+    description = 'Analyze budgets and expenses';
+    async execute(_context, message) {
+        const lower = message.content.toLowerCase();
+        if (lower.includes('budget') || lower.includes('expense') || lower.includes('cost')) {
+            return this.match('I can help analyze your budget. Please share your income and expense categories, and I\'ll provide insights on spending patterns and savings opportunities.', 0.8);
+        }
+        if (lower.includes('save') || lower.includes('saving')) {
+            return this.match('Common savings strategies: 50/30/20 rule (needs/wants/savings), automate transfers, review subscriptions, negotiate bills, and track daily spending.', 0.75);
+        }
+        return this.noMatch();
+    }
+}
+exports.BudgetAnalysisSkill = BudgetAnalysisSkill;
+class FinancialPlanningSkill extends base_1.BaseSkill {
+    name = 'financial-planning';
+    description = 'Help with financial planning and advice';
+    async execute(_context, message) {
+        const lower = message.content.toLowerCase();
+        if (lower.includes('invest') || lower.includes('portfolio')) {
+            return this.match('For investment planning, consider: risk tolerance, time horizon, diversification, asset allocation, and regular rebalancing. This is general guidance — consult a certified financial advisor for personalized advice.', 0.8);
+        }
+        if (lower.includes('retire') || lower.includes('pension')) {
+            return this.match('Retirement planning essentials: estimate target savings (25x annual expenses), maximize employer matching, consider tax-advantaged accounts, and start early for compound growth.', 0.8);
+        }
+        return this.noMatch();
+    }
+}
+exports.FinancialPlanningSkill = FinancialPlanningSkill;
+function createFinancialAdvisorConfig() {
+    return {
+        apiVersion: 'opc/v1',
+        kind: 'Agent',
+        metadata: {
+            name: 'financial-advisor',
+            version: '1.0.0',
+            description: 'AI Financial Advisor - budget analysis, expense tracking, financial planning',
+            author: 'OPC',
+            license: 'Apache-2.0',
+        },
+        spec: {
+            model: 'deepseek-chat',
+            systemPrompt: 'You are a financial advisor AI. Help users with budget analysis, expense tracking, and financial planning. Always recommend consulting a certified financial advisor for binding decisions.',
+            skills: [
+                { name: 'budget-analysis', description: 'Analyze budgets and expenses' },
+                { name: 'financial-planning', description: 'Financial planning advice' },
+            ],
+            channels: [{ type: 'web', port: 3000 }],
+            memory: { shortTerm: true, longTerm: false },
+            streaming: false,
+        },
+    };
+}
+//# sourceMappingURL=financial-advisor.js.map

package/dist/templates/legal-assistant.d.ts

@@ -0,0 +1,15 @@
+import { BaseSkill } from '../skills/base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+import type { OADDocument } from '../schema/oad';
+export declare class ContractReviewSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(_context: AgentContext, message: Message): Promise<SkillResult>;
+}
+export declare class ComplianceCheckSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(_context: AgentContext, message: Message): Promise<SkillResult>;
+}
+export declare function createLegalAssistantConfig(): OADDocument;
+//# sourceMappingURL=legal-assistant.d.ts.map

package/dist/templates/legal-assistant.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplianceCheckSkill = exports.ContractReviewSkill = void 0;
+exports.createLegalAssistantConfig = createLegalAssistantConfig;
+const base_1 = require("../skills/base");
+const LEGAL_TERMS = {
+    'force majeure': 'A clause that frees parties from obligations due to extraordinary events.',
+    'indemnification': 'One party agrees to compensate the other for certain damages or losses.',
+    'limitation of liability': 'A cap on the amount one party can claim from the other.',
+    'non-compete': 'Restricts a party from competing within a specified scope and timeframe.',
+    'confidentiality': 'Obligations to keep certain information private.',
+    'termination': 'Conditions under which the agreement may be ended.',
+};
+class ContractReviewSkill extends base_1.BaseSkill {
+    name = 'contract-review';
+    description = 'Review contracts and identify key clauses';
+    async execute(_context, message) {
+        const lower = message.content.toLowerCase();
+        for (const [term, explanation] of Object.entries(LEGAL_TERMS)) {
+            if (lower.includes(term)) {
+                return this.match(`📋 **${term.toUpperCase()}**: ${explanation}`, 0.85);
+            }
+        }
+        if (lower.includes('review') || lower.includes('contract')) {
+            return this.match('I can review contracts for key clauses like force majeure, indemnification, limitation of liability, non-compete, confidentiality, and termination provisions.', 0.7);
+        }
+        return this.noMatch();
+    }
+}
+exports.ContractReviewSkill = ContractReviewSkill;
+class ComplianceCheckSkill extends base_1.BaseSkill {
+    name = 'compliance-check';
+    description = 'Check compliance with regulations';
+    async execute(_context, message) {
+        const lower = message.content.toLowerCase();
+        if (lower.includes('gdpr') || lower.includes('privacy')) {
+            return this.match('GDPR compliance requires: data minimization, consent mechanisms, right to erasure, data protection officer, and breach notification within 72 hours.', 0.9);
+        }
+        if (lower.includes('compliance') || lower.includes('regulation')) {
+            return this.match('I can check compliance with GDPR, CCPA, SOX, HIPAA, and other major regulations. Please specify the regulation and context.', 0.7);
+        }
+        return this.noMatch();
+    }
+}
+exports.ComplianceCheckSkill = ComplianceCheckSkill;
+function createLegalAssistantConfig() {
+    return {
+        apiVersion: 'opc/v1',
+        kind: 'Agent',
+        metadata: {
+            name: 'legal-assistant',
+            version: '1.0.0',
+            description: 'AI Legal Assistant - contract review, compliance checking, legal research',
+            author: 'OPC',
+            license: 'Apache-2.0',
+        },
+        spec: {
+            model: 'deepseek-chat',
+            systemPrompt: 'You are a legal assistant AI. Help users review contracts, check compliance, and research legal topics. Always recommend consulting a qualified attorney for binding decisions.',
+            skills: [
+                { name: 'contract-review', description: 'Review contracts and identify key clauses' },
+                { name: 'compliance-check', description: 'Check regulatory compliance' },
+            ],
+            channels: [{ type: 'web', port: 3000 }],
+            memory: { shortTerm: true, longTerm: false },
+            streaming: false,
+        },
+    };
+}
+//# sourceMappingURL=legal-assistant.js.map

package/package.json

@@ -1,46 +1,46 @@
-{
-  "name": "opc-agent",
-  "version": "0.3.0",
-  "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "opc": "dist/cli.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "dev": "tsc --watch",
-    "lint": "tsc --noEmit"
-  },
-  "keywords": [
-    "agent",
-    "ai",
-    "llm",
-    "framework",
-    "typescript",
-    "agent-framework"
-  ],
-  "author": "Deepleaper",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Deepleaper/opc-agent.git"
-  },
-  "dependencies": {
-    "agentkits": "^0.1.0",
-    "commander": "^12.0.0",
-    "express": "^4.21.0",
-    "js-yaml": "^4.1.0",
-    "ws": "^8.20.0",
-    "zod": "^3.23.0"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.21",
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^20.11.0",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
-  }
-}
+{
+  "name": "opc-agent",
+  "version": "0.4.0",
+  "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "opc": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "dev": "tsc --watch",
+    "lint": "tsc --noEmit"
+  },
+  "keywords": [
+    "agent",
+    "ai",
+    "llm",
+    "framework",
+    "typescript",
+    "agent-framework"
+  ],
+  "author": "Deepleaper",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Deepleaper/opc-agent.git"
+  },
+  "dependencies": {
+    "agentkits": "^0.1.0",
+    "commander": "^12.0.0",
+    "express": "^4.21.0",
+    "js-yaml": "^4.1.0",
+    "ws": "^8.20.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.11.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  }
+}

package/src/channels/voice.ts

@@ -0,0 +1,106 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+import { Logger } from '../core/logger';
+
+// ── Voice Channel Types ─────────────────────────────────────
+
+export interface STTProvider {
+  name: string;
+  transcribe(audio: Buffer, options?: STTOptions): Promise<string>;
+}
+
+export interface TTSProvider {
+  name: string;
+  synthesize(text: string, options?: TTSOptions): Promise<Buffer>;
+}
+
+export interface STTOptions {
+  language?: string;
+  model?: string;
+}
+
+export interface TTSOptions {
+  voice?: string;
+  speed?: number;
+  language?: string;
+}
+
+export interface VoiceChannelConfig {
+  sttProvider?: STTProvider;
+  ttsProvider?: TTSProvider;
+  sampleRate?: number;
+  language?: string;
+}
+
+// ── Voice Channel ───────────────────────────────────────────
+
+export class VoiceChannel extends BaseChannel {
+  type = 'voice';
+  private config: VoiceChannelConfig;
+  private logger = new Logger('voice-channel');
+  private running = false;
+
+  constructor(config?: VoiceChannelConfig) {
+    super();
+    this.config = config ?? {};
+  }
+
+  async start(): Promise<void> {
+    this.running = true;
+    this.logger.info('Voice channel started', {
+      stt: this.config.sttProvider?.name ?? 'none',
+      tts: this.config.ttsProvider?.name ?? 'none',
+    });
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+    this.logger.info('Voice channel stopped');
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  /** Process audio input: STT → Agent → TTS */
+  async processAudio(audio: Buffer): Promise<{ text: string; response: string; audioResponse?: Buffer }> {
+    if (!this.handler) throw new Error('No message handler set');
+
+    // STT
+    let text: string;
+    if (this.config.sttProvider) {
+      text = await this.config.sttProvider.transcribe(audio, { language: this.config.language });
+    } else {
+      text = audio.toString('utf-8'); // Fallback: treat as text
+    }
+
+    this.logger.debug('STT result', { text });
+
+    // Create message and send to agent
+    const message: Message = {
+      id: `voice_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      role: 'user',
+      content: text,
+      timestamp: Date.now(),
+      metadata: { channel: 'voice' },
+    };
+
+    const response = await this.handler(message);
+
+    // TTS
+    let audioResponse: Buffer | undefined;
+    if (this.config.ttsProvider) {
+      audioResponse = await this.config.ttsProvider.synthesize(response.content, { language: this.config.language });
+    }
+
+    return { text, response: response.content, audioResponse };
+  }
+
+  setSTTProvider(provider: STTProvider): void {
+    this.config.sttProvider = provider;
+  }
+
+  setTTSProvider(provider: TTSProvider): void {
+    this.config.ttsProvider = provider;
+  }
+}

package/src/channels/webhook.ts

@@ -0,0 +1,199 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+import { Logger } from '../core/logger';
+import * as http from 'http';
+import * as crypto from 'crypto';
+
+// ── Webhook Types ───────────────────────────────────────────
+
+export interface WebhookConfig {
+  port?: number;
+  path?: string;
+  secret?: string;
+  retryAttempts?: number;
+  retryDelayMs?: number;
+  outgoing?: WebhookOutgoing[];
+}
+
+export interface WebhookOutgoing {
+  name: string;
+  url: string;
+  secret?: string;
+  events: string[];
+}
+
+export interface WebhookPayload {
+  event: string;
+  data: unknown;
+  timestamp: number;
+  id: string;
+}
+
+// ── Webhook Channel ─────────────────────────────────────────
+
+export class WebhookChannel extends BaseChannel {
+  type = 'webhook';
+  private config: WebhookConfig;
+  private server: http.Server | null = null;
+  private logger = new Logger('webhook-channel');
+  private outgoing: WebhookOutgoing[] = [];
+
+  constructor(config?: WebhookConfig) {
+    super();
+    this.config = config ?? {};
+    this.outgoing = config?.outgoing ?? [];
+  }
+
+  async start(): Promise<void> {
+    const port = this.config.port ?? 3100;
+    const path = this.config.path ?? '/webhook';
+
+    this.server = http.createServer(async (req, res) => {
+      if (req.url !== path || req.method !== 'POST') {
+        res.writeHead(404);
+        res.end('Not found');
+        return;
+      }
+
+      try {
+        const body = await this.readBody(req);
+
+        // Verify signature if secret configured
+        if (this.config.secret) {
+          const signature = req.headers['x-webhook-signature'] as string;
+          if (!this.verifySignature(body, signature, this.config.secret)) {
+            res.writeHead(401);
+            res.end('Invalid signature');
+            return;
+          }
+        }
+
+        const payload: WebhookPayload = JSON.parse(body);
+        const message: Message = {
+          id: payload.id ?? `wh_${Date.now()}`,
+          role: 'user',
+          content: typeof payload.data === 'string' ? payload.data : JSON.stringify(payload.data),
+          timestamp: payload.timestamp ?? Date.now(),
+          metadata: { channel: 'webhook', event: payload.event },
+        };
+
+        if (this.handler) {
+          const response = await this.handler(message);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ status: 'ok', response: response.content }));
+        } else {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ status: 'ok' }));
+        }
+      } catch (err) {
+        this.logger.error('Webhook error', { error: (err as Error).message });
+        res.writeHead(500);
+        res.end('Internal error');
+      }
+    });
+
+    return new Promise((resolve) => {
+      this.server!.listen(port, () => {
+        this.logger.info('Webhook channel started', { port, path });
+        resolve();
+      });
+    });
+  }
+
+  async stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          this.logger.info('Webhook channel stopped');
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  /** Send a webhook to outgoing endpoints */
+  async send(event: string, data: unknown): Promise<void> {
+    const targets = this.outgoing.filter(o => o.events.includes(event) || o.events.includes('*'));
+
+    for (const target of targets) {
+      const payload: WebhookPayload = {
+        event,
+        data,
+        timestamp: Date.now(),
+        id: `wh_out_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      };
+
+      await this.sendWithRetry(target, payload);
+    }
+  }
+
+  private async sendWithRetry(target: WebhookOutgoing, payload: WebhookPayload): Promise<void> {
+    const maxRetries = this.config.retryAttempts ?? 3;
+    const retryDelay = this.config.retryDelayMs ?? 1000;
+    const body = JSON.stringify(payload);
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        await this.httpPost(target.url, body, target.secret);
+        return;
+      } catch (err) {
+        if (attempt === maxRetries) {
+          this.logger.error('Webhook delivery failed', { target: target.name, error: (err as Error).message });
+          throw err;
+        }
+        await new Promise(r => setTimeout(r, retryDelay * Math.pow(2, attempt)));
+      }
+    }
+  }
+
+  private httpPost(url: string, body: string, secret?: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const urlObj = new URL(url);
+      const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+      if (secret) {
+        headers['x-webhook-signature'] = this.createSignature(body, secret);
+      }
+
+      const req = http.request(
+        { hostname: urlObj.hostname, port: urlObj.port, path: urlObj.pathname, method: 'POST', headers },
+        (res) => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve();
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}`));
+          }
+          res.resume();
+        },
+      );
+      req.on('error', reject);
+      req.write(body);
+      req.end();
+    });
+  }
+
+  private readBody(req: http.IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      req.on('data', (c: Buffer) => chunks.push(c));
+      req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+      req.on('error', reject);
+    });
+  }
+
+  verifySignature(body: string, signature: string, secret: string): boolean {
+    if (!signature) return false;
+    const expected = this.createSignature(body, secret);
+    if (signature.length !== expected.length) return false;
+    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+  }
+
+  createSignature(body: string, secret: string): string {
+    return crypto.createHmac('sha256', secret).update(body).digest('hex');
+  }
+
+  addOutgoing(outgoing: WebhookOutgoing): void {
+    this.outgoing.push(outgoing);
+  }
+}