opc-agent 2.0.2 → 3.0.0

package/src/core/collaboration.ts

@@ -0,0 +1,275 @@
+/**
+ * Multi-agent collaboration patterns
+ * @module core/collaboration
+ */
+
+import type { BaseAgent } from './agent';
+import type { Message } from './types';
+
+// ─── Result Types ───────────────────────────────────────────
+
+export interface DebateArgument {
+  agent: string;
+  round: number;
+  argument: string;
+}
+
+export interface DebateResult {
+  topic: string;
+  rounds: DebateArgument[];
+  summary: string;
+  judge?: string;
+}
+
+export interface VoteEntry {
+  agent: string;
+  choice: string;
+  confidence: number;
+}
+
+export interface VoteResult {
+  question: string;
+  votes: VoteEntry[];
+  winner: string;
+  tally: Record<string, number>;
+}
+
+export interface PipelineStageResult {
+  agent: string;
+  input: string;
+  output: string;
+  durationMs: number;
+}
+
+export interface PipelineResult {
+  stages: PipelineStageResult[];
+  finalOutput: string;
+  totalDurationMs: number;
+}
+
+export interface WorkerResult {
+  agent: string;
+  subtask: string;
+  result: string;
+}
+
+export interface HierarchyResult {
+  task: string;
+  subtasks: WorkerResult[];
+  synthesis: string;
+}
+
+// ─── Helper ─────────────────────────────────────────────────
+
+function makeMsg(role: 'user' | 'assistant' | 'system', content: string): Message {
+  return { id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, role, content, timestamp: Date.now() };
+}
+
+async function agentChat(agent: BaseAgent, prompt: string): Promise<string> {
+  const response = await agent.handleMessage(makeMsg('user', prompt));
+  return response.content;
+}
+
+// ─── DebatePattern ──────────────────────────────────────────
+
+export class DebatePattern {
+  constructor(private agents: BaseAgent[], private rounds: number = 3) {}
+
+  async debate(topic: string, judgeAgent?: BaseAgent): Promise<DebateResult> {
+    const allArgs: DebateArgument[] = [];
+    let context = '';
+
+    for (let round = 1; round <= this.rounds; round++) {
+      for (const agent of this.agents) {
+        const prompt = round === 1
+          ? `Debate topic: "${topic}". Present your argument.`
+          : `Debate topic: "${topic}". Previous arguments:\n${context}\nPresent your counter-argument for round ${round}.`;
+        const argument = await agentChat(agent, prompt);
+        allArgs.push({ agent: agent.name, round, argument });
+        context += `\n[${agent.name} round ${round}]: ${argument}`;
+      }
+    }
+
+    const judge = judgeAgent ?? this.agents[0];
+    const summaryPrompt = `You are the judge. Summarize and decide the winner of this debate on "${topic}":\n${context}`;
+    const summary = await agentChat(judge, summaryPrompt);
+
+    return { topic, rounds: allArgs, summary, judge: judge.name };
+  }
+}
+
+// ─── VotingPattern ──────────────────────────────────────────
+
+export class VotingPattern {
+  constructor(private agents: BaseAgent[]) {}
+
+  async vote(question: string, options: string[]): Promise<VoteResult> {
+    const votes: VoteEntry[] = [];
+    const optionList = options.map((o, i) => `${i + 1}. ${o}`).join('\n');
+
+    for (const agent of this.agents) {
+      const prompt = `Question: "${question}"\nOptions:\n${optionList}\nRespond with ONLY the exact text of your chosen option.`;
+      const raw = await agentChat(agent, prompt);
+      const choice = options.find(o => raw.includes(o)) ?? raw.trim();
+      votes.push({ agent: agent.name, choice, confidence: 1 });
+    }
+
+    return this.tallyVotes(question, votes);
+  }
+
+  async weightedVote(question: string, options: string[]): Promise<VoteResult> {
+    const votes: VoteEntry[] = [];
+    const optionList = options.map((o, i) => `${i + 1}. ${o}`).join('\n');
+
+    for (const agent of this.agents) {
+      const prompt = `Question: "${question}"\nOptions:\n${optionList}\nRespond in format: CHOICE|CONFIDENCE(0-1)`;
+      const raw = await agentChat(agent, prompt);
+      const parts = raw.split('|');
+      const choiceRaw = parts[0]?.trim() ?? '';
+      const choice = options.find(o => choiceRaw.includes(o)) ?? choiceRaw;
+      const confidence = Math.min(1, Math.max(0, parseFloat(parts[1] ?? '0.5') || 0.5));
+      votes.push({ agent: agent.name, choice, confidence });
+    }
+
+    return this.tallyVotes(question, votes);
+  }
+
+  private tallyVotes(question: string, votes: VoteEntry[]): VoteResult {
+    const tally: Record<string, number> = {};
+    for (const v of votes) {
+      tally[v.choice] = (tally[v.choice] ?? 0) + v.confidence;
+    }
+    const winner = Object.entries(tally).sort((a, b) => b[1] - a[1])[0]?.[0] ?? '';
+    return { question, votes, winner, tally };
+  }
+}
+
+// ─── PipelinePattern ────────────────────────────────────────
+
+export class PipelinePattern {
+  constructor(private stages: { agent: BaseAgent; transform?: (input: string) => string }[]) {}
+
+  async process(input: string): Promise<PipelineResult> {
+    const stageResults: PipelineStageResult[] = [];
+    let current = input;
+    const t0 = Date.now();
+
+    for (const stage of this.stages) {
+      const stageInput = stage.transform ? stage.transform(current) : current;
+      const start = Date.now();
+      const output = await agentChat(stage.agent, stageInput);
+      stageResults.push({ agent: stage.agent.name, input: stageInput, output, durationMs: Date.now() - start });
+      current = output;
+    }
+
+    return { stages: stageResults, finalOutput: current, totalDurationMs: Date.now() - t0 };
+  }
+}
+
+// ─── HierarchyPattern ───────────────────────────────────────
+
+export class HierarchyPattern {
+  constructor(private leader: BaseAgent, private workers: BaseAgent[]) {}
+
+  async execute(task: string): Promise<HierarchyResult> {
+    // Leader decomposes
+    const decomposePrompt = `Decompose this task into ${this.workers.length} subtasks (one per line, no numbering): "${task}"`;
+    const decomposition = await agentChat(this.leader, decomposePrompt);
+    const subtasks = decomposition.split('\n').map(s => s.trim()).filter(Boolean);
+
+    // Workers execute in parallel
+    const workerResults: WorkerResult[] = await Promise.all(
+      this.workers.map(async (worker, i) => {
+        const subtask = subtasks[i] ?? subtasks[subtasks.length - 1] ?? task;
+        const result = await agentChat(worker, `Complete this subtask: "${subtask}"`);
+        return { agent: worker.name, subtask, result };
+      })
+    );
+
+    // Leader synthesizes
+    const synthPrompt = `Original task: "${task}"\nSubtask results:\n${workerResults.map(r => `[${r.agent}] ${r.subtask}: ${r.result}`).join('\n')}\nSynthesize a final answer.`;
+    const synthesis = await agentChat(this.leader, synthPrompt);
+
+    return { task, subtasks: workerResults, synthesis };
+  }
+}
+
+// ─── SharedContext ───────────────────────────────────────────
+
+export class SharedContext {
+  private store: Map<string, any> = new Map();
+  private listeners: Map<string, ((value: any) => void)[]> = new Map();
+
+  set(key: string, value: any): void {
+    this.store.set(key, value);
+    const cbs = this.listeners.get(key);
+    if (cbs) cbs.forEach(cb => cb(value));
+  }
+
+  get<T>(key: string): T | undefined {
+    return this.store.get(key) as T | undefined;
+  }
+
+  getAll(): Record<string, any> {
+    const result: Record<string, any> = {};
+    for (const [k, v] of this.store) result[k] = v;
+    return result;
+  }
+
+  onChange(key: string, callback: (value: any) => void): void {
+    const existing = this.listeners.get(key) ?? [];
+    existing.push(callback);
+    this.listeners.set(key, existing);
+  }
+}
+
+// ─── ConversationProtocol ───────────────────────────────────
+
+export class ConversationProtocol {
+  async roundRobin(agents: BaseAgent[], topic: string, rounds: number): Promise<Message[]> {
+    const messages: Message[] = [];
+    let context = `Topic: "${topic}"`;
+
+    for (let round = 0; round < rounds; round++) {
+      for (const agent of agents) {
+        const prompt = `${context}\n\nIt's your turn to contribute to this discussion. Be concise.`;
+        const content = await agentChat(agent, prompt);
+        const msg = makeMsg('assistant', content);
+        (msg as any).agent = agent.name;
+        messages.push(msg);
+        context += `\n[${agent.name}]: ${content}`;
+      }
+    }
+
+    return messages;
+  }
+
+  async moderated(agents: BaseAgent[], moderator: BaseAgent, topic: string): Promise<Message[]> {
+    const messages: Message[] = [];
+    let context = `Topic: "${topic}"`;
+
+    // Moderator opens
+    const opening = await agentChat(moderator, `You are moderating a discussion on "${topic}". Introduce the topic and ask the first question.`);
+    const openMsg = makeMsg('assistant', opening);
+    (openMsg as any).agent = moderator.name;
+    messages.push(openMsg);
+    context += `\n[Moderator ${moderator.name}]: ${opening}`;
+
+    // Each agent responds
+    for (const agent of agents) {
+      const content = await agentChat(agent, `${context}\n\nRespond to the moderator's question.`);
+      const msg = makeMsg('assistant', content);
+      (msg as any).agent = agent.name;
+      messages.push(msg);
+      context += `\n[${agent.name}]: ${content}`;
+    }
+
+    // Moderator summarizes
+    const summary = await agentChat(moderator, `${context}\n\nSummarize the discussion and provide closing remarks.`);
+    const closeMsg = makeMsg('assistant', summary);
+    (closeMsg as any).agent = moderator.name;
+    messages.push(closeMsg);
+
+    return messages;
+  }
+}

