opc-agent 0.6.0 → 0.8.0

package/src/core/orchestrator.ts

@@ -0,0 +1,215 @@
+import { EventEmitter } from 'events';
+import type { AgentContext, Message } from './types';
+
+/**
+ * Multi-Agent Orchestrator — v0.8.0
+ * Routes messages to specialized sub-agents, supports parallel execution and handoffs.
+ */
+
+export interface AgentNode {
+  id: string;
+  name: string;
+  description: string;
+  /** Patterns or intents this agent handles */
+  routes: string[];
+  /** Function that processes a message and returns a response */
+  handler: (context: AgentContext, message: Message) => Promise<Message>;
+  /** Priority for routing conflicts (higher wins) */
+  priority?: number;
+}
+
+export interface OrchestratorWorkflow {
+  name: string;
+  description?: string;
+  /** Ordered list of agent IDs for sequential execution */
+  steps?: string[];
+  /** List of agent IDs for parallel execution */
+  parallel?: string[];
+  /** Router config: auto-route based on message content */
+  router?: {
+    agents: string[];
+    fallback?: string;
+  };
+}
+
+export interface HandoffRequest {
+  fromAgent: string;
+  toAgent: string;
+  context: AgentContext;
+  reason: string;
+}
+
+export interface OrchestratorConfig {
+  agents: AgentNode[];
+  workflows?: OrchestratorWorkflow[];
+  defaultWorkflow?: string;
+  maxParallel?: number;
+}
+
+export class Orchestrator extends EventEmitter {
+  private agents: Map<string, AgentNode> = new Map();
+  private workflows: Map<string, OrchestratorWorkflow> = new Map();
+  private defaultWorkflow?: string;
+  private maxParallel: number;
+
+  constructor(config: OrchestratorConfig) {
+    super();
+    this.maxParallel = config.maxParallel ?? 5;
+    this.defaultWorkflow = config.defaultWorkflow;
+
+    for (const agent of config.agents) {
+      this.agents.set(agent.id, agent);
+    }
+    for (const wf of config.workflows ?? []) {
+      this.workflows.set(wf.name, wf);
+    }
+  }
+
+  /** Register a new agent node */
+  registerAgent(agent: AgentNode): void {
+    this.agents.set(agent.id, agent);
+    this.emit('agent:registered', agent.id);
+  }
+
+  /** Unregister an agent */
+  unregisterAgent(id: string): void {
+    this.agents.delete(id);
+    this.emit('agent:unregistered', id);
+  }
+
+  /** Route a message to the best-matching agent */
+  route(message: Message): AgentNode | undefined {
+    const content = message.content.toLowerCase();
+    let bestMatch: AgentNode | undefined;
+    let bestPriority = -1;
+
+    for (const agent of this.agents.values()) {
+      for (const route of agent.routes) {
+        if (content.includes(route.toLowerCase()) || new RegExp(route, 'i').test(content)) {
+          const priority = agent.priority ?? 0;
+          if (priority > bestPriority) {
+            bestMatch = agent;
+            bestPriority = priority;
+          }
+          break;
+        }
+      }
+    }
+    return bestMatch;
+  }
+
+  /** Execute a single agent */
+  async executeAgent(agentId: string, context: AgentContext, message: Message): Promise<Message> {
+    const agent = this.agents.get(agentId);
+    if (!agent) throw new Error(`Agent not found: ${agentId}`);
+    this.emit('agent:execute', agentId, message);
+    const result = await agent.handler(context, message);
+    this.emit('agent:complete', agentId, result);
+    return result;
+  }
+
+  /** Run multiple agents in parallel */
+  async executeParallel(
+    agentIds: string[],
+    context: AgentContext,
+    message: Message
+  ): Promise<Map<string, Message>> {
+    const results = new Map<string, Message>();
+    const batches: string[][] = [];
+
+    // Batch by maxParallel
+    for (let i = 0; i < agentIds.length; i += this.maxParallel) {
+      batches.push(agentIds.slice(i, i + this.maxParallel));
+    }
+
+    for (const batch of batches) {
+      const promises = batch.map(async (id) => {
+        const result = await this.executeAgent(id, context, message);
+        results.set(id, result);
+      });
+      await Promise.all(promises);
+    }
+
+    return results;
+  }
+
+  /** Execute a named workflow */
+  async executeWorkflow(
+    workflowName: string,
+    context: AgentContext,
+    message: Message
+  ): Promise<Message[]> {
+    const wf = this.workflows.get(workflowName);
+    if (!wf) throw new Error(`Workflow not found: ${workflowName}`);
+
+    const results: Message[] = [];
+
+    // Sequential steps
+    if (wf.steps) {
+      let currentMessage = message;
+      for (const agentId of wf.steps) {
+        const result = await this.executeAgent(agentId, context, currentMessage);
+        results.push(result);
+        currentMessage = result; // chain output → next input
+      }
+    }
+
+    // Parallel execution
+    if (wf.parallel) {
+      const parallelResults = await this.executeParallel(wf.parallel, context, message);
+      results.push(...parallelResults.values());
+    }
+
+    // Router-based
+    if (wf.router) {
+      const matched = this.route(message);
+      const targetId = matched && wf.router.agents.includes(matched.id)
+        ? matched.id
+        : wf.router.fallback;
+      if (targetId) {
+        const result = await this.executeAgent(targetId, context, message);
+        results.push(result);
+      }
+    }
+
+    return results;
+  }
+
+  /** Hand off conversation from one agent to another */
+  async handoff(request: HandoffRequest): Promise<Message> {
+    this.emit('agent:handoff', request);
+    const { toAgent, context } = request;
+    const lastMessage = context.messages[context.messages.length - 1];
+    if (!lastMessage) throw new Error('No message in context for handoff');
+    return this.executeAgent(toAgent, context, lastMessage);
+  }
+
+  /** Process an incoming message using the default workflow or routing */
+  async process(context: AgentContext, message: Message): Promise<Message[]> {
+    if (this.defaultWorkflow) {
+      return this.executeWorkflow(this.defaultWorkflow, context, message);
+    }
+
+    // Fallback: route to single agent
+    const agent = this.route(message);
+    if (agent) {
+      const result = await this.executeAgent(agent.id, context, message);
+      return [result];
+    }
+
+    return [{
+      id: `orch-${Date.now()}`,
+      role: 'assistant',
+      content: 'No agent available to handle this request.',
+      timestamp: Date.now(),
+    }];
+  }
+
+  getAgents(): AgentNode[] {
+    return Array.from(this.agents.values());
+  }
+
+  getWorkflows(): OrchestratorWorkflow[] {
+    return Array.from(this.workflows.values());
+  }
+}

