@codebolt/agent 1.2.1 → 2.2.3

package/dist/unified/agent/tool.js

@@ -0,0 +1,440 @@
+"use strict";
+/**
+ * Tool creation utilities for the Unified Agent Framework
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTool = createTool;
+exports.createTextTool = createTextTool;
+exports.createFileTool = createFileTool;
+exports.createHttpTool = createHttpTool;
+exports.createValidationTool = createValidationTool;
+exports.createTransformTool = createTransformTool;
+exports.toolsToOpenAIFormat = toolsToOpenAIFormat;
+exports.executeTool = executeTool;
+const zod_1 = require("zod");
+/**
+ * Creates a new tool with input/output validation and execution logic
+ *
+ * @template TInput - Type for tool input parameters
+ * @template TOutput - Type for tool output
+ * @param config - Tool configuration object
+ * @returns Fully configured tool with validation methods
+ *
+ * @example
+ * ```typescript
+ * const calculatorTool = createTool({
+ *   id: 'calculator',
+ *   name: 'Calculator',
+ *   description: 'Performs basic mathematical calculations',
+ *   inputSchema: z.object({
+ *     expression: z.string().describe('Mathematical expression to evaluate'),
+ *   }),
+ *   outputSchema: z.object({
+ *     result: z.number(),
+ *     expression: z.string(),
+ *   }),
+ *   execute: async ({ input }) => {
+ *     const result = eval(input.expression); // Note: eval is dangerous, use a proper parser
+ *     return { result, expression: input.expression };
+ *   },
+ * });
+ * ```
+ */
+function createTool(config) {
+    const tool = {
+        ...config,
+        /**
+         * Validates input against the tool's input schema
+         * @param input - Raw input to validate
+         * @returns Validated and typed input
+         * @throws {Error} If validation fails
+         */
+        validateInput(input) {
+            try {
+                return config.inputSchema.parse(input);
+            }
+            catch (error) {
+                if (error instanceof zod_1.z.ZodError) {
+                    const errorMessages = error.issues
+                        .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+                        .join(', ');
+                    throw new Error(`Tool "${config.id}" input validation failed: ${errorMessages}`);
+                }
+                throw error;
+            }
+        },
+        /**
+         * Validates output against the tool's output schema (if provided)
+         * @param output - Raw output to validate
+         * @returns Validated and typed output
+         * @throws {Error} If validation fails
+         */
+        validateOutput(output) {
+            if (!config.outputSchema) {
+                return output;
+            }
+            try {
+                return config.outputSchema.parse(output);
+            }
+            catch (error) {
+                if (error instanceof zod_1.z.ZodError) {
+                    const errorMessages = error.issues
+                        .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+                        .join(', ');
+                    throw new Error(`Tool "${config.id}" output validation failed: ${errorMessages}`);
+                }
+                throw error;
+            }
+        },
+        /**
+         * Converts the tool to OpenAI function format
+         * @returns OpenAI function specification
+         */
+        toOpenAITool() {
+            return {
+                type: 'function',
+                function: {
+                    name: config.id,
+                    description: config.description,
+                    parameters: zodSchemaToJsonSchema(config.inputSchema)
+                }
+            };
+        }
+    };
+    return tool;
+}
+/**
+ * Converts a Zod schema to JSON Schema format for OpenAI functions
+ */
+function zodSchemaToJsonSchema(schema) {
+    // This is a simplified conversion - in a real implementation,
+    // you might want to use a library like zod-to-json-schema
+    if (schema instanceof zod_1.z.ZodObject) {
+        const shape = schema.shape;
+        const properties = {};
+        const required = [];
+        for (const [key, value] of Object.entries(shape)) {
+            properties[key] = zodTypeToJsonSchema(value);
+            // Check if field is required (not optional)
+            if (!value.isOptional()) {
+                required.push(key);
+            }
+        }
+        return {
+            type: 'object',
+            properties,
+            required: required.length > 0 ? required : undefined,
+            additionalProperties: false
+        };
+    }
+    return zodTypeToJsonSchema(schema);
+}
+/**
+ * Converts individual Zod types to JSON Schema
+ */
+function zodTypeToJsonSchema(zodType) {
+    if (zodType instanceof zod_1.z.ZodString) {
+        const result = { type: 'string' };
+        // Add description if available
+        if (zodType._def.description) {
+            result.description = zodType._def.description;
+        }
+        // Add constraints
+        const checks = zodType._def.checks || [];
+        for (const check of checks) {
+            switch (check.kind) {
+                case 'min':
+                    result.minLength = check.value;
+                    break;
+                case 'max':
+                    result.maxLength = check.value;
+                    break;
+                case 'email':
+                    result.format = 'email';
+                    break;
+                case 'url':
+                    result.format = 'uri';
+                    break;
+                case 'regex':
+                    result.pattern = check.regex.source;
+                    break;
+            }
+        }
+        return result;
+    }
+    if (zodType instanceof zod_1.z.ZodNumber) {
+        const result = { type: 'number' };
+        if (zodType._def.description) {
+            result.description = zodType._def.description;
+        }
+        const checks = zodType._def.checks || [];
+        for (const check of checks) {
+            switch (check.kind) {
+                case 'min':
+                    result.minimum = check.value;
+                    break;
+                case 'max':
+                    result.maximum = check.value;
+                    break;
+                case 'int':
+                    result.type = 'integer';
+                    break;
+            }
+        }
+        return result;
+    }
+    if (zodType instanceof zod_1.z.ZodBoolean) {
+        const result = { type: 'boolean' };
+        if (zodType._def.description) {
+            result.description = zodType._def.description;
+        }
+        return result;
+    }
+    if (zodType instanceof zod_1.z.ZodArray) {
+        const result = {
+            type: 'array',
+            items: zodTypeToJsonSchema(zodType._def.type)
+        };
+        if (zodType._def.description) {
+            result.description = zodType._def.description;
+        }
+        const checks = zodType._def.checks || [];
+        for (const check of checks) {
+            switch (check.kind) {
+                case 'min':
+                    result.minItems = check.value;
+                    break;
+                case 'max':
+                    result.maxItems = check.value;
+                    break;
+            }
+        }
+        return result;
+    }
+    if (zodType instanceof zod_1.z.ZodEnum) {
+        const result = {
+            type: 'string',
+            enum: zodType._def.values
+        };
+        if (zodType._def.description) {
+            result.description = zodType._def.description;
+        }
+        return result;
+    }
+    if (zodType instanceof zod_1.z.ZodLiteral) {
+        const result = {
+            type: typeof zodType._def.value,
+            enum: [zodType._def.value]
+        };
+        if (zodType._def.description) {
+            result.description = zodType._def.description;
+        }
+        return result;
+    }
+    if (zodType instanceof zod_1.z.ZodUnion) {
+        const options = zodType._def.options;
+        const anyOf = options.map((option) => zodTypeToJsonSchema(option));
+        const result = { anyOf };
+        if (zodType._def.description) {
+            result.description = zodType._def.description;
+        }
+        return result;
+    }
+    if (zodType instanceof zod_1.z.ZodOptional) {
+        return zodTypeToJsonSchema(zodType._def.innerType);
+    }
+    if (zodType instanceof zod_1.z.ZodNullable) {
+        const innerSchema = zodTypeToJsonSchema(zodType._def.innerType);
+        return {
+            anyOf: [
+                innerSchema,
+                { type: 'null' }
+            ]
+        };
+    }
+    if (zodType instanceof zod_1.z.ZodObject) {
+        return zodSchemaToJsonSchema(zodType);
+    }
+    // Fallback for unknown types
+    return { type: 'string', description: 'Unknown type' };
+}
+/**
+ * Creates a simple text-based tool
+ */
+function createTextTool(config) {
+    return createTool({
+        id: config.id,
+        name: config.name,
+        description: config.description,
+        inputSchema: zod_1.z.object({
+            text: zod_1.z.string().describe('Input text to process')
+        }),
+        outputSchema: zod_1.z.string(),
+        execute: async ({ input, context }) => {
+            return await config.execute(input.text, context);
+        },
+        timeout: config.timeout
+    });
+}
+/**
+ * Creates a file operation tool
+ */
+function createFileTool(config) {
+    let inputSchema;
+    switch (config.operation) {
+        case 'read':
+            inputSchema = zod_1.z.object({
+                filePath: zod_1.z.string().describe('Path to the file to read'),
+                encoding: zod_1.z.string().optional().describe('File encoding (default: utf-8)')
+            });
+            break;
+        case 'write':
+            inputSchema = zod_1.z.object({
+                filePath: zod_1.z.string().describe('Path to the file to write'),
+                content: zod_1.z.string().describe('Content to write to the file'),
+                encoding: zod_1.z.string().optional().describe('File encoding (default: utf-8)')
+            });
+            break;
+        case 'delete':
+            inputSchema = zod_1.z.object({
+                filePath: zod_1.z.string().describe('Path to the file to delete')
+            });
+            break;
+        case 'list':
+            inputSchema = zod_1.z.object({
+                directoryPath: zod_1.z.string().describe('Path to the directory to list'),
+                recursive: zod_1.z.boolean().optional().describe('Whether to list recursively')
+            });
+            break;
+        default:
+            throw new Error(`Unknown file operation: ${config.operation}`);
+    }
+    return createTool({
+        id: config.id,
+        name: config.name,
+        description: config.description,
+        inputSchema,
+        execute: config.execute
+    });
+}
+/**
+ * Creates an HTTP request tool
+ */
+function createHttpTool(config) {
+    const inputSchema = zod_1.z.object({
+        url: zod_1.z.string().describe('URL to make the request to'),
+        method: zod_1.z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).optional().describe('HTTP method'),
+        headers: zod_1.z.record(zod_1.z.string()).optional().describe('Request headers'),
+        body: zod_1.z.any().optional().describe('Request body'),
+        timeout: zod_1.z.number().optional().describe('Request timeout in milliseconds')
+    });
+    const defaultExecute = async ({ input }) => {
+        const url = config.baseUrl ? `${config.baseUrl}${input.url}` : input.url;
+        const method = input.method || config.method || 'GET';
+        const headers = { ...config.defaultHeaders, ...input.headers };
+        // This would use fetch or similar HTTP client
+        return {
+            url,
+            method,
+            headers,
+            status: 200,
+            data: 'HTTP request executed successfully'
+        };
+    };
+    return createTool({
+        id: config.id,
+        name: config.name,
+        description: config.description,
+        inputSchema,
+        execute: config.execute || defaultExecute
+    });
+}
+/**
+ * Creates a validation tool
+ */
+function createValidationTool(config) {
+    return createTool({
+        id: config.id,
+        name: config.name,
+        description: config.description,
+        inputSchema: zod_1.z.object({
+            data: zod_1.z.any().describe('Data to validate')
+        }),
+        execute: async ({ input }) => {
+            try {
+                const validatedData = config.schema.parse(input.data);
+                const result = config.onValid ? await config.onValid(validatedData) : validatedData;
+                return {
+                    valid: true,
+                    data: result,
+                    errors: []
+                };
+            }
+            catch (error) {
+                if (error instanceof zod_1.z.ZodError) {
+                    const errors = error.issues.map(issue => `${issue.path.join('.')}: ${issue.message}`);
+                    const result = config.onInvalid ? await config.onInvalid(errors) : null;
+                    return {
+                        valid: false,
+                        data: result,
+                        errors
+                    };
+                }
+                throw error;
+            }
+        }
+    });
+}
+/**
+ * Creates a transformation tool
+ */
+function createTransformTool(config) {
+    return createTool({
+        id: config.id,
+        name: config.name,
+        description: config.description,
+        inputSchema: config.inputSchema,
+        outputSchema: config.outputSchema,
+        execute: async ({ input, context }) => {
+            return await config.transform(input, context);
+        }
+    });
+}
+/**
+ * Utility to convert multiple tools to OpenAI format
+ */
+function toolsToOpenAIFormat(tools) {
+    return tools.map(tool => tool.toOpenAITool());
+}
+/**
+ * Utility to execute a tool with validation
+ */
+async function executeTool(tool, input, context, agent) {
+    // Validate input
+    const validatedInput = tool.validateInput(input);
+    // Execute with timeout if specified
+    let result;
+    if (tool.timeout) {
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`Tool execution timeout: ${tool.id}`)), tool.timeout);
+        });
+        const executionPromise = Promise.resolve(tool.execute({
+            input: validatedInput,
+            context,
+            agent
+        }));
+        result = await Promise.race([executionPromise, timeoutPromise]);
+    }
+    else {
+        result = await tool.execute({
+            input: validatedInput,
+            context,
+            agent
+        });
+    }
+    // Validate output if schema is provided
+    if (tool.validateOutput) {
+        return tool.validateOutput(result);
+    }
+    return result;
+}

