@push.rocks/smartagent 1.8.0 → 3.0.0

package/ts/smartagent.tools.http.ts

@@ -1,283 +0,0 @@
-import * as plugins from './plugins.js';
-import * as interfaces from './smartagent.interfaces.js';
-import { BaseToolWrapper } from './smartagent.tools.base.js';
-
-/**
- * HTTP tool for making web requests
- * Wraps @push.rocks/smartrequest
- */
-export class HttpTool extends BaseToolWrapper {
-  public name = 'http';
-  public description = 'Make HTTP requests to web APIs and services';
-
-  public actions: interfaces.IToolAction[] = [
-    {
-      name: 'get',
-      description: 'Make a GET request',
-      parameters: {
-        type: 'object',
-        properties: {
-          url: { type: 'string', description: 'URL to request' },
-          headers: { type: 'object', description: 'Request headers (key-value pairs)' },
-          query: { type: 'object', description: 'Query parameters (key-value pairs)' },
-          timeout: { type: 'number', description: 'Timeout in milliseconds' },
-        },
-        required: ['url'],
-      },
-    },
-    {
-      name: 'post',
-      description: 'Make a POST request with JSON body',
-      parameters: {
-        type: 'object',
-        properties: {
-          url: { type: 'string', description: 'URL to request' },
-          body: { type: 'object', description: 'JSON body to send' },
-          headers: { type: 'object', description: 'Request headers (key-value pairs)' },
-          query: { type: 'object', description: 'Query parameters (key-value pairs)' },
-          timeout: { type: 'number', description: 'Timeout in milliseconds' },
-        },
-        required: ['url'],
-      },
-    },
-    {
-      name: 'put',
-      description: 'Make a PUT request with JSON body',
-      parameters: {
-        type: 'object',
-        properties: {
-          url: { type: 'string', description: 'URL to request' },
-          body: { type: 'object', description: 'JSON body to send' },
-          headers: { type: 'object', description: 'Request headers (key-value pairs)' },
-          timeout: { type: 'number', description: 'Timeout in milliseconds' },
-        },
-        required: ['url', 'body'],
-      },
-    },
-    {
-      name: 'patch',
-      description: 'Make a PATCH request with JSON body',
-      parameters: {
-        type: 'object',
-        properties: {
-          url: { type: 'string', description: 'URL to request' },
-          body: { type: 'object', description: 'JSON body to send' },
-          headers: { type: 'object', description: 'Request headers (key-value pairs)' },
-          timeout: { type: 'number', description: 'Timeout in milliseconds' },
-        },
-        required: ['url', 'body'],
-      },
-    },
-    {
-      name: 'delete',
-      description: 'Make a DELETE request',
-      parameters: {
-        type: 'object',
-        properties: {
-          url: { type: 'string', description: 'URL to request' },
-          headers: { type: 'object', description: 'Request headers (key-value pairs)' },
-          timeout: { type: 'number', description: 'Timeout in milliseconds' },
-        },
-        required: ['url'],
-      },
-    },
-  ];
-
-  public async initialize(): Promise<void> {
-    // SmartRequest is stateless, no initialization needed
-    this.isInitialized = true;
-  }
-
-  public async cleanup(): Promise<void> {
-    this.isInitialized = false;
-  }
-
-  public async execute(
-    action: string,
-    params: Record<string, unknown>
-  ): Promise<interfaces.IToolExecutionResult> {
-    this.validateAction(action);
-    this.ensureInitialized();
-
-    try {
-      let request = plugins.smartrequest.SmartRequest.create().url(params.url as string);
-
-      // Add headers
-      if (params.headers && typeof params.headers === 'object') {
-        for (const [key, value] of Object.entries(params.headers as Record<string, string>)) {
-          request = request.header(key, value);
-        }
-      }
-
-      // Add query parameters
-      if (params.query && typeof params.query === 'object') {
-        request = request.query(params.query as Record<string, string>);
-      }
-
-      // Add timeout
-      if (params.timeout) {
-        request = request.timeout(params.timeout as number);
-      }
-
-      // Add JSON body for POST, PUT, PATCH
-      if (params.body && ['post', 'put', 'patch'].includes(action)) {
-        request = request.json(params.body);
-      }
-
-      // Execute the request
-      let response;
-      switch (action) {
-        case 'get':
-          response = await request.get();
-          break;
-        case 'post':
-          response = await request.post();
-          break;
-        case 'put':
-          response = await request.put();
-          break;
-        case 'patch':
-          response = await request.patch();
-          break;
-        case 'delete':
-          response = await request.delete();
-          break;
-        default:
-          return { success: false, error: `Unknown action: ${action}` };
-      }
-
-      // Parse response body
-      let body: unknown;
-      const contentType = response.headers?.['content-type'] || '';
-
-      try {
-        if (contentType.includes('application/json')) {
-          body = await response.json();
-        } else {
-          body = await response.text();
-        }
-      } catch {
-        body = null;
-      }
-
-      return {
-        success: response.ok,
-        result: {
-          url: params.url,
-          method: action.toUpperCase(),
-          status: response.status,
-          statusText: response.statusText,
-          ok: response.ok,
-          headers: response.headers,
-          body,
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-
-  public getToolExplanation(): string {
-    return `## Tool: http
-Make HTTP requests to web APIs and services.
-
-### Actions:
-
-**get** - Make a GET request
-Parameters:
-  - url (required): URL to request
-  - headers (optional): Request headers (key-value object)
-  - query (optional): Query parameters (key-value object)
-  - timeout (optional): Timeout in milliseconds
-
-Example:
-<tool_call>
-  <tool>http</tool>
-  <action>get</action>
-  <params>{"url": "https://api.example.com/data", "headers": {"Authorization": "Bearer token123"}}</params>
-</tool_call>
-
-**post** - Make a POST request with JSON body
-Parameters:
-  - url (required): URL to request
-  - body (optional): JSON body to send
-  - headers (optional): Request headers (key-value object)
-  - query (optional): Query parameters (key-value object)
-  - timeout (optional): Timeout in milliseconds
-
-Example:
-<tool_call>
-  <tool>http</tool>
-  <action>post</action>
-  <params>{"url": "https://api.example.com/submit", "body": {"name": "test", "value": 123}}</params>
-</tool_call>
-
-**put** - Make a PUT request with JSON body
-Parameters:
-  - url (required): URL to request
-  - body (required): JSON body to send
-  - headers (optional): Request headers (key-value object)
-  - timeout (optional): Timeout in milliseconds
-
-Example:
-<tool_call>
-  <tool>http</tool>
-  <action>put</action>
-  <params>{"url": "https://api.example.com/resource/1", "body": {"name": "updated"}}</params>
-</tool_call>
-
-**patch** - Make a PATCH request with JSON body
-Parameters:
-  - url (required): URL to request
-  - body (required): JSON body to send
-  - headers (optional): Request headers (key-value object)
-  - timeout (optional): Timeout in milliseconds
-
-Example:
-<tool_call>
-  <tool>http</tool>
-  <action>patch</action>
-  <params>{"url": "https://api.example.com/resource/1", "body": {"status": "active"}}</params>
-</tool_call>
-
-**delete** - Make a DELETE request
-Parameters:
-  - url (required): URL to request
-  - headers (optional): Request headers (key-value object)
-  - timeout (optional): Timeout in milliseconds
-
-Example:
-<tool_call>
-  <tool>http</tool>
-  <action>delete</action>
-  <params>{"url": "https://api.example.com/resource/1"}</params>
-</tool_call>
-`;
-  }
-
-  public getCallSummary(action: string, params: Record<string, unknown>): string {
-    const method = action.toUpperCase();
-    let summary = `${method} request to "${params.url}"`;
-
-    if (params.query && Object.keys(params.query as object).length > 0) {
-      const queryStr = JSON.stringify(params.query);
-      summary += ` with query: ${queryStr.length > 50 ? queryStr.substring(0, 50) + '...' : queryStr}`;
-    }
-
-    if (params.body) {
-      const bodyStr = JSON.stringify(params.body);
-      const preview = bodyStr.length > 100 ? bodyStr.substring(0, 100) + '...' : bodyStr;
-      summary += ` with body: ${preview}`;
-    }
-
-    if (params.headers && Object.keys(params.headers as object).length > 0) {
-      const headerKeys = Object.keys(params.headers as object).join(', ');
-      summary += ` with headers: [${headerKeys}]`;
-    }
-
-    return summary;
-  }
-}

package/ts/smartagent.tools.json.ts

@@ -1,224 +0,0 @@
-import * as interfaces from './smartagent.interfaces.js';
-import { BaseToolWrapper } from './smartagent.tools.base.js';
-
-/**
- * JsonValidatorTool - Validates and formats JSON data
- * Useful for agents to self-validate their JSON output before completing a task
- */
-export class JsonValidatorTool extends BaseToolWrapper {
-  public name = 'json';
-  public description = 'Validate and format JSON data. Use this to verify your JSON output is valid before completing a task.';
-
-  public actions: interfaces.IToolAction[] = [
-    {
-      name: 'validate',
-      description: 'Validate that a string is valid JSON and optionally check required fields',
-      parameters: {
-        type: 'object',
-        properties: {
-          jsonString: {
-            type: 'string',
-            description: 'The JSON string to validate',
-          },
-          requiredFields: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Optional list of field names that must be present at the root level',
-          },
-        },
-        required: ['jsonString'],
-      },
-    },
-    {
-      name: 'format',
-      description: 'Parse and pretty-print JSON string',
-      parameters: {
-        type: 'object',
-        properties: {
-          jsonString: {
-            type: 'string',
-            description: 'The JSON string to format',
-          },
-        },
-        required: ['jsonString'],
-      },
-    },
-  ];
-
-  async initialize(): Promise<void> {
-    this.isInitialized = true;
-  }
-
-  async cleanup(): Promise<void> {
-    this.isInitialized = false;
-  }
-
-  async execute(
-    action: string,
-    params: Record<string, unknown>
-  ): Promise<interfaces.IToolExecutionResult> {
-    this.validateAction(action);
-
-    switch (action) {
-      case 'validate':
-        return this.validateJson(params);
-      case 'format':
-        return this.formatJson(params);
-      default:
-        return { success: false, error: `Unknown action: ${action}` };
-    }
-  }
-
-  /**
-   * Validate JSON string and optionally check for required fields
-   */
-  private validateJson(params: Record<string, unknown>): interfaces.IToolExecutionResult {
-    const jsonString = params.jsonString as string;
-    const requiredFields = params.requiredFields as string[] | undefined;
-
-    if (!jsonString || typeof jsonString !== 'string') {
-      return {
-        success: false,
-        error: 'jsonString parameter is required and must be a string',
-      };
-    }
-
-    try {
-      const parsed = JSON.parse(jsonString);
-
-      // Check required fields if specified
-      if (requiredFields && Array.isArray(requiredFields)) {
-        const missingFields = requiredFields.filter((field) => {
-          if (typeof parsed !== 'object' || parsed === null) {
-            return true;
-          }
-          return !(field in parsed);
-        });
-
-        if (missingFields.length > 0) {
-          return {
-            success: false,
-            error: `Missing required fields: ${missingFields.join(', ')}`,
-            result: {
-              valid: false,
-              missingFields,
-              presentFields: Object.keys(parsed || {}),
-            },
-          };
-        }
-      }
-
-      return {
-        success: true,
-        result: {
-          valid: true,
-          parsed,
-          type: Array.isArray(parsed) ? 'array' : typeof parsed,
-          fieldCount: typeof parsed === 'object' && parsed !== null ? Object.keys(parsed).length : undefined,
-        },
-        summary: `JSON is valid (${Array.isArray(parsed) ? 'array' : typeof parsed})`,
-      };
-    } catch (error) {
-      const errorMessage = (error as Error).message;
-
-      // Extract position from error message if available
-      const posMatch = errorMessage.match(/position\s*(\d+)/i);
-      const position = posMatch ? parseInt(posMatch[1]) : undefined;
-
-      // Provide context around the error position
-      let context: string | undefined;
-      if (position !== undefined) {
-        const start = Math.max(0, position - 20);
-        const end = Math.min(jsonString.length, position + 20);
-        context = jsonString.substring(start, end);
-      }
-
-      return {
-        success: false,
-        error: `Invalid JSON: ${errorMessage}`,
-        result: {
-          valid: false,
-          errorPosition: position,
-          errorContext: context,
-        },
-      };
-    }
-  }
-
-  /**
-   * Format/pretty-print JSON string
-   */
-  private formatJson(params: Record<string, unknown>): interfaces.IToolExecutionResult {
-    const jsonString = params.jsonString as string;
-
-    if (!jsonString || typeof jsonString !== 'string') {
-      return {
-        success: false,
-        error: 'jsonString parameter is required and must be a string',
-      };
-    }
-
-    try {
-      const parsed = JSON.parse(jsonString);
-      const formatted = JSON.stringify(parsed, null, 2);
-
-      return {
-        success: true,
-        result: formatted,
-        summary: `Formatted JSON (${formatted.length} chars)`,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Cannot format invalid JSON: ${(error as Error).message}`,
-      };
-    }
-  }
-
-  public getToolExplanation(): string {
-    return `## Tool: json
-Validate and format JSON data. Use this to verify your JSON output is valid before completing a task.
-
-### Actions:
-
-**validate** - Validate that a string is valid JSON and optionally check required fields
-Parameters:
-  - jsonString (required): The JSON string to validate
-  - requiredFields (optional): Array of field names that must be present
-
-Example:
-<tool_call>
-  <tool>json</tool>
-  <action>validate</action>
-  <params>{"jsonString": "{\\"invoice_number\\":\\"INV-001\\",\\"total\\":99.99}", "requiredFields": ["invoice_number", "total"]}</params>
-</tool_call>
-
-**format** - Parse and pretty-print JSON string
-Parameters:
-  - jsonString (required): The JSON string to format
-
-Example:
-<tool_call>
-  <tool>json</tool>
-  <action>format</action>
-  <params>{"jsonString": "{\\"name\\":\\"test\\",\\"value\\":123}"}</params>
-</tool_call>
-`;
-  }
-
-  getCallSummary(action: string, params: Record<string, unknown>): string {
-    const jsonStr = (params.jsonString as string) || '';
-    const preview = jsonStr.length > 50 ? jsonStr.substring(0, 50) + '...' : jsonStr;
-
-    switch (action) {
-      case 'validate':
-        const fields = params.requiredFields as string[] | undefined;
-        const fieldInfo = fields ? ` (checking fields: ${fields.join(', ')})` : '';
-        return `Validate JSON: ${preview}${fieldInfo}`;
-      case 'format':
-        return `Format JSON: ${preview}`;
-      default:
-        return `JSON ${action}: ${preview}`;
-    }
-  }
-}