package/src/index.ts

@@ -54,3 +54,30 @@ export { deployToHermes } from './deploy/hermes';
 export type { HermesDeployOptions, HermesDeployResult } from './deploy/hermes';
 export { publishAgent, installAgent } from './marketplace';
 export type { AgentManifest, PublishOptions, InstallOptions } from './marketplace';
+
+// v0.7.0 modules
+export { createAuthMiddleware, getActiveSessions } from './core/auth';
+export type { AuthConfig, AuthSession } from './core/auth';
+// v0.8.0 modules
+export { Orchestrator } from './core/orchestrator';
+export type { AgentNode, OrchestratorWorkflow, OrchestratorConfig, HandoffRequest } from './core/orchestrator';
+export { AgentPipeline, compose } from './core/compose';
+export type { ComposableAgent, ComposeOptions } from './core/compose';
+export { EmailChannel } from './channels/email';
+export type { EmailChannelConfig, EmailMessage } from './channels/email';
+export { SlackChannel } from './channels/slack';
+export type { SlackChannelConfig, SlashCommandConfig, SlashCommandPayload } from './channels/slack';
+export { WeChatChannel } from './channels/wechat';
+export type { WeChatChannelConfig, WeChatMessage, TemplateMessageData } from './channels/wechat';
+export { CalculatorTool } from './tools/calculator';
+export { DateTimeTool } from './tools/datetime';
+export { JsonTransformTool } from './tools/json-transform';
+export { TextAnalysisTool } from './tools/text-analysis';
+
+export { HttpSkill } from './skills/http';
+export { WebhookTriggerSkill } from './skills/webhook-trigger';
+export type { WebhookTarget } from './skills/webhook-trigger';
+export { SchedulerSkill } from './skills/scheduler';
+export type { ScheduledTask } from './skills/scheduler';
+export { DocumentSkill } from './skills/document';
+export type { DocumentChunk } from './skills/document';

package/src/schema/oad.ts

@@ -48,6 +48,12 @@ export const HITLSchema = z.object({
   defaultAction: z.enum(['approve', 'deny']).default('deny'),
 });
 