package/dist/unified/agent/tools.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Tool creation utilities for the Unified Agent Framework
+ */
+import { z, ZodType } from 'zod';
+import type { OpenAITool } from '../types/libTypes';
+import { ToolConfig, ToolInterface } from '@codebolt/types/agent';
+export declare class Tool implements ToolInterface {
+    id: string;
+    description: string;
+    inputSchema: ZodType<any, any, any>;
+    outputSchema?: ZodType<any, any, any>;
+    executionFunction: (context: any) => any;
+    constructor(config: ToolConfig);
+    execute(input: any, context: any): Promise<{
+        success: boolean;
+        error: string | undefined;
+        result?: undefined;
+    } | {
+        success: boolean;
+        result: any;
+        error?: undefined;
+    }>;
+    getToolDescription(): string;
+    getToolSchema(): z.ZodType<any, any, any>;
+    private validateInput;
+    /**
+     * Validates output against the tool's output schema (if provided)
+     * @param output - Raw output to validate
+     * @returns Validated and typed output
+     * @throws {Error} If validation fails
+     */
+    private validateOutput;
+    /**
+     * Converts the tool to OpenAI function format
+     * @returns OpenAI function specification
+     */
+    toOpenAITool(): OpenAITool;
+    private zodSchemaToJsonSchema;
+    /**
+     * Converts individual Zod types to JSON Schema
+     */
+    private zodTypeToJsonSchema;
+}
+export declare function createTool(config: ToolConfig): Tool;