@codebolt/agent 1.1.0 → 2.2.2

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/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;