@codebolt/agent 5.0.2 → 5.0.7

package/dist/unified/agent/tool.js

@@ -1,440 +0,0 @@
-"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/examples/agentExample.d.ts

@@ -1,46 +0,0 @@
-/**
- * Examples demonstrating how to use the high-level Agent class
- * with the Unified Agent Framework
- */
-/**
- * Example 1: Basic Agent with Default Processors
- */
-export declare function basicAgentExample(): Promise<{
-    result1: any;
-    result2: any;
-}>;
-/**
- * Example 2: Agent with Custom Tools and Processors
- */
-export declare function customAgentExample(): Promise<{
-    result1: any;
-    result2: any;
-}>;
-/**
- * Example 3: Agent with Local Tool Interception
- */
-export declare function localToolInterceptionExample(): Promise<{
-    result1: any;
-    result2: any;
-}>;
-/**
- * Example 4: Data Processing Agent with Validation and Transformation
- */
-export declare function dataProcessingAgentExample(): Promise<{
-    result1: any;
-    result2: any;
-}>;
-/**
- * Example 5: Dynamic Agent Configuration
- */
-export declare function dynamicAgentExample(): Promise<{
-    result1: any;
-    result2: any;
-    result3: any;
-    tools: any;
-}>;
-/**
- * Run all examples
- */
-export declare function runAllExamples(): Promise<void>;
-export { basicAgentExample, customAgentExample, localToolInterceptionExample, dataProcessingAgentExample, dynamicAgentExample };