@codebolt/agent 1.1.0 → 2.2.2

package/dist/composablepattern/types.d.ts

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview Type definitions for the Composable Agent Pattern
+ * @description Re-exports types from @codebolt/types and adds additional types
+ */
+import { z } from 'zod';
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | MessageContent[];
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    timestamp?: string;
+    metadata?: Record<string, any>;
+}
+export interface MessageContent {
+    type: 'text' | 'image' | 'file';
+    text?: string;
+    image_url?: string;
+    file?: string;
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolConfig<TInput = any, TOutput = any> {
+    id: string;
+    description: string;
+    inputSchema: z.ZodType<TInput>;
+    outputSchema: z.ZodType<TOutput>;
+    execute: (params: {
+        context: TInput;
+        agent?: ComposableAgent;
+    }) => Promise<TOutput>;
+}
+export interface Tool<TInput = any, TOutput = any> extends ToolConfig<TInput, TOutput> {
+    validateInput: (input: unknown) => TInput;
+    validateOutput: (output: unknown) => TOutput;
+}
+export interface StorageProvider {
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+}
+export interface LibSQLStoreConfig {
+    url: string;
+    authToken?: string;
+    tableName?: string;
+}
+export interface MemoryConfig {
+    storage: StorageProvider;
+    maxMessages?: number;
+    autoSave?: boolean;
+}
+export interface AgentProcessingConfig {
+    processMentionedMCPs?: boolean;
+    processRemixPrompt?: boolean;
+    processMentionedFiles?: boolean;
+    processMentionedAgents?: boolean;
+    fileContentProcessor?: (filePath: string) => Promise<string>;
+    mcpToolProcessor?: (toolbox: string, toolName: string) => Promise<Tool | null>;
+}
+export interface ComposableAgentConfig {
+    name: string;
+    instructions: string;
+    model: string;
+    tools?: Record<string, Tool>;
+    memory?: any;
+    maxTurns?: number;
+    processing?: AgentProcessingConfig;
+    metadata?: Record<string, any>;
+}
+export interface ExecutionResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+    conversation: Message[];
+    metadata?: Record<string, any>;
+}
+export interface StreamChunk {
+    type: 'text' | 'tool_call' | 'tool_result' | 'error';
+    content: string;
+    tool_call?: ToolCall;
+    metadata?: Record<string, any>;
+}
+export type StreamCallback = (chunk: StreamChunk) => void | Promise<void>;
+export interface ComposableAgent {
+    readonly config: ComposableAgentConfig;
+    execute(message: string, options?: {
+        stream?: boolean;
+        callback?: StreamCallback;
+    }): Promise<ExecutionResult>;
+    executeMessage(message: CodeBoltMessage, options?: {
+        stream?: boolean;
+        callback?: StreamCallback;
+    }): Promise<ExecutionResult>;
+    run(options?: {
+        stream?: boolean;
+        callback?: StreamCallback;
+    }): Promise<ExecutionResult>;
+    addMessage(message: Message): void;
+    getConversation(): Message[];
+    clearConversation(): void;
+    saveConversation(): Promise<void>;
+    loadConversation(): Promise<void>;
+}
+export interface CodeBoltMessage {
+    userMessage: string;
+    mentionedFiles?: string[];
+    mentionedMCPs: {
+        toolbox: string;
+        toolName: string;
+    }[];
+    mentionedAgents: any[];
+    remixPrompt?: string;
+}
+export interface DocumentConfig {
+    content: string;
+    type?: 'text' | 'markdown' | 'json' | 'xml';
+    metadata?: Record<string, any>;
+}
+export interface ProcessedDocument {
+    content: string;
+    chunks?: string[];
+    metadata: Record<string, any>;
+    embeddings?: number[][];
+}
+export interface WorkflowContext {
+    data: Record<string, any>;
+    history: WorkflowStepResult[];
+    currentStep: number;
+    metadata: Record<string, any>;
+}
+export interface WorkflowStepResult {
+    stepId: string;
+    success: boolean;
+    output?: any;
+    error?: string;
+    executionTime: number;
+    metadata?: Record<string, any>;
+}
+export interface WorkflowStep {
+    id: string;
+    name: string;
+    description?: string;
+    inputSchema?: any;
+    outputSchema?: any;
+    execute: (context: WorkflowContext) => Promise<WorkflowStepResult>;
+    condition?: (context: WorkflowContext) => boolean | Promise<boolean>;
+    dependencies?: string[];
+    parallel?: boolean;
+    retry?: {
+        maxAttempts: number;
+        delay: number;
+        backoff?: 'linear' | 'exponential';
+    };
+}
+export interface WorkflowConfig {
+    name: string;
+    description?: string;
+    steps: WorkflowStep[];
+    initialData?: Record<string, any>;
+    timeout?: number;
+    continueOnError?: boolean;
+    maxParallelSteps?: number;
+}
+export interface WorkflowResult {
+    success: boolean;
+    data: Record<string, any>;
+    stepResults: WorkflowStepResult[];
+    executionTime: number;
+    error?: string;
+    metadata: Record<string, any>;
+}
+export interface AgentStepConfig {
+    agent: ComposableAgent;
+    messageTemplate: string;
+    inputMapping?: Record<string, string>;
+    outputMapping?: Record<string, string>;
+}
+export interface ExecutionContext {
+    /** Current conversation history */
+    messages: Message[];
+    /** Available tools */
+    tools: Record<string, Tool>;
+    /** Agent configuration */
+    config: ComposableAgentConfig;
+    /** Execution metadata */
+    metadata?: Record<string, any>;
+}

