@codebolt/agent 1.2.1 → 2.2.3

package/dist/types/commonTypes.d.ts

@@ -54,10 +54,14 @@ export interface DiffResult {
         insertions: number;
         deletions: number;
         binary: boolean;
+        status?: 'added' | 'modified' | 'deleted' | 'renamed' | 'copied';
+        oldFile?: string;
+        diff?: string;
     }>;
     insertions: number;
     deletions: number;
     changed: number;
+    rawDiff?: string;
 }
 export interface AgentFunction {
     type: 'function';

package/dist/types/processorTypes.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Processor types and interfaces for the Unified Agent Framework
+ * @deprecated Use specific processor type files instead
+ *
+ * This file is kept for backward compatibility.
+ * New code should import from the specific processor type files:
+ * - './processorTypes/messageModifierTypes'
+ * - './processorTypes/preInferenceProcessorTypes'
+ * - './processorTypes/postInferenceTypes'
+ * - './processorTypes/preToolCallProcessorTypes'
+ * - './processorTypes/postToolCallProcessorTypes'
+ */
+export * from './processorTypes';
+export interface ToolCall {
+    id: string;
+    function: {
+        name: string;
+        arguments: string | Record<string, unknown>;
+    };
+}
+export interface Tool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: unknown;
+    };
+}
+export interface Message {
+    role: 'user' | 'assistant' | 'tool' | 'system';
+    content: string | unknown[];
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    [key: string]: unknown;
+}
+export interface ProcessedMessage {
+    messages: Message[];
+    metadata?: Record<string, unknown>;
+}
+export interface ProcessorInput {
+    message: ProcessedMessage;
+    context?: Record<string, unknown>;
+}
+export interface ProcessorOutput {
+    type: string;
+    value?: unknown;
+}
+export interface Processor {
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
+    clearContext(): void;
+}
+export declare abstract class BaseProcessor implements Processor {
+    protected context: Record<string, unknown>;
+    constructor(options?: Record<string, unknown>);
+    abstract processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
+    clearContext(): void;
+    protected createEvent(type: string, value?: unknown): ProcessorOutput;
+    protected createEvents(...events: Array<{
+        type: string;
+        value?: unknown;
+    }>): ProcessorOutput[];
+}

package/dist/types/processorTypes.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Processor types and interfaces for the Unified Agent Framework
+ * @deprecated Use specific processor type files instead
+ *
+ * This file is kept for backward compatibility.
+ * New code should import from the specific processor type files:
+ * - './processorTypes/messageModifierTypes'
+ * - './processorTypes/preInferenceProcessorTypes'
+ * - './processorTypes/postInferenceTypes'
+ * - './processorTypes/preToolCallProcessorTypes'
+ * - './processorTypes/postToolCallProcessorTypes'
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProcessor = void 0;
+// Re-export all processor types from their specific modules
+__exportStar(require("./processorTypes"), exports);
+// Base processor class
+class BaseProcessor {
+    constructor(options) {
+        this.context = {};
+        if (options) {
+            this.context = { ...options };
+        }
+    }
+    setContext(key, value) {
+        this.context[key] = value;
+    }
+    getContext(key) {
+        return this.context[key];
+    }
+    clearContext() {
+        this.context = {};
+    }
+    // Helper method to create events
+    createEvent(type, value) {
+        return { type, value };
+    }
+    // Helper method to create multiple events
+    createEvents(...events) {
+        return events.map(event => this.createEvent(event.type, event.value));
+    }
+}
+exports.BaseProcessor = BaseProcessor;

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

@@ -0,0 +1,17 @@
+import { AgentConfig, AgentInterface } from "@codebolt/types/agent";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export declare class Agent implements AgentInterface {
+    private readonly config;
+    private readonly messageModifiers;
+    private readonly preInferenceProcessors;
+    private readonly postInferenceProcessors;
+    private readonly preToolCallProcessors;
+    private readonly postToolCallProcessors;
+    private readonly enableLogging;
+    constructor(config: AgentConfig);
+    execute(reqMessage: FlatUserMessage): Promise<{
+        success: boolean;
+        result: any;
+        error?: string;
+    }>;
+}

