opc-agent 4.1.1 → 4.1.3

package/src/tools/builtin/rl-tools.ts

@@ -1,243 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-// In-memory storage fallback
-interface Trajectory {
-  id: string;
-  taskType: string;
-  actions: Array<{ action: string; timestamp: number; reward?: number }>;
-  outcome?: 'success' | 'partial' | 'failure';
-  totalReward: number;
-}
-
-interface PolicyEntry {
-  taskType: string;
-  preferredActions: string[];
-  weights: Record<string, number>;
-}
-
-const trajectories: Trajectory[] = [];
-const policies = new Map<string, PolicyEntry>();
-let currentEpisode: Trajectory | null = null;
-
-function getOrCreateEpisode(taskType: string): Trajectory {
-  if (!currentEpisode || currentEpisode.taskType !== taskType) {
-    currentEpisode = {
-      id: `ep_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      taskType,
-      actions: [],
-      totalReward: 0,
-    };
-    trajectories.push(currentEpisode);
-  }
-  return currentEpisode;
-}
-
-export const rlRecordTrajectory: MCPTool = {
-  name: 'rl_record_trajectory',
-  description: 'Record action sequences and outcomes for RL training',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      taskType: { type: 'string' },
-      action: { type: 'string' },
-      outcome: { type: 'string', enum: ['success', 'partial', 'failure'] },
-    },
-    required: ['taskType', 'action'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    const ep = getOrCreateEpisode(input.taskType as string);
-    ep.actions.push({ action: input.action as string, timestamp: Date.now() });
-    if (input.outcome) ep.outcome = input.outcome as Trajectory['outcome'];
-    return { content: JSON.stringify({ episodeId: ep.id, actionsRecorded: ep.actions.length }) };
-  },
-};
-
-export const rlEvaluateOutcome: MCPTool = {
-  name: 'rl_evaluate_outcome',
-  description: "Score an action's outcome (success/partial/failure)",
-  inputSchema: {
-    type: 'object',
-    properties: {
-      episodeId: { type: 'string' },
-      outcome: { type: 'string', enum: ['success', 'partial', 'failure'] },
-    },
-    required: ['outcome'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    const ep = input.episodeId
-      ? trajectories.find(t => t.id === input.episodeId)
-      : currentEpisode;
-    if (!ep) return { content: 'No active episode found', isError: true };
-    ep.outcome = input.outcome as Trajectory['outcome'];
-    const score = ep.outcome === 'success' ? 1 : ep.outcome === 'partial' ? 0.5 : 0;
-    return { content: JSON.stringify({ episodeId: ep.id, outcome: ep.outcome, score }) };
-  },
-};
-
-export const rlGetBestStrategy: MCPTool = {
-  name: 'rl_get_best_strategy',
-  description: 'Retrieve best-performing strategy for a task type',
-  inputSchema: {
-    type: 'object',
-    properties: { taskType: { type: 'string' } },
-    required: ['taskType'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    const taskType = input.taskType as string;
-    const relevant = trajectories.filter(t => t.taskType === taskType && t.outcome === 'success');
-    if (relevant.length === 0) return { content: JSON.stringify({ strategy: null, message: 'No successful strategies found' }) };
-    const best = relevant.reduce((a, b) => a.totalReward >= b.totalReward ? a : b);
-    return { content: JSON.stringify({ strategy: best.actions.map(a => a.action), totalReward: best.totalReward }) };
-  },
-};
-
-export const rlCompareStrategies: MCPTool = {
-  name: 'rl_compare_strategies',
-  description: 'Compare multiple strategies by success rate',
-  inputSchema: {
-    type: 'object',
-    properties: { taskType: { type: 'string' } },
-    required: ['taskType'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    const taskType = input.taskType as string;
-    const relevant = trajectories.filter(t => t.taskType === taskType && t.outcome);
-    const total = relevant.length;
-    const successes = relevant.filter(t => t.outcome === 'success').length;
-    const partials = relevant.filter(t => t.outcome === 'partial').length;
-    const failures = relevant.filter(t => t.outcome === 'failure').length;
-    return {
-      content: JSON.stringify({
-        taskType, total, successRate: total ? successes / total : 0,
-        breakdown: { successes, partials, failures },
-      }),
-    };
-  },
-};
-
-export const rlGenerateTrainingData: MCPTool = {
-  name: 'rl_generate_training_data',
-  description: 'Export trajectories as fine-tuning JSONL',
-  inputSchema: {
-    type: 'object',
-    properties: { taskType: { type: 'string' }, minReward: { type: 'number' } },
-  },
-  async execute(input): Promise<MCPToolResult> {
-    let data = trajectories;
-    if (input.taskType) data = data.filter(t => t.taskType === input.taskType);
-    if (input.minReward != null) data = data.filter(t => t.totalReward >= (input.minReward as number));
-    const jsonl = data.map(t => JSON.stringify({
-      messages: [
-        { role: 'system', content: `Task: ${t.taskType}` },
-        ...t.actions.map(a => ({ role: 'assistant', content: a.action })),
-      ],
-      outcome: t.outcome,
-      reward: t.totalReward,
-    })).join('\n');
-    return { content: jsonl || '(no data)' };
-  },
-};
-
-export const rlRewardSignal: MCPTool = {
-  name: 'rl_reward_signal',
-  description: 'Record positive/negative reward for last action',
-  inputSchema: {
-    type: 'object',
-    properties: { reward: { type: 'number' }, reason: { type: 'string' } },
-    required: ['reward'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    if (!currentEpisode || currentEpisode.actions.length === 0) {
-      return { content: 'No current episode or actions to reward', isError: true };
-    }
-    const lastAction = currentEpisode.actions[currentEpisode.actions.length - 1];
-    lastAction.reward = input.reward as number;
-    currentEpisode.totalReward += input.reward as number;
-    return { content: JSON.stringify({ action: lastAction.action, reward: input.reward, totalReward: currentEpisode.totalReward }) };
-  },
-};
-
-export const rlExplorationSuggest: MCPTool = {
-  name: 'rl_exploration_suggest',
-  description: 'Suggest alternative approaches (exploration)',
-  inputSchema: {
-    type: 'object',
-    properties: { taskType: { type: 'string' }, currentAction: { type: 'string' } },
-    required: ['taskType'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    const taskType = input.taskType as string;
-    const allActions = new Set<string>();
-    trajectories.filter(t => t.taskType === taskType).forEach(t => t.actions.forEach(a => allActions.add(a.action)));
-    const suggestions = Array.from(allActions).filter(a => a !== input.currentAction).slice(0, 5);
-    if (suggestions.length === 0) {
-      return { content: JSON.stringify({ suggestions: [], message: 'No alternative actions found. Try a completely new approach.' }) };
-    }
-    return { content: JSON.stringify({ suggestions }) };
-  },
-};
-
-export const rlUpdatePolicy: MCPTool = {
-  name: 'rl_update_policy',
-  description: "Update agent's action preferences based on rewards",
-  inputSchema: {
-    type: 'object',
-    properties: { taskType: { type: 'string' }, action: { type: 'string' }, weight: { type: 'number' } },
-    required: ['taskType', 'action', 'weight'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    const taskType = input.taskType as string;
-    let policy = policies.get(taskType);
-    if (!policy) {
-      policy = { taskType, preferredActions: [], weights: {} };
-      policies.set(taskType, policy);
-    }
-    const action = input.action as string;
-    policy.weights[action] = (policy.weights[action] || 0) + (input.weight as number);
-    policy.preferredActions = Object.entries(policy.weights)
-      .sort(([, a], [, b]) => b - a)
-      .map(([k]) => k);
-    return { content: JSON.stringify({ taskType, preferredActions: policy.preferredActions.slice(0, 5), weights: policy.weights }) };
-  },
-};
-
-export const rlGetStatistics: MCPTool = {
-  name: 'rl_get_statistics',
-  description: 'Get success/failure stats by task type',
-  inputSchema: {
-    type: 'object',
-    properties: { taskType: { type: 'string' } },
-  },
-  async execute(input): Promise<MCPToolResult> {
-    let data = trajectories;
-    if (input.taskType) data = data.filter(t => t.taskType === input.taskType);
-    const stats: Record<string, { total: number; success: number; partial: number; failure: number; avgReward: number }> = {};
-    for (const t of data) {
-      if (!stats[t.taskType]) stats[t.taskType] = { total: 0, success: 0, partial: 0, failure: 0, avgReward: 0 };
-      const s = stats[t.taskType];
-      s.total++;
-      if (t.outcome === 'success') s.success++;
-      else if (t.outcome === 'partial') s.partial++;
-      else if (t.outcome === 'failure') s.failure++;
-      s.avgReward = (s.avgReward * (s.total - 1) + t.totalReward) / s.total;
-    }
-    return { content: JSON.stringify(stats) };
-  },
-};
-
-export const rlResetEpisode: MCPTool = {
-  name: 'rl_reset_episode',
-  description: 'Clear current episode state',
-  inputSchema: { type: 'object', properties: {} },
-  async execute(): Promise<MCPToolResult> {
-    const had = currentEpisode != null;
-    currentEpisode = null;
-    return { content: JSON.stringify({ reset: true, hadActiveEpisode: had }) };
-  },
-};
-
-export const rlTools: MCPTool[] = [
-  rlRecordTrajectory, rlEvaluateOutcome, rlGetBestStrategy, rlCompareStrategies,
-  rlGenerateTrainingData, rlRewardSignal, rlExplorationSuggest, rlUpdatePolicy,
-  rlGetStatistics, rlResetEpisode,
-];

package/src/tools/builtin/shell.ts

@@ -1,43 +0,0 @@
-import { execSync } from 'child_process';
-import * as path from 'path';
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const shellTool: MCPTool = {
-  name: 'shell_exec',
-  description: 'Execute a shell command (sandboxed to workspace)',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      command: { type: 'string' },
-      timeout: { type: 'number', default: 30000 },
-    },
-    required: ['command'],
-  },
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const command = input.command as string;
-    const timeout = (input.timeout as number) || 30000;
-    const workspace = process.cwd();
-
-    // Block path traversal attempts
-    if (command.includes('..')) {
-      return { content: 'Commands with ".." are not allowed for security', isError: true };
-    }
-
-    try {
-      const output = execSync(command, {
-        cwd: workspace,
-        timeout,
-        encoding: 'utf-8',
-        maxBuffer: 1024 * 1024,
-        stdio: ['pipe', 'pipe', 'pipe'],
-      });
-      const result = (output || '').slice(0, 5000);
-      return { content: result || '(no output)', isError: false };
-    } catch (err: any) {
-      const stderr = err.stderr ? String(err.stderr).slice(0, 2500) : '';
-      const stdout = err.stdout ? String(err.stdout).slice(0, 2500) : '';
-      const output = [stdout, stderr].filter(Boolean).join('\n') || err.message;
-      return { content: `Command failed: ${output.slice(0, 5000)}`, isError: true };
-    }
-  },
-};

package/src/tools/builtin/vision.ts

@@ -1,64 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-import { VisionManager } from '../../core/vision';
-import type { ImageInput } from '../../core/vision';
-
-const manager = new VisionManager();
-
-export const visionAnalyzeTool: MCPTool = {
-  name: 'vision_analyze',
-  description: 'Analyze an image using vision AI. Provide image as URL or base64.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      image_url: { type: 'string', description: 'URL of the image to analyze' },
-      image_base64: { type: 'string', description: 'Base64-encoded image data' },
-      prompt: { type: 'string', description: 'Optional prompt for analysis' },
-    },
-  },
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const imgInput: ImageInput = input.image_url
-      ? { type: 'url', data: input.image_url as string }
-      : { type: 'base64', data: input.image_base64 as string };
-    const result = await manager.analyze(imgInput, input.prompt as string | undefined);
-    return { content: JSON.stringify(result) };
-  },
-};
-
-export const visionExtractTextTool: MCPTool = {
-  name: 'vision_extract_text',
-  description: 'Extract text (OCR) from an image.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      image_url: { type: 'string', description: 'URL of the image' },
-      image_base64: { type: 'string', description: 'Base64-encoded image data' },
-    },
-  },
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const imgInput: ImageInput = input.image_url
-      ? { type: 'url', data: input.image_url as string }
-      : { type: 'base64', data: input.image_base64 as string };
-    const text = await manager.extractText(imgInput);
-    return { content: text };
-  },
-};
-
-export const visionCompareTool: MCPTool = {
-  name: 'vision_compare',
-  description: 'Compare multiple images.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      image_urls: { type: 'array', items: { type: 'string' }, description: 'URLs of images to compare' },
-      prompt: { type: 'string', description: 'Optional comparison prompt' },
-    },
-  },
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const urls = input.image_urls as string[];
-    const images: ImageInput[] = urls.map(url => ({ type: 'url' as const, data: url }));
-    const result = await manager.compareImages(images, input.prompt as string | undefined);
-    return { content: result };
-  },
-};
-
-export const visionTools: MCPTool[] = [visionAnalyzeTool, visionExtractTextTool, visionCompareTool];

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

@@ -1,126 +0,0 @@
-/**
- * Web Search & Read Built-in Tools - v0.10.0
- * Registers web_search and web_read as agent-callable tools.
- */
-
-import type { MCPTool, MCPToolResult } from '../mcp';
-import { webSearch, DEFAULT_SEARCH_CONFIG, type WebSearchConfig, type SearchEngine } from '../web-search';
-import { scrapeUrl } from '../web-scraper';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import * as os from 'os';
-
-function loadSearchConfig(): WebSearchConfig {
-  try {
-    const cfgPath = join(os.homedir(), '.opc', 'config.json');
-    if (existsSync(cfgPath)) {
-      const cfg = JSON.parse(readFileSync(cfgPath, 'utf-8'));
-      if (cfg.webSearch) {
-        return { ...DEFAULT_SEARCH_CONFIG, ...cfg.webSearch };
-      }
-    }
-  } catch { /* ignore */ }
-  return DEFAULT_SEARCH_CONFIG;
-}
-
-export const webSearchTool: MCPTool = {
-  name: 'web_search',
-  description: 'Search the internet for information. Returns titles, URLs, and snippets from search results. Use when you need current information or facts you\'re unsure about.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      query: {
-        type: 'string',
-        description: 'Search query string',
-      },
-      maxResults: {
-        type: 'number',
-        description: 'Maximum number of results to return (default: 5)',
-      },
-      engine: {
-        type: 'string',
-        enum: ['duckduckgo', 'brave', 'searxng', 'google'],
-        description: 'Search engine to use (default: configured engine)',
-      },
-    },
-    required: ['query'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const query = String(input.query ?? '');
-    if (!query.trim()) {
-      return { content: 'Error: empty search query', isError: true };
-    }
-
-    const config = loadSearchConfig();
-    if (!config.enabled) {
-      return { content: 'Web search is disabled in settings.', isError: true };
-    }
-
-    try {
-      const results = await webSearch(query, config, {
-        maxResults: (input.maxResults as number) || 5,
-        engine: input.engine as SearchEngine | undefined,
-      });
-
-      if (results.length === 0) {
-        return { content: `No results found for: ${query}` };
-      }
-
-      const formatted = results.map((r, i) =>
-        `${i + 1}. **${r.title}**\n   ${r.url}\n   ${r.snippet}`
-      ).join('\n\n');
-
-      return {
-        content: `Search results for "${query}":\n\n${formatted}`,
-        metadata: { resultCount: results.length, query },
-      };
-    } catch (err) {
-      return {
-        content: `Search error: ${err instanceof Error ? err.message : String(err)}`,
-        isError: true,
-      };
-    }
-  },
-};
-
-export const webReadTool: MCPTool = {
-  name: 'web_read',
-  description: 'Read and extract the main content from a web page URL. Returns clean markdown text. Use to get detailed information from a specific page.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      url: {
-        type: 'string',
-        description: 'URL of the web page to read',
-      },
-      maxLength: {
-        type: 'number',
-        description: 'Maximum content length in characters (default: 5000)',
-      },
-    },
-    required: ['url'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const url = String(input.url ?? '');
-    if (!url.trim()) {
-      return { content: 'Error: empty URL', isError: true };
-    }
-
-    try {
-      const result = await scrapeUrl(url, (input.maxLength as number) || 5000);
-      return {
-        content: `# ${result.title}\n\nSource: ${result.url}\nWords: ${result.wordCount}\n\n---\n\n${result.content}`,
-        metadata: { title: result.title, url: result.url, wordCount: result.wordCount },
-      };
-    } catch (err) {
-      return {
-        content: `Scrape error: ${err instanceof Error ? err.message : String(err)}`,
-        isError: true,
-      };
-    }
-  },
-};
-
-export const webSearchTools: MCPTool[] = [webSearchTool, webReadTool];

package/src/tools/builtin/web.ts

@@ -1,35 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const webTool: MCPTool = {
-  name: 'web_fetch',
-  description: 'Fetch content from a URL',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      url: { type: 'string' },
-      method: { type: 'string', enum: ['GET', 'POST'], default: 'GET' },
-      maxLength: { type: 'number', default: 5000 },
-    },
-    required: ['url'],
-  },
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const url = input.url as string;
-    const method = (input.method as string) || 'GET';
-    const maxLength = (input.maxLength as number) || 5000;
-
-    try {
-      const response = await fetch(url, { method, signal: AbortSignal.timeout(15000) });
-      const text = await response.text();
-      const truncated = text.length > maxLength ? text.slice(0, maxLength) + '\n...[truncated]' : text;
-      return {
-        content: `Status: ${response.status}\n\n${truncated}`,
-        isError: false,
-      };
-    } catch (err) {
-      return {
-        content: `Fetch error: ${err instanceof Error ? err.message : String(err)}`,
-        isError: true,
-      };
-    }
-  },
-};

package/src/tools/calculator.ts

@@ -1,73 +0,0 @@
-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;
-}