@codebolt/agent 1.1.0 → 2.2.2

package/dist/unified/agent/tools.js

@@ -0,0 +1,487 @@
+"use strict";
+/**
+ * Tool creation utilities for the Unified Agent Framework
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tool = void 0;
+exports.createTool = createTool;
+const zod_1 = require("zod");
+class Tool {
+    constructor(config) {
+        this.id = config.id;
+        this.description = config.description;
+        this.inputSchema = config.inputSchema;
+        this.outputSchema = config.outputSchema;
+        this.executionFunction = config.execute;
+    }
+    async execute(input, context) {
+        const inputValidation = this.validateInput(input);
+        if (!inputValidation.valid) {
+            return { success: false, error: inputValidation.error };
+        }
+        try {
+            let output = await this.executionFunction({ input, ...context });
+            const outputValidation = this.validateOutput(output);
+            if (!outputValidation.valid) {
+                return { success: false, error: outputValidation.error };
+            }
+            return { success: true, result: output };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Tool "${this.id}" execution failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    getToolDescription() {
+        return this.description;
+    }
+    getToolSchema() {
+        return this.inputSchema;
+    }
+    validateInput(input) {
+        try {
+            this.inputSchema.parse(input);
+            return { valid: true };
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                const errorMessages = error.issues
+                    .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+                    .join(', ');
+                return {
+                    valid: false,
+                    error: `Tool "${this.id}" input validation failed: ${errorMessages}`
+                };
+            }
+            return {
+                valid: false,
+                error: `Tool "${this.id}" input validation failed: ${error instanceof Error ? error.message : 'Unknown 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 (!this.outputSchema) {
+            return { valid: true };
+        }
+        try {
+            this.outputSchema.parse(output);
+            return { valid: true };
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                const errorMessages = error.issues
+                    .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+                    .join(', ');
+                return {
+                    valid: false,
+                    error: `Tool "${this.id}" output validation failed: ${errorMessages}`
+                };
+            }
+            return {
+                valid: false,
+                error: `Tool "${this.id}" output validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    /**
+     * Converts the tool to OpenAI function format
+     * @returns OpenAI function specification
+     */
+    toOpenAITool() {
+        return {
+            type: 'function',
+            function: {
+                name: this.id,
+                description: this.description,
+                parameters: this.zodSchemaToJsonSchema(this.inputSchema)
+            }
+        };
+    }
+    // /**
+    //  * Converts a Zod schema to JSON Schema format for OpenAI functions
+    //  */
+    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] = this.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 this.zodTypeToJsonSchema(schema);
+    }
+    /**
+     * Converts individual Zod types to JSON Schema
+     */
+    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: this.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) => this.zodTypeToJsonSchema(option));
+            const result = { anyOf };
+            if (zodType._def.description) {
+                result.description = zodType._def.description;
+            }
+            return result;
+        }
+        if (zodType instanceof zod_1.z.ZodOptional) {
+            return this.zodTypeToJsonSchema(zodType._def.innerType);
+        }
+        if (zodType instanceof zod_1.z.ZodNullable) {
+            const innerSchema = this.zodTypeToJsonSchema(zodType._def.innerType);
+            return {
+                anyOf: [
+                    innerSchema,
+                    { type: 'null' }
+                ]
+            };
+        }
+        if (zodType instanceof zod_1.z.ZodObject) {
+            return this.zodSchemaToJsonSchema(zodType);
+        }
+        // Fallback for unknown types
+        return { type: 'string', description: 'Unknown type' };
+    }
+}
+exports.Tool = Tool;
+function createTool(config) {
+    const toolObject = new Tool(config);
+    return toolObject;
+}
+// /**
+//  * Creates a simple text-based tool
+//  */
+// export function createTextTool(config: {
+//     id: string;
+//     name: string;
+//     description: string;
+//     execute: (text: string, context?: Record<string, any>) => Promise<string> | string;
+//     timeout?: number;
+// }): Tool<{ text: string }, string> {
+//     return createTool({
+//         id: config.id,
+//         name: config.name,
+//         description: config.description,
+//         inputSchema: z.object({
+//             text: z.string().describe('Input text to process')
+//         }),
+//         outputSchema: z.string(),
+//         execute: async ({ input, context }) => {
+//             return await config.execute(input.text, context);
+//         },
+//         timeout: config.timeout
+//     });
+// }
+// /**
+//  * Creates a file operation tool
+//  */
+// export function createFileTool(config: {
+//     id: string;
+//     name: string;
+//     description: string;
+//     operation: 'read' | 'write' | 'delete' | 'list';
+//     execute: (params: any, context?: Record<string, any>) => Promise<any> | any;
+// }): Tool {
+//     let inputSchema: z.ZodType;
+//     switch (config.operation) {
+//         case 'read':
+//             inputSchema = z.object({
+//                 filePath: z.string().describe('Path to the file to read'),
+//                 encoding: z.string().optional().describe('File encoding (default: utf-8)')
+//             });
+//             break;
+//         case 'write':
+//             inputSchema = z.object({
+//                 filePath: z.string().describe('Path to the file to write'),
+//                 content: z.string().describe('Content to write to the file'),
+//                 encoding: z.string().optional().describe('File encoding (default: utf-8)')
+//             });
+//             break;
+//         case 'delete':
+//             inputSchema = z.object({
+//                 filePath: z.string().describe('Path to the file to delete')
+//             });
+//             break;
+//         case 'list':
+//             inputSchema = z.object({
+//                 directoryPath: z.string().describe('Path to the directory to list'),
+//                 recursive: 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
+//  */
+// export function createHttpTool(config: {
+//     id: string;
+//     name: string;
+//     description: string;
+//     method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+//     baseUrl?: string;
+//     defaultHeaders?: Record<string, string>;
+//     execute?: (params: any, context?: Record<string, any>) => Promise<any> | any;
+// }): Tool {
+//     const inputSchema = z.object({
+//         url: z.string().describe('URL to make the request to'),
+//         method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).optional().describe('HTTP method'),
+//         headers: z.record(z.string()).optional().describe('Request headers'),
+//         body: z.any().optional().describe('Request body'),
+//         timeout: z.number().optional().describe('Request timeout in milliseconds')
+//     });
+//     const defaultExecute = async ({ input }: { input: any }) => {
+//         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
+//  */
+// export function createValidationTool<T>(config: {
+//     id: string;
+//     name: string;
+//     description: string;
+//     schema: z.ZodType<T>;
+//     onValid?: (data: T) => Promise<any> | any;
+//     onInvalid?: (errors: string[]) => Promise<any> | any;
+// }): Tool {
+//     return createTool({
+//         id: config.id,
+//         name: config.name,
+//         description: config.description,
+//         inputSchema: z.object({
+//             data: 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 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
+//  */
+// export function createTransformTool<TInput, TOutput>(config: {
+//     id: string;
+//     name: string;
+//     description: string;
+//     inputSchema: z.ZodType<TInput>;
+//     outputSchema?: z.ZodType<TOutput>;
+//     transform: (input: TInput, context?: Record<string, any>) => Promise<TOutput> | TOutput;
+// }): Tool<TInput, TOutput> {
+//     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
+//  */
+// export function toolsToOpenAIFormat(tools: Tool[]): OpenAITool[] {
+//     return tools.map(tool => tool.toOpenAITool());
+// }
+// /**
+//  * Utility to execute a tool with validation
+//  */
+// export async function executeTool<TInput, TOutput>(
+//     tool: Tool<TInput, TOutput>,
+//     input: unknown,
+//     context?: Record<string, any>,
+//     agent?: any
+// ): Promise<TOutput> {
+//     // Validate input
+//     const validatedInput = tool.validateInput(input);
+//     // Execute with timeout if specified
+//     let result: TOutput;
+//     if (tool.timeout) {
+//         const timeoutPromise = new Promise<never>((_, 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/workflow.d.ts

@@ -0,0 +1,24 @@
+import { BaseWorkflow, workflowConfig, WorkflowResult, workflowStepOutput } from "@codebolt/types/agent";
+export declare class Workflow implements BaseWorkflow {
+    private config;
+    private context;
+    private currentStepIndex;
+    private executionId;
+    private startTime;
+    private stepResults;
+    constructor(config: workflowConfig);
+    execute(): WorkflowResult;
+    executeStep(): workflowStepOutput;
+    executeSteps(): workflowStepOutput[];
+    getContext(): any;
+    updateContext(newContext: any): void;
+    reset(): void;
+    getCurrentStepIndex(): number;
+    getTotalSteps(): number;
+    getExecutionId(): string;
+    setInitialContext(context: any): void;
+    getStepResults(): workflowStepOutput[];
+    executeAsync(): Promise<WorkflowResult>;
+    executeStepAsync(): Promise<workflowStepOutput>;
+    executeStepsAsync(): Promise<workflowStepOutput[]>;
+}