package/dist/composablepattern/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @fileoverview Type definitions for the Composable Agent Pattern
+ * @description Re-exports types from @codebolt/types and adds additional types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/composablepattern/user-context.d.ts

@@ -0,0 +1,214 @@
+/**
+ * @fileoverview User Context Management for CodeBolt Integration
+ * @description Manages user message state and configuration for ComposableAgent
+ */
+import type { CodeBoltMessage } from './types';
+/**
+ * Global user context state
+ */
+interface UserContextState {
+    /** Current user message */
+    currentMessage?: CodeBoltMessage;
+    /** User configuration for processing */
+    userConfig?: {
+        processMentionedMCPs?: boolean;
+        processRemixPrompt?: boolean;
+        processMentionedFiles?: boolean;
+        processMentionedAgents?: boolean;
+    };
+    /** Session data */
+    sessionData?: Record<string, any>;
+}
+/**
+ * Global user context manager
+ */
+declare class UserContextManager {
+    private state;
+    /**
+     * Save user message and extract configuration
+     *
+     * @param message - CodeBolt message from onMessage
+     * @param config - Optional user configuration override
+     */
+    saveUserMessage(message: CodeBoltMessage, config?: UserContextState['userConfig']): void;
+    /**
+     * Get current user message
+     *
+     * @returns Current CodeBolt message or undefined
+     */
+    getUserMessage(): CodeBoltMessage | undefined;
+    /**
+     * Get user configuration
+     *
+     * @returns User processing configuration
+     */
+    getUserConfig(): UserContextState['userConfig'];
+    /**
+     * Get mentioned MCPs from current message
+     *
+     * @returns Array of mentioned MCP tools
+     */
+    getMentionedMCPs(): {
+        toolbox: string;
+        toolName: string;
+    }[];
+    /**
+     * Get mentioned files from current message
+     *
+     * @returns Array of mentioned file paths
+     */
+    getMentionedFiles(): string[];
+    /**
+     * Get mentioned agents from current message
+     *
+     * @returns Array of mentioned agents
+     */
+    getMentionedAgents(): any[];
+    /**
+     * Get remix prompt from current message
+     *
+     * @returns Remix prompt string or undefined
+     */
+    getRemixPrompt(): string | undefined;
+    /**
+     * Check if a specific processing type is enabled
+     *
+     * @param type - Processing type to check
+     * @returns Whether the processing type is enabled
+     */
+    isProcessingEnabled(type: keyof NonNullable<UserContextState['userConfig']>): boolean;
+    /**
+     * Set session data
+     *
+     * @param key - Session data key
+     * @param value - Session data value
+     */
+    setSessionData(key: string, value: any): void;
+    /**
+     * Get session data
+     *
+     * @param key - Session data key
+     * @returns Session data value
+     */
+    getSessionData(key: string): any;
+    /**
+     * Clear all user context (typically called at start of new message)
+     */
+    clear(): void;
+    /**
+     * Get current message text content
+     *
+     * @returns User message text
+     */
+    getMessageText(): string;
+    /**
+     * Create a simplified message object for agent execution
+     *
+     * @returns Simple message object with just text content
+     */
+    getSimpleMessage(): {
+        text: string;
+        hasContext: boolean;
+    };
+}
+declare const userContextManager: UserContextManager;
+/**
+ * Save user message and configuration globally
+ * This should be called in codebolt.onMessage() before creating agents
+ *
+ * @param message - CodeBolt message from onMessage
+ * @param config - Optional configuration override
+ */
+export declare function saveUserMessage(message: CodeBoltMessage, config?: {
+    processMentionedMCPs?: boolean;
+    processRemixPrompt?: boolean;
+    processMentionedFiles?: boolean;
+    processMentionedAgents?: boolean;
+}): void;
+/**
+ * Get current user message
+ * Can be called from anywhere in the agent execution
+ *
+ * @returns Current CodeBolt message or undefined
+ */
+export declare function getUserMessage(): CodeBoltMessage | undefined;
+/**
+ * Get user processing configuration
+ *
+ * @returns User configuration object
+ */
+export declare function getUserConfig(): {
+    processMentionedMCPs?: boolean;
+    processRemixPrompt?: boolean;
+    processMentionedFiles?: boolean;
+    processMentionedAgents?: boolean;
+} | undefined;
+/**
+ * Get mentioned MCPs from current message
+ *
+ * @returns Array of mentioned MCP tools
+ */
+export declare function getMentionedMCPs(): {
+    toolbox: string;
+    toolName: string;
+}[];
+/**
+ * Get mentioned files from current message
+ *
+ * @returns Array of mentioned file paths
+ */
+export declare function getMentionedFiles(): string[];
+/**
+ * Get mentioned agents from current message
+ *
+ * @returns Array of mentioned agents
+ */
+export declare function getMentionedAgents(): any[];
+/**
+ * Get remix prompt from current message
+ *
+ * @returns Remix prompt string or undefined
+ */
+export declare function getRemixPrompt(): string | undefined;
+/**
+ * Check if a specific processing type is enabled
+ *
+ * @param type - Processing type to check
+ * @returns Whether the processing type is enabled
+ */
+export declare function isProcessingEnabled(type: 'processMentionedMCPs' | 'processRemixPrompt' | 'processMentionedFiles' | 'processMentionedAgents'): boolean;
+/**
+ * Get simple message text for agent execution
+ *
+ * @returns Message text content
+ */
+export declare function getMessageText(): string;
+/**
+ * Get simplified message object
+ *
+ * @returns Simple message with text and context flag
+ */
+export declare function getSimpleMessage(): {
+    text: string;
+    hasContext: boolean;
+};
+/**
+ * Set session data
+ *
+ * @param key - Session data key
+ * @param value - Session data value
+ */
+export declare function setSessionData(key: string, value: any): void;
+/**
+ * Get session data
+ *
+ * @param key - Session data key
+ * @returns Session data value
+ */
+export declare function getSessionData(key: string): any;
+/**
+ * Clear user context (call at start of new message)
+ */
+export declare function clearUserContext(): void;
+export { userContextManager };
+export type { UserContextState };