package/dist/unified/agent/agent.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const base_1 = require("../base");
+const responseExecutor_1 = require("../base/responseExecutor");
+const agentStep_1 = require("../base/agentStep");
+class Agent {
+    constructor(config) {
+        var _a, _b, _c, _d, _e;
+        this.config = { ...config };
+        this.messageModifiers = ((_a = config.processors) === null || _a === void 0 ? void 0 : _a.messageModifiers) || [];
+        this.preInferenceProcessors = ((_b = config.processors) === null || _b === void 0 ? void 0 : _b.preInferenceProcessors) || [];
+        this.postInferenceProcessors = ((_c = config.processors) === null || _c === void 0 ? void 0 : _c.postInferenceProcessors) || [];
+        this.preToolCallProcessors = ((_d = config.processors) === null || _d === void 0 ? void 0 : _d.preToolCallProcessors) || [];
+        this.postToolCallProcessors = ((_e = config.processors) === null || _e === void 0 ? void 0 : _e.postToolCallProcessors) || [];
+        this.enableLogging = config.enableLogging !== false;
+    }
+    async execute(reqMessage) {
+        if (!reqMessage) {
+            return {
+                success: false,
+                result: null,
+                error: 'Request message is required'
+            };
+        }
+        try {
+            const promptGenerator = new base_1.InitialPromptGenerator({
+                processors: this.messageModifiers,
+                baseSystemPrompt: this.config.instructions || 'Based on User Message send reply',
+                enableLogging: this.enableLogging
+            });
+            let prompt = await promptGenerator.processMessage(reqMessage);
+            let completed = false;
+            while (!completed) {
+                const agentStep = new agentStep_1.AgentStep({
+                    preInferenceProcessors: this.preInferenceProcessors,
+                    postInferenceProcessors: this.postInferenceProcessors
+                });
+                const stepResult = await agentStep.executeStep(reqMessage, prompt);
+                prompt = stepResult.nextMessage;
+                if (this.enableLogging) {
+                    // console.log('[Agent] Step completed, processing response');
+                }
+                const responseExecutor = new responseExecutor_1.ResponseExecutor({
+                    preToolCalProcessors: this.preToolCallProcessors,
+                    postToolCallProcessors: this.postToolCallProcessors
+                });
+                const executionResult = await responseExecutor.executeResponse({
+                    initailUserMessage: reqMessage,
+                    actualMessageSentToLLM: stepResult.actualMessageSentToLLM,
+                    rawLLMOutput: stepResult.rawLLMResponse,
+                    nextMessage: stepResult.nextMessage
+                });
+                completed = executionResult.completed;
+                prompt = executionResult.nextMessage;
+            }
+            if (this.enableLogging) {
+                // console.log('[Agent] Execution completed successfully');
+            }
+            return {
+                success: true,
+                result: prompt,
+                error: undefined
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            if (this.enableLogging) {
+                console.error('[Agent] Execution failed:', error);
+            }
+            return {
+                success: false,
+                result: null,
+                error: errorMessage
+            };
+        }
+    }
+}
+exports.Agent = Agent;

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

@@ -0,0 +1,2 @@
+export declare class Team {
+}

package/dist/unified/agent/team.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Team = void 0;
+class Team {
+}
+exports.Team = Team;

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

@@ -0,0 +1,99 @@
+/**
+ * Tool creation utilities for the Unified Agent Framework
+ */
+import { z } from 'zod';
+import type { OpenAITool } from '../types/libTypes';
+import type { Tool, ToolConfig } from './agent';
+/**
+ * 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 };
+ *   },
+ * });
+ * ```
+ */
+export declare function createTool<TInput = any, TOutput = any>(config: ToolConfig<TInput, TOutput>): Tool<TInput, TOutput>;
+/**
+ * Creates a simple text-based tool
+ */
+export declare 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>;
+/**
+ * Creates a file operation tool
+ */
+export declare 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;
+/**
+ * Creates an HTTP request tool
+ */
+export declare 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;
+/**
+ * Creates a validation tool
+ */
+export declare 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;
+/**
+ * Creates a transformation tool
+ */
+export declare 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>;
+/**
+ * Utility to convert multiple tools to OpenAI format
+ */
+export declare function toolsToOpenAIFormat(tools: Tool[]): OpenAITool[];
+/**
+ * Utility to execute a tool with validation
+ */
+export declare function executeTool<TInput, TOutput>(tool: Tool<TInput, TOutput>, input: unknown, context?: Record<string, any>, agent?: any): Promise<TOutput>;