opc-agent 1.2.0 → 1.2.1

package/src/tools/datetime.ts

@@ -1,149 +1,149 @@
-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;
-}
+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/gateway.ts

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