package/dist/composablepattern/user-context.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * @fileoverview User Context Management for CodeBolt Integration
+ * @description Manages user message state and configuration for ComposableAgent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userContextManager = void 0;
+exports.saveUserMessage = saveUserMessage;
+exports.getUserMessage = getUserMessage;
+exports.getUserConfig = getUserConfig;
+exports.getMentionedMCPs = getMentionedMCPs;
+exports.getMentionedFiles = getMentionedFiles;
+exports.getMentionedAgents = getMentionedAgents;
+exports.getRemixPrompt = getRemixPrompt;
+exports.isProcessingEnabled = isProcessingEnabled;
+exports.getMessageText = getMessageText;
+exports.getSimpleMessage = getSimpleMessage;
+exports.setSessionData = setSessionData;
+exports.getSessionData = getSessionData;
+exports.clearUserContext = clearUserContext;
+/**
+ * Global user context manager
+ */
+class UserContextManager {
+    constructor() {
+        this.state = {};
+    }
+    /**
+     * Save user message and extract configuration
+     *
+     * @param message - CodeBolt message from onMessage
+     * @param config - Optional user configuration override
+     */
+    saveUserMessage(message, config) {
+        var _a, _b, _c, _d;
+        this.state.currentMessage = message;
+        // Auto-detect configuration from message if not explicitly provided
+        if (config) {
+            this.state.userConfig = { ...config };
+        }
+        else {
+            this.state.userConfig = {
+                processMentionedMCPs: ((_a = message.mentionedMCPs) === null || _a === void 0 ? void 0 : _a.length) > 0,
+                processRemixPrompt: !!message.remixPrompt,
+                processMentionedFiles: ((_c = (_b = message.mentionedFiles) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > 0,
+                processMentionedAgents: ((_d = message.mentionedAgents) === null || _d === void 0 ? void 0 : _d.length) > 0
+            };
+        }
+    }
+    /**
+     * Get current user message
+     *
+     * @returns Current CodeBolt message or undefined
+     */
+    getUserMessage() {
+        return this.state.currentMessage;
+    }
+    /**
+     * Get user configuration
+     *
+     * @returns User processing configuration
+     */
+    getUserConfig() {
+        return this.state.userConfig || {};
+    }
+    /**
+     * Get mentioned MCPs from current message
+     *
+     * @returns Array of mentioned MCP tools
+     */
+    getMentionedMCPs() {
+        var _a;
+        return ((_a = this.state.currentMessage) === null || _a === void 0 ? void 0 : _a.mentionedMCPs) || [];
+    }
+    /**
+     * Get mentioned files from current message
+     *
+     * @returns Array of mentioned file paths
+     */
+    getMentionedFiles() {
+        var _a;
+        return ((_a = this.state.currentMessage) === null || _a === void 0 ? void 0 : _a.mentionedFiles) || [];
+    }
+    /**
+     * Get mentioned agents from current message
+     *
+     * @returns Array of mentioned agents
+     */
+    getMentionedAgents() {
+        var _a;
+        return ((_a = this.state.currentMessage) === null || _a === void 0 ? void 0 : _a.mentionedAgents) || [];
+    }
+    /**
+     * Get remix prompt from current message
+     *
+     * @returns Remix prompt string or undefined
+     */
+    getRemixPrompt() {
+        var _a;
+        return (_a = this.state.currentMessage) === null || _a === void 0 ? void 0 : _a.remixPrompt;
+    }
+    /**
+     * Check if a specific processing type is enabled
+     *
+     * @param type - Processing type to check
+     * @returns Whether the processing type is enabled
+     */
+    isProcessingEnabled(type) {
+        var _a, _b;
+        return (_b = (_a = this.state.userConfig) === null || _a === void 0 ? void 0 : _a[type]) !== null && _b !== void 0 ? _b : false;
+    }
+    /**
+     * Set session data
+     *
+     * @param key - Session data key
+     * @param value - Session data value
+     */
+    setSessionData(key, value) {
+        if (!this.state.sessionData) {
+            this.state.sessionData = {};
+        }
+        this.state.sessionData[key] = value;
+    }
+    /**
+     * Get session data
+     *
+     * @param key - Session data key
+     * @returns Session data value
+     */
+    getSessionData(key) {
+        var _a;
+        return (_a = this.state.sessionData) === null || _a === void 0 ? void 0 : _a[key];
+    }
+    /**
+     * Clear all user context (typically called at start of new message)
+     */
+    clear() {
+        this.state = {};
+    }
+    /**
+     * Get current message text content
+     *
+     * @returns User message text
+     */
+    getMessageText() {
+        var _a;
+        return ((_a = this.state.currentMessage) === null || _a === void 0 ? void 0 : _a.userMessage) || '';
+    }
+    /**
+     * Create a simplified message object for agent execution
+     *
+     * @returns Simple message object with just text content
+     */
+    getSimpleMessage() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return {
+            text: this.getMessageText(),
+            hasContext: !!(((_b = (_a = this.state.currentMessage) === null || _a === void 0 ? void 0 : _a.mentionedFiles) === null || _b === void 0 ? void 0 : _b.length) ||
+                ((_d = (_c = this.state.currentMessage) === null || _c === void 0 ? void 0 : _c.mentionedMCPs) === null || _d === void 0 ? void 0 : _d.length) ||
+                ((_f = (_e = this.state.currentMessage) === null || _e === void 0 ? void 0 : _e.mentionedAgents) === null || _f === void 0 ? void 0 : _f.length) ||
+                ((_g = this.state.currentMessage) === null || _g === void 0 ? void 0 : _g.remixPrompt))
+        };
+    }
+}
+// Global singleton instance
+const userContextManager = new UserContextManager();
+exports.userContextManager = userContextManager;
+/**
+ * Save user message and configuration globally
+ * This should be called in codebolt.onMessage() before creating agents
+ *
+ * @param message - CodeBolt message from onMessage
+ * @param config - Optional configuration override
+ */
+function saveUserMessage(message, config) {
+    userContextManager.saveUserMessage(message, config);
+}
+/**
+ * Get current user message
+ * Can be called from anywhere in the agent execution
+ *
+ * @returns Current CodeBolt message or undefined
+ */
+function getUserMessage() {
+    return userContextManager.getUserMessage();
+}
+/**
+ * Get user processing configuration
+ *
+ * @returns User configuration object
+ */
+function getUserConfig() {
+    return userContextManager.getUserConfig();
+}
+/**
+ * Get mentioned MCPs from current message
+ *
+ * @returns Array of mentioned MCP tools
+ */
+function getMentionedMCPs() {
+    return userContextManager.getMentionedMCPs();
+}
+/**
+ * Get mentioned files from current message
+ *
+ * @returns Array of mentioned file paths
+ */
+function getMentionedFiles() {
+    return userContextManager.getMentionedFiles();
+}
+/**
+ * Get mentioned agents from current message
+ *
+ * @returns Array of mentioned agents
+ */
+function getMentionedAgents() {
+    return userContextManager.getMentionedAgents();
+}
+/**
+ * Get remix prompt from current message
+ *
+ * @returns Remix prompt string or undefined
+ */
+function getRemixPrompt() {
+    return userContextManager.getRemixPrompt();
+}
+/**
+ * Check if a specific processing type is enabled
+ *
+ * @param type - Processing type to check
+ * @returns Whether the processing type is enabled
+ */
+function isProcessingEnabled(type) {
+    return userContextManager.isProcessingEnabled(type);
+}
+/**
+ * Get simple message text for agent execution
+ *
+ * @returns Message text content
+ */
+function getMessageText() {
+    return userContextManager.getMessageText();
+}
+/**
+ * Get simplified message object
+ *
+ * @returns Simple message with text and context flag
+ */
+function getSimpleMessage() {
+    return userContextManager.getSimpleMessage();
+}
+/**
+ * Set session data
+ *
+ * @param key - Session data key
+ * @param value - Session data value
+ */
+function setSessionData(key, value) {
+    userContextManager.setSessionData(key, value);
+}
+/**
+ * Get session data
+ *
+ * @param key - Session data key
+ * @returns Session data value
+ */
+function getSessionData(key) {
+    return userContextManager.getSessionData(key);
+}
+/**
+ * Clear user context (call at start of new message)
+ */
+function clearUserContext() {
+    userContextManager.clear();
+}