opc-agent 4.1.2 → 4.1.3

package/src/tools/integrations/web-scraper.ts

@@ -1,47 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const WebScraperTool: MCPTool = {
-  name: 'web-scraper',
-  description: 'Fetch and extract readable content from a URL.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      url: { type: 'string', description: 'URL to scrape' },
-      max_length: { type: 'number', description: 'Max characters to return (default: 5000)' },
-    },
-    required: ['url'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const url = String(input.url ?? '');
-    if (!url) return { content: 'Error: url required', isError: true };
-    const maxLen = Number(input.max_length ?? 5000);
-
-    try {
-      const res = await fetch(url, {
-        headers: { 'User-Agent': 'Mozilla/5.0 (compatible; OPCAgent/1.0)' },
-      });
-      if (!res.ok) return { content: `HTTP ${res.status}: ${res.statusText}`, isError: true };
-
-      const html = await res.text();
-      // Simple HTML to text extraction
-      const text = html
-        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
-        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
-        .replace(/<[^>]+>/g, ' ')
-        .replace(/&nbsp;/g, ' ')
-        .replace(/&amp;/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/\s+/g, ' ')
-        .trim();
-
-      const truncated = text.length > maxLen ? text.slice(0, maxLen) + '...(truncated)' : text;
-      return { content: truncated, metadata: { url, length: text.length } };
-    } catch (err) {
-      return { content: `Scraper error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};

package/src/tools/integrations/web-search.ts

@@ -1,58 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const WebSearchTool: MCPTool = {
-  name: 'web-search',
-  description: 'Search the web using SerpAPI, Tavily, or Brave Search. Requires SERPAPI_KEY, TAVILY_API_KEY, or BRAVE_SEARCH_KEY env var.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      query: { type: 'string', description: 'Search query' },
-      provider: { type: 'string', enum: ['serpapi', 'tavily', 'brave'], description: 'Search provider (auto-detects from env)' },
-      count: { type: 'number', description: 'Number of results (default: 5)' },
-    },
-    required: ['query'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const query = String(input.query ?? '');
-    if (!query) return { content: 'Error: query required', isError: true };
-    const count = Number(input.count ?? 5);
-
-    try {
-      const provider = String(input.provider ?? '');
-      if (provider === 'tavily' || process.env.TAVILY_API_KEY) {
-        const key = process.env.TAVILY_API_KEY;
-        if (!key) return { content: 'Error: TAVILY_API_KEY required', isError: true };
-        const res = await fetch('https://api.tavily.com/search', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ api_key: key, query, max_results: count }),
-        });
-        const data = await res.json() as Record<string, unknown>;
-        return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
-      }
-
-      if (provider === 'brave' || process.env.BRAVE_SEARCH_KEY) {
-        const key = process.env.BRAVE_SEARCH_KEY;
-        if (!key) return { content: 'Error: BRAVE_SEARCH_KEY required', isError: true };
-        const res = await fetch(`https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${count}`, {
-          headers: { 'X-Subscription-Token': key, 'Accept': 'application/json' },
-        });
-        const data = await res.json() as Record<string, unknown>;
-        return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
-      }
-
-      if (provider === 'serpapi' || process.env.SERPAPI_KEY) {
-        const key = process.env.SERPAPI_KEY;
-        if (!key) return { content: 'Error: SERPAPI_KEY required', isError: true };
-        const res = await fetch(`https://serpapi.com/search.json?q=${encodeURIComponent(query)}&num=${count}&api_key=${key}`);
-        const data = await res.json() as Record<string, unknown>;
-        return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
-      }
-
-      return { content: 'Error: No search API key configured (TAVILY_API_KEY, BRAVE_SEARCH_KEY, or SERPAPI_KEY)', isError: true };
-    } catch (err) {
-      return { content: `Search error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};

package/src/tools/integrations/webhook.ts

@@ -1,38 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const WebhookTool: MCPTool = {
-  name: 'webhook',
-  description: 'Send HTTP requests to arbitrary webhook URLs. Supports POST and GET.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      url: { type: 'string', description: 'Webhook URL' },
-      method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'], description: 'HTTP method (default: POST)' },
-      headers: { type: 'object', description: 'Custom headers as key-value pairs' },
-      body: { type: 'string', description: 'Request body (JSON string)' },
-    },
-    required: ['url'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const url = String(input.url ?? '');
-    if (!url) return { content: 'Error: url is required', isError: true };
-
-    const method = String(input.method ?? 'POST').toUpperCase();
-    const customHeaders = (input.headers ?? {}) as Record<string, string>;
-    const headers: Record<string, string> = { 'Content-Type': 'application/json', ...customHeaders };
-
-    try {
-      const opts: RequestInit = { method, headers };
-      if (method !== 'GET' && method !== 'HEAD' && input.body) {
-        opts.body = String(input.body);
-      }
-      const res = await fetch(url, opts);
-      const text = await res.text();
-      const truncated = text.length > 4000 ? text.slice(0, 4000) + '...(truncated)' : text;
-      return { content: `Status: ${res.status}\n${truncated}`, metadata: { status: res.status } };
-    } catch (err) {
-      return { content: `Webhook error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};

package/src/tools/json-transform.ts

@@ -1,187 +0,0 @@
-import type { MCPTool, MCPToolResult } from './mcp';
-
-/**
- * JSON Transform Tool — v0.8.0
- * Parse, query, and transform JSON data as an LLM function tool.
- */
-export const JsonTransformTool: MCPTool = {
-  name: 'json_transform',
-  description: 'Parse, query (JSONPath-like), transform, flatten, or merge JSON data.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      operation: {
-        type: 'string',
-        enum: ['parse', 'query', 'flatten', 'unflatten', 'merge', 'pick', 'omit', 'sort', 'filter', 'map_keys'],
-        description: 'Operation to perform on the JSON data',
-      },
-      data: {
-        description: 'JSON string or object to operate on',
-      },
-      data2: {
-        description: 'Second JSON for merge operation',
-      },
-      path: {
-        type: 'string',
-        description: 'Dot-notation path for query (e.g. "users.0.name")',
-      },
-      keys: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Keys for pick/omit operations',
-      },
-      sortBy: {
-        type: 'string',
-        description: 'Key to sort array by',
-      },
-      order: {
-        type: 'string',
-        enum: ['asc', 'desc'],
-      },
-      filterKey: {
-        type: 'string',
-        description: 'Key to filter by',
-      },
-      filterValue: {
-        description: 'Value to match for filter',
-      },
-    },
-    required: ['operation', 'data'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    try {
-      const op = String(input.operation);
-      const data = typeof input.data === 'string' ? JSON.parse(input.data) : input.data;
-
-      switch (op) {
-        case 'parse':
-          return { content: JSON.stringify(data, null, 2) };
-
-        case 'query': {
-          const path = String(input.path ?? '');
-          const result = getByPath(data, path);
-          return { content: JSON.stringify(result, null, 2) };
-        }
-
-        case 'flatten':
-          return { content: JSON.stringify(flatten(data), null, 2) };
-
-        case 'unflatten':
-          return { content: JSON.stringify(unflatten(data as Record<string, unknown>), null, 2) };
-
-        case 'merge': {
-          const data2 = typeof input.data2 === 'string' ? JSON.parse(input.data2) : input.data2;
-          return { content: JSON.stringify(deepMerge(data, data2), null, 2) };
-        }
-
-        case 'pick': {
-          const keys = input.keys as string[] ?? [];
-          const result: Record<string, unknown> = {};
-          for (const k of keys) {
-            if (k in data) result[k] = data[k];
-          }
-          return { content: JSON.stringify(result, null, 2) };
-        }
-
-        case 'omit': {
-          const keys = new Set(input.keys as string[] ?? []);
-          const result: Record<string, unknown> = {};
-          for (const [k, v] of Object.entries(data)) {
-            if (!keys.has(k)) result[k] = v;
-          }
-          return { content: JSON.stringify(result, null, 2) };
-        }
-
-        case 'sort': {
-          if (!Array.isArray(data)) return { content: 'Data must be an array for sort', isError: true };
-          const sortBy = String(input.sortBy ?? '');
-          const order = input.order === 'desc' ? -1 : 1;
-          const sorted = [...data].sort((a, b) => {
-            const va = sortBy ? a[sortBy] : a;
-            const vb = sortBy ? b[sortBy] : b;
-            return va < vb ? -order : va > vb ? order : 0;
-          });
-          return { content: JSON.stringify(sorted, null, 2) };
-        }
-
-        case 'filter': {
-          if (!Array.isArray(data)) return { content: 'Data must be an array for filter', isError: true };
-          const fk = String(input.filterKey ?? '');
-          const fv = input.filterValue;
-          const filtered = data.filter((item) => item[fk] === fv);
-          return { content: JSON.stringify(filtered, null, 2) };
-        }
-
-        case 'map_keys': {
-          // Rename keys: path is "old:new,old2:new2"
-          const mapping = String(input.path ?? '').split(',').reduce((acc, pair) => {
-            const [old, nw] = pair.split(':');
-            if (old && nw) acc[old.trim()] = nw.trim();
-            return acc;
-          }, {} as Record<string, string>);
-          const result: Record<string, unknown> = {};
-          for (const [k, v] of Object.entries(data)) {
-            result[mapping[k] ?? k] = v;
-          }
-          return { content: JSON.stringify(result, null, 2) };
-        }
-
-        default:
-          return { content: `Unknown operation: ${op}`, isError: true };
-      }
-    } catch (err) {
-      return { content: `Error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};
-
-function getByPath(obj: unknown, path: string): unknown {
-  return path.split('.').reduce((curr: any, key) => {
-    if (curr == null) return undefined;
-    const idx = Number(key);
-    return Number.isInteger(idx) && Array.isArray(curr) ? curr[idx] : curr[key];
-  }, obj);
-}
-
-function flatten(obj: unknown, prefix = ''): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-  if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
-    for (const [k, v] of Object.entries(obj)) {
-      const key = prefix ? `${prefix}.${k}` : k;
-      if (v && typeof v === 'object' && !Array.isArray(v)) {
-        Object.assign(result, flatten(v, key));
-      } else {
-        result[key] = v;
-      }
-    }
-  }
-  return result;
-}
-
-function unflatten(obj: Record<string, unknown>): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const parts = key.split('.');
-    let curr: any = result;
-    for (let i = 0; i < parts.length - 1; i++) {
-      if (!(parts[i] in curr)) curr[parts[i]] = {};
-      curr = curr[parts[i]];
-    }
-    curr[parts[parts.length - 1]] = value;
-  }
-  return result;
-}
-
-function deepMerge(a: any, b: any): any {
-  if (!b) return a;
-  const result = { ...a };
-  for (const [k, v] of Object.entries(b)) {
-    if (v && typeof v === 'object' && !Array.isArray(v) && result[k] && typeof result[k] === 'object') {
-      result[k] = deepMerge(result[k], v);
-    } else {
-      result[k] = v;
-    }
-  }
-  return result;
-}

package/src/tools/mcp-client.ts

@@ -1,131 +0,0 @@
-import { spawn, type ChildProcess } from 'child_process';
-import type { MCPToolDefinition, MCPToolResult } from './mcp';
-
-export interface MCPServerConfig {
-  name: string;
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-}
-
-export class MCPClient {
-  private process: ChildProcess | null = null;
-  private config: MCPServerConfig | null = null;
-  private nextId = 1;
-  private pending = new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>();
-  private buffer = '';
-  private connected = false;
-
-  async connect(config: MCPServerConfig): Promise<void> {
-    this.config = config;
-    this.process = spawn(config.command, config.args ?? [], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env, ...config.env },
-    });
-
-    this.process.stdout!.on('data', (data: Buffer) => {
-      this.buffer += data.toString();
-      this.processBuffer();
-    });
-
-    this.process.on('error', (err) => {
-      for (const [, p] of this.pending) p.reject(err);
-      this.pending.clear();
-    });
-
-    this.process.on('exit', () => {
-      this.connected = false;
-      for (const [, p] of this.pending) p.reject(new Error('MCP server exited'));
-      this.pending.clear();
-    });
-
-    // Send initialize
-    await this.sendRequest('initialize', {
-      protocolVersion: '2024-11-05',
-      capabilities: {},
-      clientInfo: { name: 'opc-agent', version: '0.7.0' },
-    });
-
-    // Send initialized notification
-    this.sendNotification('notifications/initialized', {});
-    this.connected = true;
-  }
-
-  private processBuffer(): void {
-    const lines = this.buffer.split('\n');
-    this.buffer = lines.pop() ?? '';
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        const msg = JSON.parse(trimmed);
-        if (msg.id !== undefined && this.pending.has(msg.id)) {
-          const p = this.pending.get(msg.id)!;
-          this.pending.delete(msg.id);
-          if (msg.error) {
-            p.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
-          } else {
-            p.resolve(msg.result);
-          }
-        }
-      } catch { /* skip non-JSON lines */ }
-    }
-  }
-
-  private sendRequest(method: string, params?: Record<string, unknown>): Promise<any> {
-    return new Promise((resolve, reject) => {
-      if (!this.process?.stdin?.writable) {
-        reject(new Error('MCP server not connected'));
-        return;
-      }
-      const id = this.nextId++;
-      this.pending.set(id, { resolve, reject });
-      const msg = JSON.stringify({ jsonrpc: '2.0', method, params: params ?? {}, id });
-      this.process.stdin.write(msg + '\n');
-
-      // Timeout after 30s
-      setTimeout(() => {
-        if (this.pending.has(id)) {
-          this.pending.delete(id);
-          reject(new Error(`MCP request timed out: ${method}`));
-        }
-      }, 30000);
-    });
-  }
-
-  private sendNotification(method: string, params: Record<string, unknown>): void {
-    if (!this.process?.stdin?.writable) return;
-    const msg = JSON.stringify({ jsonrpc: '2.0', method, params });
-    this.process.stdin.write(msg + '\n');
-  }
-
-  async listTools(): Promise<MCPToolDefinition[]> {
-    const result = await this.sendRequest('tools/list');
-    return (result.tools ?? []).map((t: any) => ({
-      name: t.name,
-      description: t.description ?? '',
-      inputSchema: t.inputSchema ?? {},
-    }));
-  }
-
-  async callTool(name: string, input: Record<string, unknown>): Promise<MCPToolResult> {
-    const result = await this.sendRequest('tools/call', { name, arguments: input });
-    const content = (result.content ?? [])
-      .map((c: any) => c.text ?? JSON.stringify(c))
-      .join('\n');
-    return { content, isError: result.isError ?? false };
-  }
-
-  async disconnect(): Promise<void> {
-    if (this.process) {
-      this.process.kill();
-      this.process = null;
-    }
-    this.connected = false;
-    this.pending.clear();
-  }
-
-  isConnected(): boolean {
-    return this.connected;
-  }
-}

package/src/tools/mcp.ts

@@ -1,76 +0,0 @@
-import type { AgentContext, Message } from '../core/types';
-
-/**
- * MCP (Model Context Protocol) compatible tool interface.
- * Tools follow the MCP standard format with JSON Schema input validation.
- */
-export interface MCPToolDefinition {
-  name: string;
-  description: string;
-  inputSchema: Record<string, unknown>; // JSON Schema
-}
-
-export interface MCPToolResult {
-  content: string;
-  isError?: boolean;
-  metadata?: Record<string, unknown>;
-}
-
-export interface MCPTool extends MCPToolDefinition {
-  execute(input: Record<string, unknown>, context?: AgentContext): Promise<MCPToolResult>;
-}
-
-export class MCPToolRegistry {
-  private tools: Map<string, MCPTool> = new Map();
-
-  register(tool: MCPTool): void {
-    this.tools.set(tool.name, tool);
-  }
-
-  unregister(name: string): void {
-    this.tools.delete(name);
-  }
-
-  get(name: string): MCPTool | undefined {
-    return this.tools.get(name);
-  }
-
-  list(): MCPToolDefinition[] {
-    return Array.from(this.tools.values()).map(({ name, description, inputSchema }) => ({
-      name,
-      description,
-      inputSchema,
-    }));
-  }
-
-  has(name: string): boolean {
-    return this.tools.has(name);
-  }
-
-  async execute(name: string, input: Record<string, unknown>, context?: AgentContext): Promise<MCPToolResult> {
-    const tool = this.tools.get(name);
-    if (!tool) {
-      return { content: `Tool '${name}' not found`, isError: true };
-    }
-    try {
-      return await tool.execute(input, context);
-    } catch (err) {
-      return {
-        content: `Tool execution error: ${err instanceof Error ? err.message : String(err)}`,
-        isError: true,
-      };
-    }
-  }
-}
-
-/**
- * Create an MCP tool from a simple function.
- */
-export function createMCPTool(
-  name: string,
-  description: string,
-  inputSchema: Record<string, unknown>,
-  executeFn: (input: Record<string, unknown>, context?: AgentContext) => Promise<MCPToolResult>,
-): MCPTool {
-  return { name, description, inputSchema, execute: executeFn };
-}

package/src/tools/text-analysis.ts

@@ -1,116 +0,0 @@
-import type { MCPTool, MCPToolResult } from './mcp';
-
-/**
- * Text Analysis Tool — v0.8.0
- * Summarize, translate (stub), sentiment analysis as an LLM function tool.
- * Note: For production, connect to actual LLM/NLP APIs. This provides basic built-in analysis.
- */
-export const TextAnalysisTool: MCPTool = {
-  name: 'text_analysis',
-  description: 'Analyze text: word count, character count, reading time, keyword extraction, basic sentiment, and language detection.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      operation: {
-        type: 'string',
-        enum: ['stats', 'keywords', 'sentiment', 'detect_language', 'truncate', 'split_sentences'],
-        description: 'Analysis operation to perform',
-      },
-      text: {
-        type: 'string',
-        description: 'Text to analyze',
-      },
-      maxLength: {
-        type: 'number',
-        description: 'Max length for truncate operation',
-      },
-      topN: {
-        type: 'number',
-        description: 'Number of top keywords to extract (default: 10)',
-      },
-    },
-    required: ['operation', 'text'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    try {
-      const op = String(input.operation);
-      const text = String(input.text ?? '');
-
-      switch (op) {
-        case 'stats': {
-          const words = text.split(/\s+/).filter(Boolean);
-          const sentences = text.split(/[.!?。！？]+/).filter(Boolean);
-          const readingTimeMin = Math.ceil(words.length / 200);
-          return {
-            content: JSON.stringify({
-              characters: text.length,
-              words: words.length,
-              sentences: sentences.length,
-              paragraphs: text.split(/\n\s*\n/).filter(Boolean).length,
-              readingTimeMinutes: readingTimeMin,
-            }, null, 2),
-          };
-        }
-
-        case 'keywords': {
-          const topN = Number(input.topN ?? 10);
-          const words = text.toLowerCase().replace(/[^\w\s\u4e00-\u9fff]/g, '').split(/\s+/).filter(Boolean);
-          const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'in', 'on', 'at', 'to', 'for', 'of', 'and', 'or', 'but', 'not', 'with', 'this', 'that', 'it', 'be', 'has', 'have', 'had', 'do', 'does', 'did', 'will', 'would', 'can', 'could', 'should', 'may', 'might', 'from', 'by', 'as', 'if', 'so', 'than']);
-          const freq: Record<string, number> = {};
-          for (const w of words) {
-            if (w.length < 2 || stopWords.has(w)) continue;
-            freq[w] = (freq[w] ?? 0) + 1;
-          }
-          const sorted = Object.entries(freq).sort((a, b) => b[1] - a[1]).slice(0, topN);
-          return { content: JSON.stringify(sorted.map(([word, count]) => ({ word, count })), null, 2) };
-        }
-
-        case 'sentiment': {
-          // Basic lexicon-based sentiment
-          const positiveWords = new Set(['good', 'great', 'excellent', 'amazing', 'wonderful', 'fantastic', 'love', 'happy', 'best', 'awesome', 'perfect', 'brilliant', 'outstanding', 'superb', 'beautiful', 'nice', 'enjoy', 'like', 'positive', 'success']);
-          const negativeWords = new Set(['bad', 'terrible', 'awful', 'horrible', 'hate', 'worst', 'poor', 'ugly', 'fail', 'wrong', 'sad', 'angry', 'frustrating', 'disappointing', 'negative', 'annoying', 'broken', 'useless', 'boring', 'painful']);
-
-          const words = text.toLowerCase().split(/\s+/);
-          let pos = 0, neg = 0;
-          for (const w of words) {
-            if (positiveWords.has(w)) pos++;
-            if (negativeWords.has(w)) neg++;
-          }
-          const total = pos + neg || 1;
-          const score = (pos - neg) / total; // -1 to 1
-          const label = score > 0.1 ? 'positive' : score < -0.1 ? 'negative' : 'neutral';
-          return {
-            content: JSON.stringify({ score: Math.round(score * 100) / 100, label, positive: pos, negative: neg }, null, 2),
-          };
-        }
-
-        case 'detect_language': {
-          // Simple heuristic
-          const hasChinese = /[\u4e00-\u9fff]/.test(text);
-          const hasJapanese = /[\u3040-\u309f\u30a0-\u30ff]/.test(text);
-          const hasKorean = /[\uac00-\ud7af]/.test(text);
-          const hasArabic = /[\u0600-\u06ff]/.test(text);
-          const lang = hasChinese ? 'zh' : hasJapanese ? 'ja' : hasKorean ? 'ko' : hasArabic ? 'ar' : 'en';
-          return { content: JSON.stringify({ detected: lang, confidence: 'heuristic' }) };
-        }
-
-        case 'truncate': {
-          const maxLen = Number(input.maxLength ?? 100);
-          const truncated = text.length > maxLen ? text.slice(0, maxLen) + '...' : text;
-          return { content: truncated };
-        }
-
-        case 'split_sentences': {
-          const sentences = text.match(/[^.!?。！？]+[.!?。！？]+/g) ?? [text];
-          return { content: JSON.stringify(sentences.map((s) => s.trim()), null, 2) };
-        }
-
-        default:
-          return { content: `Unknown operation: ${op}`, isError: true };
-      }
-    } catch (err) {
-      return { content: `Error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};