@codebolt/agent 1.2.1 → 2.2.3

package/dist/unified/types/libTypes.d.ts

@@ -0,0 +1,378 @@
+/**
+ * Library types for the Unified Agent Framework
+ * Self-contained within the unified directory
+ */
+/**
+ * Represents a message in the conversation with roles and content.
+ */
+export interface Message {
+    /** The role of the message sender: user, assistant, tool, or system */
+    role: 'user' | 'assistant' | 'tool' | 'system';
+    /** The content of the message, can be an array of content blocks or a string */
+    content: unknown[] | string;
+    /** Optional ID for tool calls */
+    tool_call_id?: string;
+    /** Optional tool calls for assistant messages */
+    tool_calls?: ToolCall[];
+    /** Additional properties that might be present */
+    [key: string]: unknown;
+}
+/**
+ * Represents a tool call in OpenAI format
+ */
+export interface ToolCall {
+    /** Unique identifier for this tool call */
+    id: string;
+    /** The type of tool call */
+    type: 'function';
+    /** Function call details */
+    function: {
+        /** Name of the function to call */
+        name: string;
+        /** Arguments for the function call as JSON string */
+        arguments: string;
+    };
+}
+/**
+ * Represents a tool definition in OpenAI format
+ */
+export interface Tool {
+    /** The type of tool */
+    type: 'function';
+    /** Function definition */
+    function: {
+        /** Name of the function */
+        name: string;
+        /** Description of what the function does */
+        description?: string;
+        /** JSON schema for the function parameters */
+        parameters?: unknown;
+    };
+}
+/**
+ * OpenAI-compatible message format for conversations
+ */
+export interface OpenAIMessage {
+    /** Role of the message sender */
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    /** Content of the message */
+    content: string | Array<{
+        type: string;
+        text: string;
+    }>;
+    /** Tool call ID for tool messages */
+    tool_call_id?: string;
+    /** Tool calls for assistant messages */
+    tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    /** Name for tool messages */
+    name?: string;
+}
+/**
+ * OpenAI-compatible tool format
+ */
+export interface OpenAITool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, unknown>;
+            required?: string[];
+            additionalProperties?: boolean;
+        };
+    };
+}
+/**
+ * Tool result from execution
+ */
+export interface ToolResult {
+    /** Tool call ID that this result corresponds to */
+    toolCallId: string;
+    /** Name of the tool that was executed */
+    toolName: string;
+    /** Result of the tool execution */
+    result: string;
+    /** Whether the tool execution was successful */
+    success: boolean;
+    /** Error message if execution failed */
+    error?: string;
+    /** Execution metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * LLM inference request parameters
+ */
+export interface LLMInferenceParams {
+    /** Array of messages in the conversation */
+    messages: Message[];
+    /** Available tools for the model to use */
+    tools?: Tool[];
+    /** How the model should use tools */
+    tool_choice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    /** The LLM role to determine which model to use */
+    llmrole: string;
+    /** Maximum number of tokens to generate */
+    max_tokens?: number;
+    /** Temperature for response generation */
+    temperature?: number;
+    /** Whether to stream the response */
+    stream?: boolean;
+}
+/**
+ * LLM response from inference
+ */
+export interface LLMResponse {
+    /** Generated content */
+    content?: string;
+    /** Tool calls if any */
+    tool_calls?: ToolCall[];
+    /** Finish reason */
+    finish_reason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+    /** Usage statistics */
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * CodeBolt API interface for agent operations
+ */
+export interface CodeboltAPI {
+    /** Chat operations */
+    chat: {
+        /** Send a message to the user */
+        sendMessage(message: string): Promise<void>;
+        /** Get conversation history */
+        getHistory(): Promise<OpenAIMessage[]>;
+        /** Clear conversation history */
+        clearHistory(): Promise<void>;
+        /** Summarize conversation */
+        summarizeConversation(messages: OpenAIMessage[], options?: {
+            maxLength?: number;
+            includeToolCalls?: boolean;
+        }): Promise<string>;
+    };
+    /** LLM operations */
+    llm: {
+        /** Generate LLM response */
+        inference(params: LLMInferenceParams): Promise<LLMResponse>;
+        /** Stream LLM response */
+        stream(params: LLMInferenceParams): AsyncIterable<LLMResponse>;
+    };
+    /** MCP (Micro-Component Platform) operations */
+    mcp: {
+        /** Execute an MCP tool */
+        executeTool(toolName: string, params: unknown): Promise<{
+            data: unknown;
+        }>;
+        /** List available MCP tools */
+        listTools(): Promise<string[]>;
+        /** Get tool schema */
+        getToolSchema(toolName: string): Promise<OpenAITool>;
+    };
+    /** File system operations */
+    fs: {
+        /** Read file content */
+        readFile(path: string): Promise<string>;
+        /** Write file content */
+        writeFile(path: string, content: string): Promise<void>;
+        /** List directory contents */
+        listDir(path: string): Promise<string[]>;
+        /** Check if file exists */
+        exists(path: string): Promise<boolean>;
+    };
+    /** Agent operations */
+    agent?: {
+        /** Start a sub-agent */
+        startAgent(agentName: string, params: unknown): Promise<{
+            data: unknown;
+        }>;
+        /** List available agents */
+        listAgents(): Promise<string[]>;
+    };
+}
+/**
+ * LLM configuration
+ */
+export interface LLMConfig {
+    /** LLM name/role identifier */
+    llmname?: string;
+    /** Model name */
+    model?: string;
+    /** Temperature for generation */
+    temperature?: number;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** API key */
+    apiKey?: string;
+    /** Base URL for API */
+    baseUrl?: string;
+    /** Additional configuration */
+    [key: string]: unknown;
+}
+/**
+ * Agent execution context
+ */
+export interface ExecutionContext {
+    /** Session identifier */
+    sessionId?: string;
+    /** User identifier */
+    userId?: string;
+    /** Conversation identifier */
+    conversationId?: string;
+    /** Request identifier */
+    requestId?: string;
+    /** Execution start time */
+    startTime: string;
+    /** Additional metadata */
+    metadata: Record<string, unknown>;
+}
+/**
+ * Agent execution result
+ */
+export interface AgentExecutionResult {
+    /** Whether execution completed successfully */
+    success: boolean;
+    /** Final response message */
+    response: string;
+    /** Complete conversation history */
+    conversationHistory: OpenAIMessage[];
+    /** Tool execution results */
+    toolResults: ToolResult[];
+    /** Number of iterations performed */
+    iterations: number;
+    /** Whether the agent completed its task */
+    completed: boolean;
+    /** Execution context */
+    context: Record<string, unknown>;
+    /** Error message if execution failed */
+    error?: string;
+    /** Execution metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Agent event types
+ */
+export type AgentEventType = 'AgentStarted' | 'AgentCompleted' | 'AgentError' | 'MessageProcessed' | 'ToolExecuted' | 'ConversationUpdated' | 'IterationCompleted';
+/**
+ * Agent event data
+ */
+export interface AgentEvent {
+    type: AgentEventType;
+    timestamp: string;
+    data: Record<string, unknown>;
+    error?: string;
+}
+/**
+ * Event handler function
+ */
+export type AgentEventHandler = (event: AgentEvent) => void | Promise<void>;
+/**
+ * Deep partial type for configuration objects
+ */
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * Function that can be sync or async
+ */
+export type MaybeAsync<T> = T | Promise<T>;
+/**
+ * Callback function type
+ */
+export type Callback<T = unknown> = (data: T) => void | Promise<void>;
+/**
+ * Error with context information
+ */
+export interface ContextualError extends Error {
+    context?: Record<string, unknown>;
+    code?: string;
+    statusCode?: number;
+}
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+    /** Whether validation passed */
+    isValid: boolean;
+    /** Validation errors */
+    errors: string[];
+    /** Validation warnings */
+    warnings: string[];
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Schema validation function
+ */
+export type SchemaValidator<T = unknown> = (data: unknown) => ValidationResult & {
+    data?: T;
+};
+/**
+ * Stream chunk for real-time responses
+ */
+export interface StreamChunk {
+    /** Type of chunk */
+    type: 'text' | 'tool_call' | 'tool_result' | 'error' | 'done';
+    /** Chunk content */
+    content: string;
+    /** Tool call information if applicable */
+    toolCall?: ToolCall;
+    /** Tool result if applicable */
+    toolResult?: ToolResult;
+    /** Error information if applicable */
+    error?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Stream callback function
+ */
+export type StreamCallback = (chunk: StreamChunk) => void | Promise<void>;
+/**
+ * Memory storage interface
+ */
+export interface MemoryStorage {
+    /** Store data */
+    set(key: string, value: unknown): Promise<void>;
+    /** Retrieve data */
+    get(key: string): Promise<unknown>;
+    /** Delete data */
+    delete(key: string): Promise<void>;
+    /** List all keys */
+    keys(): Promise<string[]>;
+    /** Clear all data */
+    clear(): Promise<void>;
+}
+/**
+ * Conversation memory entry
+ */
+export interface ConversationMemory {
+    /** Conversation ID */
+    id: string;
+    /** Messages in the conversation */
+    messages: OpenAIMessage[];
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+    /** Additional metadata */
+    metadata: Record<string, unknown>;
+}
+export type { Message as LibMessage, ToolCall as LibToolCall, Tool as LibTool, OpenAIMessage as LibOpenAIMessage, OpenAITool as LibOpenAITool, ToolResult as LibToolResult, LLMInferenceParams as LibLLMInferenceParams, LLMResponse as LibLLMResponse, CodeboltAPI as LibCodeboltAPI, LLMConfig as LibLLMConfig, ExecutionContext as LibExecutionContext, AgentExecutionResult as LibAgentExecutionResult, AgentEvent as LibAgentEvent, AgentEventHandler as LibAgentEventHandler, StreamChunk as LibStreamChunk, StreamCallback as LibStreamCallback, MemoryStorage as LibMemoryStorage, ConversationMemory as LibConversationMemory };

package/dist/unified/types/libTypes.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Library types for the Unified Agent Framework
+ * Self-contained within the unified directory
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/unified/types/types.d.ts

@@ -0,0 +1,212 @@
+import { Processor } from 'src/types/processorTypes';
+import type { OpenAIMessage, OpenAITool, ToolResult, CodeboltAPI } from './libTypes';
+/**
+ * Configuration for the unified agent
+ */
+export interface UnifiedAgentConfig {
+    /** Maximum iterations for agent loops */
+    maxIterations?: number;
+    /** Maximum conversation length before summarization */
+    maxConversationLength?: number;
+    /** LLM configuration */
+    llmConfig?: LLMConfig;
+    /** Codebolt API instance */
+    codebolt?: CodeboltAPI;
+    /** Enable logging */
+    enableLogging?: boolean;
+    /** Retry configuration */
+    retryConfig?: {
+        maxRetries?: number;
+        retryDelay?: number;
+    };
+}
+/**
+ * LLM configuration for the unified agent
+ */
+export interface LLMConfig {
+    llmname?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    apiKey?: string;
+    baseUrl?: string;
+}
+/**
+ * Output from unified message processing
+ */
+export interface UnifiedMessageOutput {
+    /** Processed messages ready for LLM */
+    messages: OpenAIMessage[];
+    /** Available tools */
+    tools: OpenAITool[];
+    /** Updated context */
+    context: Record<string, any>;
+    /** Tool choice strategy */
+    toolChoice: 'auto' | 'none' | 'required';
+}
+/**
+ * Input for unified agent step processing
+ */
+export interface UnifiedStepInput {
+    /** Processed messages */
+    messages: OpenAIMessage[];
+    /** Available tools */
+    tools: OpenAITool[];
+    /** Processing context */
+    context?: Record<string, any>;
+    /** Tool choice strategy */
+    toolChoice?: 'auto' | 'none' | 'required';
+}
+/**
+ * Output from unified agent step processing
+ */
+export interface UnifiedStepOutput {
+    /** LLM response */
+    llmResponse: any;
+    /** Whether processing is complete */
+    finished: boolean;
+    /** Tool calls detected */
+    toolCalls?: Array<{
+        tool: string;
+        parameters: any;
+    }>;
+    /** Updated context */
+    context: Record<string, any>;
+}
+/**
+ * Input for unified response execution
+ */
+export interface UnifiedResponseInput {
+    /** LLM response to process */
+    llmResponse: any;
+    /** Previous conversation messages */
+    conversationHistory: OpenAIMessage[];
+    /** Available tools */
+    tools: OpenAITool[];
+    /** Processing context */
+    context?: Record<string, any>;
+}
+/**
+ * Output from unified response execution
+ */
+export interface UnifiedResponseOutput {
+    /** Tool execution results */
+    toolResults: ToolResult[];
+    /** Next user message (if any) */
+    nextUserMessage: OpenAIMessage | null;
+    /** Updated conversation history */
+    conversationHistory: OpenAIMessage[];
+    /** Whether task is completed */
+    completed: boolean;
+    /** Final response message */
+    finalMessage?: string;
+}
+/**
+ * Complete agent execution input
+ */
+export interface UnifiedAgentInput {
+    /** User message or request */
+    userMessage: any;
+    /** Available tools */
+    tools?: OpenAITool[];
+    /** Processing context */
+    context?: Record<string, any>;
+    /** Previous conversation history */
+    conversationHistory?: OpenAIMessage[];
+    /** Maximum iterations for this execution */
+    maxIterations?: number;
+}
+/**
+ * Complete agent execution output
+ */
+export interface UnifiedAgentOutput {
+    /** Final response message */
+    response: string;
+    /** Tool execution results */
+    toolResults: ToolResult[];
+    /** Updated conversation history */
+    conversationHistory: OpenAIMessage[];
+    /** Final context state */
+    context: Record<string, any>;
+    /** Whether task was completed successfully */
+    completed: boolean;
+    /** Number of iterations used */
+    iterations: number;
+}
+/**
+ * Unified message modifier interface
+ */
+export interface UnifiedMessageModifier {
+    /** Process and modify input messages */
+    processMessage(input: any): Promise<UnifiedMessageOutput>;
+    /** Add a processor to the modifier */
+    addProcessor(processor: Processor): void;
+    /** Set context value */
+    setContext(key: string, value: any): void;
+    /** Get context value */
+    getContext(key: string): any;
+    /** Clear all context */
+    clearContext(): void;
+}
+/**
+ * Unified response executor interface
+ */
+export interface UnifiedResponseExecutor {
+    /** Execute response processing including tool execution */
+    executeResponse(input: UnifiedResponseInput): Promise<UnifiedResponseOutput>;
+    /** Execute tools from LLM response */
+    executeTools(llmResponse: any, tools: OpenAITool[], context?: Record<string, any>): Promise<ToolResult[]>;
+    /** Build follow-up conversation */
+    buildFollowUpConversation(conversationHistory: OpenAIMessage[], toolResults: ToolResult[], llmResponse: any): Promise<OpenAIMessage[]>;
+    /** Check if conversation needs summarization */
+    shouldSummarizeConversation(conversationHistory: OpenAIMessage[]): boolean;
+    /** Summarize conversation */
+    summarizeConversation(conversationHistory: OpenAIMessage[]): Promise<OpenAIMessage[]>;
+    /** Add a follow-up conversation processor */
+    addFollowUpConversationProcessor(processor: Processor): void;
+    /** Remove a follow-up conversation processor */
+    removeFollowUpConversationProcessor(processor: Processor): boolean;
+    /** Get all follow-up conversation processors */
+    getFollowUpConversationProcessors(): Processor[];
+    /** Clear all follow-up conversation processors */
+    clearFollowUpConversationProcessors(): void;
+    /** Add a pre-tool call processor */
+    addPreToolCallProcessor(processor: Processor): void;
+    /** Remove a pre-tool call processor */
+    removePreToolCallProcessor(processor: Processor): boolean;
+    /** Get all pre-tool call processors */
+    getPreToolCallProcessors(): Processor[];
+    /** Clear all pre-tool call processors */
+    clearPreToolCallProcessors(): void;
+}
+/**
+ * Main unified agent interface
+ */
+export type UnifiedAgentEventType = 'message_processed' | 'step_started' | 'step_completed' | 'tool_call_detected' | 'tool_execution_started' | 'tool_execution_completed' | 'response_generated' | 'conversation_summarized' | 'agent_completed' | 'agent_error' | 'iteration_started' | 'iteration_completed';
+export interface UnifiedAgentEvent {
+    type: UnifiedAgentEventType;
+    data?: any;
+    timestamp: string;
+    context?: Record<string, any>;
+}
+/**
+ * Event handler for unified agent events
+ */
+export type UnifiedAgentEventHandler = (event: UnifiedAgentEvent) => void | Promise<void>;
+export declare class UnifiedAgentError extends Error {
+    readonly code: string;
+    readonly context?: Record<string, any> | undefined;
+    constructor(message: string, code: string, context?: Record<string, any> | undefined);
+}
+export declare class UnifiedMessageProcessingError extends UnifiedAgentError {
+    constructor(message: string, context?: Record<string, any>);
+}
+export declare class UnifiedStepExecutionError extends UnifiedAgentError {
+    constructor(message: string, context?: Record<string, any>);
+}
+export declare class UnifiedResponseExecutionError extends UnifiedAgentError {
+    constructor(message: string, context?: Record<string, any>);
+}
+export declare class UnifiedToolExecutionError extends UnifiedAgentError {
+    constructor(message: string, context?: Record<string, any>);
+}

package/dist/unified/types/types.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedToolExecutionError = exports.UnifiedResponseExecutionError = exports.UnifiedStepExecutionError = exports.UnifiedMessageProcessingError = exports.UnifiedAgentError = void 0;
+// ================================
+// Error Types
+// ================================
+class UnifiedAgentError extends Error {
+    constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = 'UnifiedAgentError';
+    }
+}
+exports.UnifiedAgentError = UnifiedAgentError;
+class UnifiedMessageProcessingError extends UnifiedAgentError {
+    constructor(message, context) {
+        super(message, 'MESSAGE_PROCESSING_ERROR', context);
+        this.name = 'UnifiedMessageProcessingError';
+    }
+}
+exports.UnifiedMessageProcessingError = UnifiedMessageProcessingError;
+class UnifiedStepExecutionError extends UnifiedAgentError {
+    constructor(message, context) {
+        super(message, 'STEP_EXECUTION_ERROR', context);
+        this.name = 'UnifiedStepExecutionError';
+    }
+}
+exports.UnifiedStepExecutionError = UnifiedStepExecutionError;
+class UnifiedResponseExecutionError extends UnifiedAgentError {
+    constructor(message, context) {
+        super(message, 'RESPONSE_EXECUTION_ERROR', context);
+        this.name = 'UnifiedResponseExecutionError';
+    }
+}
+exports.UnifiedResponseExecutionError = UnifiedResponseExecutionError;
+class UnifiedToolExecutionError extends UnifiedAgentError {
+    constructor(message, context) {
+        super(message, 'TOOL_EXECUTION_ERROR', context);
+        this.name = 'UnifiedToolExecutionError';
+    }
+}
+exports.UnifiedToolExecutionError = UnifiedToolExecutionError;

package/dist/unified/utils/utils.d.ts

@@ -0,0 +1,40 @@
+import type { UnifiedAgentConfig } from '../types/types';
+/**
+ * Advanced agent creation with full configuration
+ */
+/**
+ * Utility to create a testing agent with minimal configuration
+ */
+/**
+ * Utility to validate agent configuration
+ */
+export declare function validateAgentConfig(config: UnifiedAgentConfig): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * Utility to create agent from environment variables
+ */
+/**
+ * Utility to benchmark agent performance
+ */
+export declare function benchmarkAgent(agent: any, testCases: Array<{
+    name: string;
+    input: any;
+    expectedOutput?: any;
+}>): Promise<{
+    results: Array<{
+        name: string;
+        success: boolean;
+        duration: number;
+        output: any;
+        error?: string;
+    }>;
+    summary: {
+        totalTests: number;
+        passed: number;
+        failed: number;
+        averageDuration: number;
+    };
+}>;