+export const AuthSchema = z.object({
+  enabled: z.boolean().default(false),
+  apiKeys: z.array(z.string()).default([]),
+  sessionIsolation: z.boolean().default(true),
+});
+
 export const ChannelSchema = z.object({
   type: z.enum(['web', 'websocket', 'telegram', 'cli', 'voice', 'webhook']),
   port: z.number().optional(),
@@ -124,6 +130,7 @@ export const SpecSchema = z.object({
   voice: VoiceSchema.optional(),
   webhook: WebhookSchema.optional(),
   hitl: HITLSchema.optional(),
+  auth: AuthSchema.optional(),
 });
 
 export const OADSchema = z.object({

package/src/skills/document.ts

@@ -0,0 +1,100 @@
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+import { KnowledgeBase } from '../core/knowledge';
+
+export interface DocumentChunk {
+  content: string;
+  metadata: {
+    filename: string;
+    mimeType: string;
+    chunkIndex: number;
+    totalChunks: number;
+  };
+}
+
+export class DocumentSkill extends BaseSkill {
+  name = 'document';
+  description = 'Process uploaded documents (PDF, TXT, MD, DOCX). Chunks content and adds to knowledge base.';
+  private knowledgeBase: KnowledgeBase;
+
+  constructor(kbPath: string = '.') {
+    super();
+    this.knowledgeBase = new KnowledgeBase(kbPath);
+  }
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    // Check if message has document attachment metadata
+    const meta = message.metadata;
+    if (!meta?.document) return this.noMatch();
+
+    const { content, filename, mimeType } = meta.document as {
+      content: string; filename: string; mimeType: string;
+    };
+
+    try {
+      const text = this.extractText(content, mimeType ?? this.guessMime(filename));
+      const chunks = this.chunk(text, 1000, 100);
+
+      const result = await this.knowledgeBase.addText(
+        chunks.map(c => c.content).join('\n\n---\n\n'),
+        filename
+      );
+
+      return this.match(
+        `📄 Processed "${filename}": ${chunks.length} chunks, ${text.length} chars → added to knowledge base (${result.chunks} KB entries)`
+      );
+    } catch (err) {
+      return this.match(`Document processing error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  extractText(content: string, mimeType: string): string {
+    // For plain text formats, content is already text
+    if (mimeType.includes('text/') || mimeType.includes('markdown')) {
+      return content;
+    }
+    // For other formats, assume base64-encoded or pre-extracted text
+    // In a real implementation, you'd use pdf-parse, mammoth, etc.
+    return content;
+  }
+
+  chunk(text: string, size: number = 1000, overlap: number = 100): DocumentChunk[] {
+    const chunks: DocumentChunk[] = [];
+    let start = 0;
+    while (start < text.length) {
+      const end = Math.min(start + size, text.length);
+      chunks.push({
+        content: text.slice(start, end),
+        metadata: {
+          filename: '',
+          mimeType: '',
+          chunkIndex: chunks.length,
+          totalChunks: 0, // filled after
+        },
+      });
+      start = end - overlap;
+      if (start >= text.length) break;
+    }
+    // Fill totalChunks
+    for (const c of chunks) c.metadata.totalChunks = chunks.length;
+    return chunks;
+  }
+
+  private guessMime(filename: string): string {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    switch (ext) {
+      case 'pdf': return 'application/pdf';
+      case 'txt': return 'text/plain';
+      case 'md': return 'text/markdown';
+      case 'docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+      default: return 'text/plain';
+    }
+  }
+
+  /** Process raw text content directly (for API uploads) */
+  async processText(content: string, filename: string): Promise<{ chunks: number; chars: number }> {
+    const chunks = this.chunk(content);
+    const result = await this.knowledgeBase.addText(content, filename);
+    return { chunks: chunks.length, chars: content.length };
+  }
+}

package/src/skills/http.ts

@@ -0,0 +1,35 @@
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export class HttpSkill extends BaseSkill {
+  name = 'http';
+  description = 'Make HTTP requests to external APIs. Usage: http GET|POST|PUT|DELETE <url> [body]';
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    const text = message.content.trim();
+    const match = text.match(/^http\s+(GET|POST|PUT|PATCH|DELETE)\s+(\S+)(?:\s+(.+))?$/is);
+    if (!match) return this.noMatch();
+
+    const [, method, url, bodyStr] = match;
+
+    try {
+      const opts: RequestInit = {
+        method: method.toUpperCase(),
+        headers: { 'Content-Type': 'application/json', 'User-Agent': 'OPC-Agent/0.7.0' },
+      };
+
+      if (bodyStr && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
+        opts.body = bodyStr;
+      }
+
+      const res = await fetch(url, opts);
+      const contentType = res.headers.get('content-type') ?? '';
+      const body = contentType.includes('json') ? JSON.stringify(await res.json(), null, 2) : await res.text();
+
+      const truncated = body.length > 4000 ? body.slice(0, 4000) + '\n...[truncated]' : body;
+      return this.match(`HTTP ${res.status} ${res.statusText}\n\n${truncated}`);
+    } catch (err) {
+      return this.match(`HTTP Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}

package/src/skills/scheduler.ts

@@ -0,0 +1,80 @@
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export interface ScheduledTask {
+  id: string;
+  name: string;
+  cronExpr: string;
+  action: string;
+  enabled: boolean;
+  lastRun?: number;
+  nextRun?: number;
+}
+
+export class SchedulerSkill extends BaseSkill {
+  name = 'scheduler';
+  description = 'Schedule recurring tasks. Usage: schedule list | schedule add <name> <cron> <action> | schedule remove <id>';
+  private tasks: Map<string, ScheduledTask> = new Map();
+  private timers: Map<string, NodeJS.Timeout> = new Map();
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    const text = message.content.trim();
+
+    if (/^schedule\s+list$/i.test(text)) {
+      if (this.tasks.size === 0) return this.match('No scheduled tasks.');
+      const lines = Array.from(this.tasks.values()).map(t =>
+        `• ${t.name} (${t.id}) — ${t.cronExpr} — ${t.enabled ? '✅' : '❌'} — Last: ${t.lastRun ? new Date(t.lastRun).toISOString() : 'never'}`
+      );
+      return this.match(`Scheduled tasks:\n${lines.join('\n')}`);
+    }
+
+    const addMatch = text.match(/^schedule\s+add\s+(\S+)\s+(".*?"|\S+)\s+(.+)$/i);
+    if (addMatch) {
+      const [, name, cronExpr, action] = addMatch;
+      const id = `task_${Date.now().toString(36)}`;
+      const task: ScheduledTask = {
+        id, name, cronExpr: cronExpr.replace(/"/g, ''), action, enabled: true,
+      };
+      this.tasks.set(id, task);
+      // Simple interval-based scheduling (parse cron for interval in minutes)
+      const intervalMs = this.parseCronToInterval(task.cronExpr);
+      if (intervalMs > 0) {
+        const timer = setInterval(() => {
+          task.lastRun = Date.now();
+        }, intervalMs);
+        this.timers.set(id, timer);
+      }
+      return this.match(`Task scheduled: ${name} (${id}) — ${task.cronExpr} → "${action}"`);
+    }
+
+    const rmMatch = text.match(/^schedule\s+remove\s+(\S+)$/i);
+    if (rmMatch) {
+      const id = rmMatch[1];
+      const timer = this.timers.get(id);
+      if (timer) clearInterval(timer);
+      this.timers.delete(id);
+      const removed = this.tasks.delete(id);
+      return this.match(removed ? `Task ${id} removed.` : `Task ${id} not found.`);
+    }
+
+    return this.noMatch();
+  }
+
+  private parseCronToInterval(expr: string): number {
+    // Simple: support "every Xm" or "every Xh" or basic intervals
+    const m = expr.match(/every\s+(\d+)\s*(m|min|h|hr|s|sec)/i);
+    if (m) {
+      const val = parseInt(m[1]);
+      const unit = m[2].toLowerCase();
+      if (unit.startsWith('h')) return val * 3600_000;
+      if (unit.startsWith('m')) return val * 60_000;
+      if (unit.startsWith('s')) return val * 1000;
+    }
+    return 0; // Unknown cron format, no auto-schedule
+  }
+
+  destroy(): void {
+    for (const timer of this.timers.values()) clearInterval(timer);
+    this.timers.clear();
+  }
+}

package/src/skills/webhook-trigger.ts

@@ -0,0 +1,59 @@
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export interface WebhookTarget {
+  name: string;
+  url: string;
+  method?: string;
+  headers?: Record<string, string>;
+  secret?: string;
+}
+
+export class WebhookTriggerSkill extends BaseSkill {
+  name = 'webhook-trigger';
+  description = 'Trigger external webhooks. Usage: webhook <name> [payload JSON]';
+  private targets: Map<string, WebhookTarget> = new Map();
+
+  registerTarget(target: WebhookTarget): void {
+    this.targets.set(target.name, target);
+  }
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    const match = message.content.trim().match(/^webhook\s+(\S+)(?:\s+(.+))?$/is);
+    if (!match) return this.noMatch();
+
+    const [, name, payloadStr] = match;
+    const target = this.targets.get(name);
+    if (!target) {
+      const available = Array.from(this.targets.keys()).join(', ') || 'none';
+      return this.match(`Unknown webhook "${name}". Available: ${available}`);
+    }
+
+    try {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        'User-Agent': 'OPC-Agent/0.7.0',
+        ...target.headers,
+      };
+      if (target.secret) {
+        headers['X-Webhook-Secret'] = target.secret;
+      }
+
+      const body = payloadStr ?? JSON.stringify({
+        agent: context.agentName,
+        timestamp: Date.now(),
+        trigger: 'manual',
+      });
+
+      const res = await fetch(target.url, {
+        method: target.method ?? 'POST',
+        headers,
+        body,
+      });
+
+      return this.match(`Webhook "${name}" triggered → ${res.status} ${res.statusText}`);
+    } catch (err) {
+      return this.match(`Webhook error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}

package/src/tools/calculator.ts

@@ -0,0 +1,73 @@
+import type { MCPTool, MCPToolResult } from './mcp';
+
+/**
+ * Calculator Tool — v0.8.0
+ * Safe math expression evaluation as an LLM function tool.
+ */
+export const CalculatorTool: MCPTool = {
+  name: 'calculator',
+  description: 'Evaluate a mathematical expression. Supports basic arithmetic, powers, sqrt, abs, min, max, round, ceil, floor, PI, E.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      expression: {
+        type: 'string',
+        description: 'Mathematical expression to evaluate, e.g. "2 + 3 * 4" or "sqrt(144) + PI"',
+      },
+    },
+    required: ['expression'],
+  },
+
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const expr = String(input.expression ?? '');
+    try {
+      const result = safeEval(expr);
+      return { content: String(result) };
+    } catch (err) {
+      return { content: `Error: ${(err as Error).message}`, isError: true };
+    }
+  },
+};
+
+/** Safe math evaluator — no eval(), no arbitrary code */
+function safeEval(expr: string): number {
+  // Whitelist: digits, operators, parens, dots, commas, spaces, and known functions
+  const sanitized = expr.replace(/\s+/g, '');
+  const allowed = /^[0-9+\-*/().,%^a-zA-Z_]+$/;
+  if (!allowed.test(sanitized)) {
+    throw new Error('Invalid characters in expression');
+  }
+
+  // Replace known math functions/constants
+  const prepared = sanitized
+    .replace(/\bPI\b/gi, String(Math.PI))
+    .replace(/\bE\b/g, String(Math.E))
+    .replace(/\bsqrt\b/gi, 'Math.sqrt')
+    .replace(/\babs\b/gi, 'Math.abs')
+    .replace(/\bmin\b/gi, 'Math.min')
+    .replace(/\bmax\b/gi, 'Math.max')
+    .replace(/\bround\b/gi, 'Math.round')
+    .replace(/\bceil\b/gi, 'Math.ceil')
+    .replace(/\bfloor\b/gi, 'Math.floor')
+    .replace(/\bpow\b/gi, 'Math.pow')
+    .replace(/\blog\b/gi, 'Math.log')
+    .replace(/\blog10\b/gi, 'Math.log10')
+    .replace(/\bsin\b/gi, 'Math.sin')
+    .replace(/\bcos\b/gi, 'Math.cos')
+    .replace(/\btan\b/gi, 'Math.tan')
+    .replace(/\^/g, '**');
+
+  // Block anything that isn't math
+  if (/[a-zA-Z_]/.test(prepared.replace(/Math\.\w+/g, ''))) {
+    throw new Error('Unsupported function or variable in expression');
+  }
+
+  // Use Function constructor with restricted scope
+  const fn = new Function('Math', `"use strict"; return (${prepared});`);
+  const result = fn(Math);
+
+  if (typeof result !== 'number' || !isFinite(result)) {
+    throw new Error('Expression did not evaluate to a finite number');
+  }
+  return result;
+}