opc-agent 4.1.1 → 4.1.3

package/src/tools/datetime.ts

@@ -1,149 +0,0 @@
-import type { MCPTool, MCPToolResult } from './mcp';
-
-/**
- * DateTime Tool — v0.8.0
- * Date/time operations as an LLM function tool.
- */
-export const DateTimeTool: MCPTool = {
-  name: 'datetime',
-  description: 'Get current date/time, format dates, calculate date differences, or add/subtract time.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      operation: {
-        type: 'string',
-        enum: ['now', 'format', 'diff', 'add', 'parse'],
-        description: 'Operation to perform',
-      },
-      date: {
-        type: 'string',
-        description: 'Date string (ISO 8601 or common format)',
-      },
-      date2: {
-        type: 'string',
-        description: 'Second date for diff operation',
-      },
-      format: {
-        type: 'string',
-        description: 'Output format: iso, date, time, datetime, unix, relative',
-      },
-      amount: {
-        type: 'number',
-        description: 'Amount to add (can be negative)',
-      },
-      unit: {
-        type: 'string',
-        enum: ['milliseconds', 'seconds', 'minutes', 'hours', 'days', 'weeks', 'months', 'years'],
-        description: 'Unit for add operation',
-      },
-      timezone: {
-        type: 'string',
-        description: 'IANA timezone (e.g. Asia/Shanghai, America/New_York)',
-      },
-    },
-    required: ['operation'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    try {
-      const op = String(input.operation);
-      const tz = input.timezone as string | undefined;
-
-      switch (op) {
-        case 'now': {
-          const now = new Date();
-          const fmt = (input.format as string) ?? 'iso';
-          return { content: formatDate(now, fmt, tz) };
-        }
-
-        case 'format': {
-          const d = parseDate(input.date as string);
-          const fmt = (input.format as string) ?? 'iso';
-          return { content: formatDate(d, fmt, tz) };
-        }
-
-        case 'diff': {
-          const d1 = parseDate(input.date as string);
-          const d2 = input.date2 ? parseDate(input.date2 as string) : new Date();
-          const diffMs = d2.getTime() - d1.getTime();
-          const days = Math.floor(Math.abs(diffMs) / 86400000);
-          const hours = Math.floor((Math.abs(diffMs) % 86400000) / 3600000);
-          const mins = Math.floor((Math.abs(diffMs) % 3600000) / 60000);
-          const sign = diffMs < 0 ? '-' : '';
-          return {
-            content: JSON.stringify({
-              milliseconds: diffMs,
-              readable: `${sign}${days}d ${hours}h ${mins}m`,
-              days: diffMs / 86400000,
-            }),
-          };
-        }
-
-        case 'add': {
-          const d = input.date ? parseDate(input.date as string) : new Date();
-          const amount = Number(input.amount ?? 0);
-          const unit = String(input.unit ?? 'days');
-          const result = addTime(d, amount, unit);
-          const fmt = (input.format as string) ?? 'iso';
-          return { content: formatDate(result, fmt, tz) };
-        }
-
-        case 'parse': {
-          const d = parseDate(input.date as string);
-          return {
-            content: JSON.stringify({
-              iso: d.toISOString(),
-              unix: d.getTime(),
-              year: d.getFullYear(),
-              month: d.getMonth() + 1,
-              day: d.getDate(),
-              weekday: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][d.getDay()],
-            }),
-          };
-        }
-
-        default:
-          return { content: `Unknown operation: ${op}`, isError: true };
-      }
-    } catch (err) {
-      return { content: `Error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};
-
-function parseDate(s: string): Date {
-  const d = new Date(s);
-  if (isNaN(d.getTime())) throw new Error(`Invalid date: ${s}`);
-  return d;
-}
-
-function formatDate(d: Date, fmt: string, tz?: string): string {
-  if (tz) {
-    const localeStr = d.toLocaleString('en-US', { timeZone: tz });
-    d = new Date(localeStr);
-  }
-  switch (fmt) {
-    case 'iso': return d.toISOString();
-    case 'date': return d.toISOString().split('T')[0];
-    case 'time': return d.toTimeString().split(' ')[0];
-    case 'datetime': return d.toISOString().replace('T', ' ').replace(/\.\d+Z$/, '');
-    case 'unix': return String(d.getTime());
-    default: return d.toISOString();
-  }
-}
-
-function addTime(d: Date, amount: number, unit: string): Date {
-  const result = new Date(d);
-  switch (unit) {
-    case 'milliseconds': result.setTime(result.getTime() + amount); break;
-    case 'seconds': result.setTime(result.getTime() + amount * 1000); break;
-    case 'minutes': result.setTime(result.getTime() + amount * 60000); break;
-    case 'hours': result.setTime(result.getTime() + amount * 3600000); break;
-    case 'days': result.setDate(result.getDate() + amount); break;
-    case 'weeks': result.setDate(result.getDate() + amount * 7); break;
-    case 'months': result.setMonth(result.getMonth() + amount); break;
-    case 'years': result.setFullYear(result.getFullYear() + amount); break;
-    default: throw new Error(`Unknown unit: ${unit}`);
-  }
-  return result;
-}

package/src/tools/document-processor.ts

@@ -1,213 +0,0 @@
-/**
- * Document Processor - Parse and chunk documents for knowledge learning
- * Supports: PDF, TXT, MD, DOCX, CSV, JSON
- */
-
-export interface DocumentChunk {
-  title: string;
-  content: string;
-  metadata: {
-    source: string;
-    format: string;
-    chunkIndex: number;
-    totalChunks?: number;
-    page?: number;
-  };
-}
-
-export interface ProcessedDocument {
-  id: string;
-  filename: string;
-  format: string;
-  size: number;
-  chunks: DocumentChunk[];
-  processedAt: string;
-}
-
-const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
-const CHUNK_TARGET_CHARS = 2000; // ~500 tokens
-const CHUNK_MAX_CHARS = 4000; // ~1000 tokens
-
-export class DocumentProcessor {
-  /**
-   * Process a file buffer into chunks
-   */
-  async process(buffer: Buffer, filename: string): Promise<ProcessedDocument> {
-    if (buffer.length > MAX_FILE_SIZE) {
-      throw new Error(`File too large: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (max 50MB)`);
-    }
-
-    const ext = filename.split('.').pop()?.toLowerCase() || '';
-    let rawText: string;
-
-    switch (ext) {
-      case 'pdf':
-        rawText = await this.parsePDF(buffer);
-        break;
-      case 'docx':
-        rawText = await this.parseDOCX(buffer);
-        break;
-      case 'csv':
-        rawText = this.parseCSV(buffer.toString('utf-8'));
-        break;
-      case 'json':
-        rawText = this.parseJSON(buffer.toString('utf-8'));
-        break;
-      case 'txt':
-      case 'md':
-      case 'markdown':
-        rawText = buffer.toString('utf-8');
-        break;
-      default:
-        // Try as plain text
-        rawText = buffer.toString('utf-8');
-    }
-
-    const chunks = this.chunkText(rawText, filename, ext);
-
-    return {
-      id: `doc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-      filename,
-      format: ext,
-      size: buffer.length,
-      chunks,
-      processedAt: new Date().toISOString(),
-    };
-  }
-
-  private async parsePDF(buffer: Buffer): Promise<string> {
-    try {
-      const pdfParse = require('pdf-parse');
-      const data = await pdfParse(buffer);
-      return data.text || '';
-    } catch (e: any) {
-      throw new Error(`PDF parse failed: ${e.message}`);
-    }
-  }
-
-  private async parseDOCX(buffer: Buffer): Promise<string> {
-    try {
-      const mammoth = require('mammoth');
-      const result = await mammoth.extractRawText({ buffer });
-      return result.value || '';
-    } catch (e: any) {
-      throw new Error(`DOCX parse failed: ${e.message}`);
-    }
-  }
-
-  private parseCSV(text: string): string {
-    const lines = text.split('\n').filter(l => l.trim());
-    if (lines.length === 0) return '';
-
-    const headers = lines[0].split(',').map(h => h.trim().replace(/^"|"$/g, ''));
-    const rows = lines.slice(1);
-
-    // Convert CSV to readable text
-    return rows.map((row, i) => {
-      const values = this.parseCSVLine(row);
-      const pairs = headers.map((h, j) => `${h}: ${values[j] || ''}`);
-      return `Record ${i + 1}:\n${pairs.join('\n')}`;
-    }).join('\n\n');
-  }
-
-  private parseCSVLine(line: string): string[] {
-    const result: string[] = [];
-    let current = '';
-    let inQuotes = false;
-    for (const ch of line) {
-      if (ch === '"') { inQuotes = !inQuotes; }
-      else if (ch === ',' && !inQuotes) { result.push(current.trim()); current = ''; }
-      else { current += ch; }
-    }
-    result.push(current.trim());
-    return result;
-  }
-
-  private parseJSON(text: string): string {
-    try {
-      const data = JSON.parse(text);
-      if (Array.isArray(data)) {
-        return data.map((item, i) => `Item ${i + 1}:\n${JSON.stringify(item, null, 2)}`).join('\n\n');
-      }
-      return JSON.stringify(data, null, 2);
-    } catch {
-      return text;
-    }
-  }
-
-  /**
-   * Smart chunking: split by headings/paragraphs, respecting size limits
-   */
-  private chunkText(text: string, filename: string, format: string): DocumentChunk[] {
-    if (!text.trim()) return [];
-
-    // Split by markdown headings or double newlines
-    const sections = text.split(/\n(?=#{1,3}\s)|(?:\n\s*\n)/).filter(s => s.trim());
-    const chunks: DocumentChunk[] = [];
-    let currentChunk = '';
-    let currentTitle = filename;
-
-    for (const section of sections) {
-      const headingMatch = section.match(/^(#{1,3})\s+(.+)/);
-      if (headingMatch) {
-        currentTitle = headingMatch[2].trim();
-      }
-
-      if (currentChunk.length + section.length > CHUNK_MAX_CHARS && currentChunk.length > 0) {
-        chunks.push({
-          title: currentTitle,
-          content: currentChunk.trim(),
-          metadata: { source: filename, format, chunkIndex: chunks.length },
-        });
-        currentChunk = '';
-      }
-
-      currentChunk += section + '\n\n';
-
-      if (currentChunk.length >= CHUNK_TARGET_CHARS) {
-        chunks.push({
-          title: currentTitle,
-          content: currentChunk.trim(),
-          metadata: { source: filename, format, chunkIndex: chunks.length },
-        });
-        currentChunk = '';
-      }
-    }
-
-    if (currentChunk.trim()) {
-      chunks.push({
-        title: currentTitle,
-        content: currentChunk.trim(),
-        metadata: { source: filename, format, chunkIndex: chunks.length },
-      });
-    }
-
-    // If we got no chunks from section splitting (e.g. dense text), force-split
-    if (chunks.length === 0 && text.trim()) {
-      const words = text.split(/\s+/);
-      let buf = '';
-      for (const w of words) {
-        if (buf.length + w.length + 1 > CHUNK_MAX_CHARS && buf) {
-          chunks.push({
-            title: filename,
-            content: buf.trim(),
-            metadata: { source: filename, format, chunkIndex: chunks.length },
-          });
-          buf = '';
-        }
-        buf += w + ' ';
-      }
-      if (buf.trim()) {
-        chunks.push({
-          title: filename,
-          content: buf.trim(),
-          metadata: { source: filename, format, chunkIndex: chunks.length },
-        });
-      }
-    }
-
-    // Set totalChunks
-    for (const c of chunks) c.metadata.totalChunks = chunks.length;
-    return chunks;
-  }
-}

package/src/tools/gateway.ts

@@ -1,220 +0,0 @@
-import type { AgentContext } from '../core/types';
-import type { MCPTool, MCPToolDefinition, MCPToolResult } from './mcp';
-
-// ─── Gateway Types ───────────────────────────────────────────
-
-export interface ToolGatewayConfig {
-  enabled: boolean;
-  endpoint: string;
-  apiKey: string;
-  enabledTools?: GatewayToolName[];
-  timeout?: number;
-}
-
-export type GatewayToolName = 'web-search' | 'image-gen' | 'tts' | 'browser';
-
-interface GatewayToolMeta {
-  name: GatewayToolName;
-  description: string;
-  inputSchema: Record<string, unknown>;
-  available: boolean;
-}
-
-interface GatewayResponse {
-  content: string;
-  error?: string;
-  metadata?: Record<string, unknown>;
-}
-
-// ─── Gateway Tool Wrapper ────────────────────────────────────
-
-class GatewayTool implements MCPTool {
-  name: string;
-  description: string;
-  inputSchema: Record<string, unknown>;
-
-  constructor(
-    private gateway: ToolGateway,
-    private meta: GatewayToolMeta,
-  ) {
-    this.name = `gateway:${meta.name}`;
-    this.description = `[Gateway] ${meta.description}`;
-    this.inputSchema = meta.inputSchema;
-  }
-
-  async execute(input: Record<string, unknown>, _context?: AgentContext): Promise<MCPToolResult> {
-    return this.gateway.invokeTool(this.meta.name, input);
-  }
-}
-
-// ─── Default Tool Definitions ────────────────────────────────
-
-const DEFAULT_TOOL_DEFS: GatewayToolMeta[] = [
-  {
-    name: 'web-search',
-    description: 'Search the web and return results',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        query: { type: 'string', description: 'Search query' },
-        count: { type: 'number', description: 'Number of results (1-10)' },
-      },
-      required: ['query'],
-    },
-    available: true,
-  },
-  {
-    name: 'image-gen',
-    description: 'Generate images from text prompts',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        prompt: { type: 'string', description: 'Image generation prompt' },
-        size: { type: 'string', description: 'Image size (e.g. 1024x1024)' },
-      },
-      required: ['prompt'],
-    },
-    available: true,
-  },
-  {
-    name: 'tts',
-    description: 'Convert text to speech audio',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        text: { type: 'string', description: 'Text to synthesize' },
-        voice: { type: 'string', description: 'Voice identifier' },
-      },
-      required: ['text'],
-    },
-    available: true,
-  },
-  {
-    name: 'browser',
-    description: 'Automated browser actions — navigate, screenshot, extract content',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        action: { type: 'string', description: 'Action: navigate | screenshot | extract' },
-        url: { type: 'string', description: 'Target URL' },
-        selector: { type: 'string', description: 'CSS selector for extraction' },
-      },
-      required: ['action', 'url'],
-    },
-    available: true,
-  },
-];
-
-// ─── ToolGateway ─────────────────────────────────────────────
-
-export class ToolGateway {
-  private config: ToolGatewayConfig;
-  private availableTools: Map<GatewayToolName, GatewayToolMeta> = new Map();
-  private connected = false;
-
-  constructor(config: ToolGatewayConfig) {
-    this.config = {
-      timeout: 30_000,
-      ...config,
-    };
-  }
-
-  /** Discover available tools from the gateway endpoint. */
-  async connect(): Promise<void> {
-    if (!this.config.enabled) return;
-
-    try {
-      const res = await fetch(`${this.config.endpoint}/tools`, {
-        headers: { Authorization: `Bearer ${this.config.apiKey}` },
-        signal: AbortSignal.timeout(this.config.timeout!),
-      });
-
-      if (!res.ok) {
-        throw new Error(`Gateway returned ${res.status}`);
-      }
-
-      const data = (await res.json()) as { tools: GatewayToolMeta[] };
-      const enabledSet = this.config.enabledTools
-        ? new Set(this.config.enabledTools)
-        : null;
-
-      for (const tool of data.tools) {
-        if (!enabledSet || enabledSet.has(tool.name)) {
-          this.availableTools.set(tool.name, tool);
-        }
-      }
-      this.connected = true;
-    } catch {
-      // Auto-detect failed — fall back to default definitions
-      this.loadDefaults();
-      this.connected = false;
-    }
-  }
-
-  /** Load default tool definitions (used as fallback). */
-  private loadDefaults(): void {
-    const enabledSet = this.config.enabledTools
-      ? new Set(this.config.enabledTools)
-      : null;
-
-    for (const def of DEFAULT_TOOL_DEFS) {
-      if (!enabledSet || enabledSet.has(def.name)) {
-        this.availableTools.set(def.name, def);
-      }
-    }
-  }
-
-  /** Invoke a tool through the gateway. */
-  async invokeTool(name: GatewayToolName, input: Record<string, unknown>): Promise<MCPToolResult> {
-    try {
-      const res = await fetch(`${this.config.endpoint}/tools/${name}/invoke`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${this.config.apiKey}`,
-        },
-        body: JSON.stringify({ input }),
-        signal: AbortSignal.timeout(this.config.timeout!),
-      });
-
-      if (!res.ok) {
-        return { content: `Gateway error: HTTP ${res.status}`, isError: true };
-      }
-
-      const data = (await res.json()) as GatewayResponse;
-      if (data.error) {
-        return { content: data.error, isError: true, metadata: data.metadata };
-      }
-      return { content: data.content, metadata: data.metadata };
-    } catch (err) {
-      return {
-        content: `Gateway invocation failed: ${err instanceof Error ? err.message : String(err)}`,
-        isError: true,
-      };
-    }
-  }
-
-  /** Get all gateway tools as MCPTool instances for registry integration. */
-  getTools(): MCPTool[] {
-    return Array.from(this.availableTools.values()).map(
-      (meta) => new GatewayTool(this, meta),
-    );
-  }
-
-  /** Get tool definitions (without execute). */
-  listTools(): MCPToolDefinition[] {
-    return Array.from(this.availableTools.values()).map(({ name, description, inputSchema }) => ({
-      name: `gateway:${name}`,
-      description: `[Gateway] ${description}`,
-      inputSchema,
-    }));
-  }
-
-  get isConnected(): boolean {
-    return this.connected;
-  }
-
-  get toolCount(): number {
-    return this.availableTools.size;
-  }
-}