package/src/deploy/index.ts

@@ -0,0 +1,255 @@
+/**
+ * AgentDeployer - Deploy agents to Docker, Railway, Fly.io
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+export interface DeployOptions {
+  port?: number;
+  env?: Record<string, string>;
+  platform?: 'docker' | 'railway' | 'fly' | 'render';
+  replicas?: number;
+}
+
+export interface DeployResult {
+  platform: string;
+  success: boolean;
+  url?: string;
+  message: string;
+  files?: string[];
+}
+
+export class AgentDeployer {
+  /**
+   * Generate Dockerfile for the agent
+   */
+  async generateDockerfile(agentDir: string, options?: DeployOptions): Promise<string> {
+    const port = options?.port || 3000;
+    const pkgPath = path.join(agentDir, 'package.json');
+    let startCmd = 'node src/index.js';
+    
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        if (pkg.scripts?.start) {
+          startCmd = pkg.scripts.start;
+        }
+        if (pkg.main) {
+          startCmd = `node ${pkg.main}`;
+        }
+      } catch {}
+    }
+
+    return `FROM node:22-slim
+WORKDIR /app
+
+# Install dependencies
+COPY package*.json ./
+RUN npm ci --production
+
+# Copy source
+COPY . .
+
+# Build if needed
+RUN if [ -f "tsconfig.json" ]; then npx tsc || true; fi
+
+EXPOSE ${port}
+
+ENV NODE_ENV=production
+ENV PORT=${port}
+
+CMD ["${startCmd.split(' ')[0]}", ${startCmd.split(' ').slice(1).map(s => `"${s}"`).join(', ')}]
+`;
+  }
+
+  /**
+   * Generate docker-compose.yml
+   */
+  async generateCompose(agentDir: string, options?: DeployOptions): Promise<string> {
+    const port = options?.port || 3000;
+    const replicas = options?.replicas || 1;
+    const agentName = path.basename(agentDir).toLowerCase().replace(/[^a-z0-9-]/g, '-') || 'opc-agent';
+    
+    const envLines = options?.env 
+      ? Object.entries(options.env).map(([k, v]) => `      - ${k}=${v}`).join('\n')
+      : '';
+
+    return `version: "3.8"
+
+services:
+  ${agentName}:
+    build: .
+    ports:
+      - "${port}:${port}"
+    environment:
+      - NODE_ENV=production
+      - PORT=${port}
+${envLines ? envLines + '\n' : ''}    restart: unless-stopped
+${replicas > 1 ? `    deploy:\n      replicas: ${replicas}` : ''}
+    volumes:
+      - agent-data:/app/data
+
+volumes:
+  agent-data:
+`;
+  }
+
+  /**
+   * Deploy to Railway (via CLI)
+   */
+  async deployRailway(agentDir: string): Promise<DeployResult> {
+    try {
+      execSync('railway version', { stdio: 'pipe' });
+    } catch {
+      return { platform: 'railway', success: false, message: 'Railway CLI not installed. Run: npm i -g @railway/cli' };
+    }
+
+    try {
+      // Ensure Dockerfile exists
+      const dockerfilePath = path.join(agentDir, 'Dockerfile');
+      if (!fs.existsSync(dockerfilePath)) {
+        const content = await this.generateDockerfile(agentDir);
+        fs.writeFileSync(dockerfilePath, content);
+      }
+
+      const output = execSync('railway up --detach', { cwd: agentDir, encoding: 'utf-8' });
+      const urlMatch = output.match(/(https:\/\/[^\s]+)/);
+      return { 
+        platform: 'railway', 
+        success: true, 
+        url: urlMatch?.[1],
+        message: 'Deployed to Railway successfully' 
+      };
+    } catch (e: any) {
+      return { platform: 'railway', success: false, message: e.message };
+    }
+  }
+
+  /**
+   * Deploy to Fly.io
+   */
+  async deployFly(agentDir: string): Promise<DeployResult> {
+    try {
+      execSync('fly version', { stdio: 'pipe' });
+    } catch {
+      return { platform: 'fly', success: false, message: 'Fly CLI not installed. Run: curl -L https://fly.io/install.sh | sh' };
+    }
+
+    try {
+      const agentName = path.basename(agentDir).toLowerCase().replace(/[^a-z0-9-]/g, '-');
+      
+      // Generate fly.toml if not exists
+      const flyTomlPath = path.join(agentDir, 'fly.toml');
+      if (!fs.existsSync(flyTomlPath)) {
+        fs.writeFileSync(flyTomlPath, `app = "${agentName}"
+primary_region = "sjc"
+
+[build]
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+
+[checks]
+  [checks.alive]
+    type = "tcp"
+    port = 3000
+`);
+      }
+
+      // Ensure Dockerfile exists
+      const dockerfilePath = path.join(agentDir, 'Dockerfile');
+      if (!fs.existsSync(dockerfilePath)) {
+        const content = await this.generateDockerfile(agentDir);
+        fs.writeFileSync(dockerfilePath, content);
+      }
+
+      const output = execSync('fly deploy', { cwd: agentDir, encoding: 'utf-8' });
+      return { 
+        platform: 'fly', 
+        success: true, 
+        url: `https://${agentName}.fly.dev`,
+        message: 'Deployed to Fly.io successfully' 
+      };
+    } catch (e: any) {
+      return { platform: 'fly', success: false, message: e.message };
+    }
+  }
+
+  /**
+   * Deploy locally via Docker
+   */
+  async deployLocal(agentDir: string, options?: DeployOptions): Promise<DeployResult> {
+    try {
+      execSync('docker version', { stdio: 'pipe' });
+    } catch {
+      return { platform: 'docker', success: false, message: 'Docker not installed or not running' };
+    }
+
+    const files: string[] = [];
+
+    // Generate Dockerfile
+    const dockerfilePath = path.join(agentDir, 'Dockerfile');
+    if (!fs.existsSync(dockerfilePath)) {
+      fs.writeFileSync(dockerfilePath, await this.generateDockerfile(agentDir, options));
+      files.push('Dockerfile');
+    }
+
+    // Generate docker-compose.yml
+    const composePath = path.join(agentDir, 'docker-compose.yml');
+    if (!fs.existsSync(composePath)) {
+      fs.writeFileSync(composePath, await this.generateCompose(agentDir, options));
+      files.push('docker-compose.yml');
+    }
+
+    try {
+      execSync('docker compose up -d --build', { cwd: agentDir, stdio: 'inherit' });
+      const port = options?.port || 3000;
+      return { 
+        platform: 'docker', 
+        success: true, 
+        url: `http://localhost:${port}`,
+        message: 'Running locally via Docker',
+        files 
+      };
+    } catch (e: any) {
+      return { platform: 'docker', success: false, message: e.message, files };
+    }
+  }
+
+  /**
+   * Generate deployment files without deploying
+   */
+  async generateFiles(agentDir: string, options?: DeployOptions): Promise<DeployResult> {
+    const files: string[] = [];
+    const port = options?.port || 3000;
+
+    const dockerfile = await this.generateDockerfile(agentDir, options);
+    fs.writeFileSync(path.join(agentDir, 'Dockerfile'), dockerfile);
+    files.push('Dockerfile');
+
+    const compose = await this.generateCompose(agentDir, options);
+    fs.writeFileSync(path.join(agentDir, 'docker-compose.yml'), compose);
+    files.push('docker-compose.yml');
+
+    // Generate .dockerignore
+    const dockerignore = `node_modules
+.git
+.env
+*.log
+dist
+`;
+    fs.writeFileSync(path.join(agentDir, '.dockerignore'), dockerignore);
+    files.push('.dockerignore');
+
+    return {
+      platform: 'docker',
+      success: true,
+      message: `Generated ${files.length} deployment files`,
+      files,
+    };
+  }
+}

package/src/index.ts

@@ -40,7 +40,8 @@ export type { A2ARequest, A2AResponse, AgentCapability, AgentRegistration, Agent
 export { HITLManager } from './core/hitl';
 export type { ApprovalRequest, ApprovalResponse, HITLConfig } from './core/hitl';
 export { VoiceChannel } from './channels/voice';
-export type { VoiceChannelConfig, STTProvider, TTSProvider } from './channels/voice';
+export type { VoiceChannelConfig, STTProvider, TTSProvider, VoiceConfig } from './channels/voice';
+export { WhisperSTTProvider, DeepgramSTTProvider, EdgeTTSProvider, OpenAITTSProvider, ElevenLabsTTSProvider, createVoiceProviders } from './channels/voice';
 export { WebhookChannel } from './channels/webhook';
 export type { WebhookConfig, WebhookPayload } from './channels/webhook';
 export { VersionManager } from './core/versioning';
@@ -106,6 +107,10 @@ export { loggerPlugin } from './plugins/logger';
 export { rateLimiterPlugin, createRateLimiterPlugin as createEnhancedRateLimiterPlugin } from './plugins/rate-limiter';
 export { contentFilterPlugin, createContentFilterPlugin } from './plugins/content-filter';
 
+// v2.1.0 — Guardrails
+export { GuardrailManager, createGuardrailsFromConfig } from './security/guardrails';
+export type { GuardrailConfig, GuardrailRule, GuardrailResult, GuardrailViolation } from './security/guardrails';
+
 // v1.1.0 modules
 export { FeishuChannel } from './channels/feishu';
 export type { FeishuChannelConfig } from './channels/feishu';
@@ -168,6 +173,10 @@ export type { EvalCase, EvalResult, EvalSuite, EvalReport } from './eval';
 // v1.9.0 — AG-UI Protocol (Agent-User Interaction)
 export { AGUIServer, AGUIEventEmitter, AGUIClient } from './protocols/agui';
 export { AGUI_EVENT_TYPES, isValidEventType } from './protocols/agui';
+// v2.0.0 - Multi-agent collaboration patterns
+export { DebatePattern, VotingPattern, PipelinePattern, HierarchyPattern, SharedContext, ConversationProtocol } from './core/collaboration';
+export type { DebateResult, DebateArgument, VoteResult, VoteEntry, PipelineResult, PipelineStageResult, HierarchyResult, WorkerResult } from './core/collaboration';
+
 export type {
   AGUIEvent, AGUIEventType, AGUIMessage, AGUIRunRequest, AGUIToolCall,
   AGUIToolDefinition, TextMessageStartEvent, TextMessageContentEvent,
@@ -176,3 +185,14 @@ export type {
   RunStartedEvent, RunFinishedEvent, RunErrorEvent,
   StepStartedEvent, StepFinishedEvent, CustomEvent,
 } from './protocols/agui';
+
+// v2.0.0 - Pre-built tool integrations (20 tools)
+export {
+  SlackTool, EmailSendTool, WebhookTool,
+  NotionTool, GitHubTool, JiraTool, CalendarTool, TrelloTool,
+  WebSearchTool, WebScraperTool, DatabaseTool, VectorSearchTool,
+  CodeExecutionTool, GitTool, NpmTool,
+  ImageGenerationTool, PDFReaderTool, CSVAnalyzerTool,
+  SummarizerTool, TranslatorTool,
+  getAllIntegrationTools, getIntegrationTool,
+} from './tools/integrations';

package/src/mcp/servers/calculator-mcp.ts

@@ -0,0 +1,65 @@
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+const UNITS: Record<string, Record<string, number>> = {
+  length: { m: 1, km: 1000, cm: 0.01, mm: 0.001, in: 0.0254, ft: 0.3048, yd: 0.9144, mi: 1609.344 },
+  weight: { kg: 1, g: 0.001, mg: 0.000001, lb: 0.453592, oz: 0.0283495, ton: 1000 },
+  temperature: {}, // special
+};
+
+function convertTemp(value: number, from: string, to: string): number {
+  let celsius = from === 'C' ? value : from === 'F' ? (value - 32) * 5/9 : value - 273.15;
+  return to === 'C' ? celsius : to === 'F' ? celsius * 9/5 + 32 : celsius + 273.15;
+}
+
+export function createCalculatorServer(): MCPServerConfig {
+  return {
+    name: 'calculator',
+    version: '1.0.0',
+    tools: [
+      {
+        name: 'calc_evaluate',
+        description: 'Evaluate a mathematical expression (safe eval with Math functions)',
+        inputSchema: { type: 'object', properties: { expression: { type: 'string', description: 'Math expression, e.g. "sqrt(16) + pow(2,3)"' } }, required: ['expression'] },
+        handler: async (args: { expression: string }) => {
+          const safe = args.expression.replace(/[^0-9+\-*/().,%\s]/g, (m) => {
+            const allowed = ['Math','PI','E','sqrt','pow','abs','sin','cos','tan','log','log2','log10','ceil','floor','round','min','max','random'];
+            return allowed.some(a => m.includes(a)) ? m : '';
+          });
+          const fn = new Function('Math', `"use strict"; return (${args.expression})`);
+          const result = fn(Math);
+          return { expression: args.expression, result };
+        },
+      },
+      {
+        name: 'calc_convert',
+        description: 'Convert between units (length, weight, temperature)',
+        inputSchema: { type: 'object', properties: { value: { type: 'number' }, from: { type: 'string' }, to: { type: 'string' }, category: { type: 'string', enum: ['length', 'weight', 'temperature'] } }, required: ['value', 'from', 'to'] },
+        handler: async (args: { value: number; from: string; to: string; category?: string }) => {
+          if (['C', 'F', 'K'].includes(args.from) && ['C', 'F', 'K'].includes(args.to)) {
+            return { value: args.value, from: args.from, to: args.to, result: convertTemp(args.value, args.from, args.to) };
+          }
+          for (const [, units] of Object.entries(UNITS)) {
+            if (units[args.from] && units[args.to]) {
+              const base = args.value * units[args.from];
+              return { value: args.value, from: args.from, to: args.to, result: base / units[args.to] };
+            }
+          }
+          throw new Error(`Cannot convert ${args.from} to ${args.to}`);
+        },
+      },
+      {
+        name: 'calc_percentage',
+        description: 'Calculate percentages: what is X% of Y, X is what % of Y, % change',
+        inputSchema: { type: 'object', properties: { operation: { type: 'string', enum: ['of', 'is_what_percent', 'change'] }, x: { type: 'number' }, y: { type: 'number' } }, required: ['operation', 'x', 'y'] },
+        handler: async (args: { operation: string; x: number; y: number }) => {
+          switch (args.operation) {
+            case 'of': return { result: (args.x / 100) * args.y, description: `${args.x}% of ${args.y}` };
+            case 'is_what_percent': return { result: (args.x / args.y) * 100, description: `${args.x} is ${((args.x / args.y) * 100).toFixed(2)}% of ${args.y}` };
+            case 'change': return { result: ((args.y - args.x) / args.x) * 100, description: `Change from ${args.x} to ${args.y}` };
+            default: throw new Error('Unknown operation');
+          }
+        },
+      },
+    ],
+  };
+}