@codebolt/agent 1.2.1 → 2.2.3

package/dist/unified/orchestrator/orchestrator.js

@@ -0,0 +1,519 @@
+"use strict";
+/**
+ * Unified Orchestrator for Multi-Agent, Multi-Workflow, Multi-Tool Coordination
+ *
+ * The Orchestrator can dynamically choose and execute agents, workflows, and tools
+ * in any order based on context and user input. Unlike workflows which have fixed
+ * execution order, the orchestrator makes intelligent decisions about what to execute.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedOrchestrator = void 0;
+exports.createOrchestrator = createOrchestrator;
+exports.createRuntimeContext = createRuntimeContext;
+const zod_1 = require("zod");
+const agent_1 = require("../agent/agent");
+const tool_1 = require("../agent/tool");
+// ================================
+// Orchestrator Implementation
+// ================================
+/**
+ * Main Orchestrator class for coordinating agents, workflows, and tools
+ */
+class UnifiedOrchestrator {
+    constructor(config, codebolt) {
+        this.config = {
+            limits: {
+                maxSteps: 20,
+                maxExecutionTime: 600000, // 10 minutes
+                maxMemoryUsage: 100 * 1024 * 1024 // 100MB
+            },
+            decisionConfig: {
+                explainDecisions: true,
+                confidenceThreshold: 0.7,
+                askConfirmation: false
+            },
+            memory: {
+                persistent: false,
+                maxSize: 1000,
+                ttl: 3600000 // 1 hour
+            },
+            ...config
+        };
+        this.codebolt = codebolt;
+        // Create decision-making agent
+        this.decisionAgent = this.createDecisionAgent();
+    }
+    /**
+     * Create the internal decision-making agent
+     */
+    createDecisionAgent() {
+        const decisionTool = (0, tool_1.createTool)({
+            id: 'make-orchestration-decision',
+            name: 'Make Orchestration Decision',
+            description: 'Decide what resource to execute next in the orchestration',
+            inputSchema: zod_1.z.object({
+                userMessage: zod_1.z.string(),
+                availableAgents: zod_1.z.array(zod_1.z.string()),
+                availableWorkflows: zod_1.z.array(zod_1.z.string()),
+                availableTools: zod_1.z.array(zod_1.z.string()),
+                executionHistory: zod_1.z.array(zod_1.z.object({
+                    stepType: zod_1.z.string(),
+                    resourceId: zod_1.z.string(),
+                    success: zod_1.z.boolean(),
+                    output: zod_1.z.unknown()
+                })),
+                contextData: zod_1.z.record(zod_1.z.unknown())
+            }),
+            execute: async ({ input }) => {
+                // This is a placeholder - in a real implementation, this would use
+                // sophisticated decision logic or ML models
+                const { userMessage, availableAgents, availableWorkflows, availableTools, executionHistory } = input;
+                // Simple heuristic-based decision making
+                if (executionHistory.length === 0) {
+                    // First step - analyze what type of task this is
+                    if (userMessage.toLowerCase().includes('workflow') || userMessage.toLowerCase().includes('process')) {
+                        return {
+                            resourceType: 'workflow',
+                            resourceId: availableWorkflows[0],
+                            reasoning: 'User mentioned workflow/process, starting with first available workflow',
+                            confidence: 0.8,
+                            isComplete: false
+                        };
+                    }
+                    else if (availableAgents.length > 0) {
+                        return {
+                            resourceType: 'agent',
+                            resourceId: availableAgents[0],
+                            reasoning: 'Starting with first available agent for general task',
+                            confidence: 0.7,
+                            isComplete: false
+                        };
+                    }
+                }
+                // Check if we have enough information to complete
+                const lastStep = executionHistory[executionHistory.length - 1];
+                if (lastStep && lastStep.success) {
+                    return {
+                        resourceType: 'complete',
+                        reasoning: 'Task appears to be completed successfully',
+                        confidence: 0.9,
+                        isComplete: true
+                    };
+                }
+                return {
+                    resourceType: 'complete',
+                    reasoning: 'No clear next step identified',
+                    confidence: 0.5,
+                    isComplete: true
+                };
+            }
+        });
+        return new agent_1.Agent({
+            name: 'Orchestrator Decision Agent',
+            instructions: `${this.config.instructions}
+
+You are the decision-making component of an orchestrator. Your job is to analyze the current situation and decide what resource (agent, workflow, or tool) should be executed next.
+
+Available resources:
+- Agents: ${Object.keys(this.config.agents).join(', ')}
+- Workflows: ${Object.keys(this.config.workflows).join(', ')}
+- Tools: ${Object.keys(this.config.tools || {}).join(', ')}
+
+Consider:
+1. The user's request and intent
+2. What has already been executed
+3. What information or capabilities are needed next
+4. Whether the task is complete
+
+Always use the make-orchestration-decision tool to provide structured decisions.`,
+            tools: [decisionTool],
+            llmConfig: this.config.llmConfig
+        });
+    }
+    /**
+     * Execute orchestration loop
+     */
+    async loop(userMessage, options = {}) {
+        const startTime = Date.now();
+        // Initialize runtime context
+        const context = this.initializeRuntimeContext(userMessage, options.runtimeContext);
+        try {
+            // Apply processors if configured
+            if (this.config.processors) {
+                await this.applyProcessors(userMessage, context);
+            }
+            // Main orchestration loop
+            while (!this.shouldStop(context)) {
+                const decision = await this.makeDecision(userMessage, context);
+                if (decision.isComplete) {
+                    break;
+                }
+                await this.executeDecision(decision, context);
+                context.currentStep++;
+            }
+            const totalExecutionTime = Date.now() - startTime;
+            return this.createSuccessResult(context, totalExecutionTime);
+        }
+        catch (error) {
+            const totalExecutionTime = Date.now() - startTime;
+            return this.createErrorResult(context, error, totalExecutionTime);
+        }
+    }
+    /**
+     * Initialize runtime context
+     */
+    initializeRuntimeContext(userMessage, partial) {
+        var _a;
+        return {
+            sessionId: (partial === null || partial === void 0 ? void 0 : partial.sessionId) || this.generateSessionId(),
+            userId: partial === null || partial === void 0 ? void 0 : partial.userId,
+            conversationState: (partial === null || partial === void 0 ? void 0 : partial.conversationState) || { userMessage },
+            executionHistory: (partial === null || partial === void 0 ? void 0 : partial.executionHistory) || [],
+            memory: (partial === null || partial === void 0 ? void 0 : partial.memory) || new Map(),
+            currentStep: (partial === null || partial === void 0 ? void 0 : partial.currentStep) || 0,
+            maxSteps: (partial === null || partial === void 0 ? void 0 : partial.maxSteps) || ((_a = this.config.limits) === null || _a === void 0 ? void 0 : _a.maxSteps) || 20,
+            startTime: new Date().toISOString(),
+            customData: (partial === null || partial === void 0 ? void 0 : partial.customData) || {}
+        };
+    }
+    /**
+     * Generate unique session ID
+     */
+    generateSessionId() {
+        return `orch_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Apply orchestrator processors
+     */
+    async applyProcessors(userMessage, context) {
+        if (!this.config.processors)
+            return;
+        for (const processor of this.config.processors) {
+            try {
+                const input = {
+                    message: {
+                        messages: [{
+                                role: 'user',
+                                content: userMessage
+                            }],
+                        metadata: {
+                            sessionId: context.sessionId,
+                            step: context.currentStep
+                        }
+                    },
+                    context: context.conversationState
+                };
+                await processor.processInput(input);
+            }
+            catch (error) {
+                console.warn('Orchestrator processor failed:', error);
+            }
+        }
+    }
+    /**
+     * Make orchestration decision
+     */
+    async makeDecision(userMessage, context) {
+        const decisionInput = {
+            userMessage,
+            availableAgents: Object.keys(this.config.agents),
+            availableWorkflows: Object.keys(this.config.workflows),
+            availableTools: Object.keys(this.config.tools || {}),
+            executionHistory: context.executionHistory.map(step => ({
+                stepType: step.stepType,
+                resourceId: step.resourceId,
+                success: step.success,
+                output: step.output
+            })),
+            contextData: context.conversationState
+        };
+        const result = await this.decisionAgent.execute(`Analyze the current situation and decide what to execute next: ${JSON.stringify(decisionInput)}`);
+        // Extract decision from agent response
+        // In a real implementation, this would parse the structured tool output
+        const decision = {
+            resourceType: 'agent', // Default fallback
+            resourceId: Object.keys(this.config.agents)[0],
+            reasoning: 'Default decision - execute first available agent',
+            confidence: 0.5,
+            isComplete: context.currentStep >= context.maxSteps,
+            input: { message: userMessage, context: context.conversationState }
+        };
+        // Record decision in execution history
+        context.executionHistory.push({
+            stepId: `decision_${context.currentStep}`,
+            stepType: 'decision',
+            resourceId: 'decision-agent',
+            resourceName: 'Decision Making',
+            input: decisionInput,
+            output: decision,
+            success: true,
+            executionTime: 0,
+            timestamp: new Date().toISOString(),
+            metadata: { confidence: decision.confidence }
+        });
+        return decision;
+    }
+    /**
+     * Execute orchestration decision
+     */
+    async executeDecision(decision, context) {
+        var _a, _b;
+        const stepId = `step_${context.currentStep}`;
+        const startTime = Date.now();
+        try {
+            let result;
+            let resourceName;
+            switch (decision.resourceType) {
+                case 'agent':
+                    if (!decision.resourceId || !this.config.agents[decision.resourceId]) {
+                        throw new Error(`Agent not found: ${decision.resourceId}`);
+                    }
+                    const agent = this.config.agents[decision.resourceId];
+                    resourceName = agent.config.name;
+                    const agentInput = typeof decision.input === 'object' && decision.input && 'message' in decision.input
+                        ? decision.input.message
+                        : String(decision.input);
+                    result = await agent.execute(agentInput);
+                    break;
+                case 'workflow':
+                    if (!decision.resourceId || !this.config.workflows[decision.resourceId]) {
+                        throw new Error(`Workflow not found: ${decision.resourceId}`);
+                    }
+                    const workflow = this.config.workflows[decision.resourceId];
+                    resourceName = `Workflow: ${decision.resourceId}`;
+                    // Update workflow context with current data
+                    if (decision.input && typeof decision.input === 'object') {
+                        workflow.updateContext(decision.input);
+                    }
+                    result = await workflow.execute();
+                    break;
+                case 'tool':
+                    if (!decision.resourceId || !((_a = this.config.tools) === null || _a === void 0 ? void 0 : _a[decision.resourceId])) {
+                        throw new Error(`Tool not found: ${decision.resourceId}`);
+                    }
+                    const tool = this.config.tools[decision.resourceId];
+                    resourceName = tool.function.name;
+                    result = await (0, tool_1.executeTool)(tool, decision.input, this.codebolt);
+                    break;
+                default:
+                    throw new Error(`Unknown resource type: ${decision.resourceType}`);
+            }
+            // Record successful execution
+            const executionStep = {
+                stepId,
+                stepType: decision.resourceType,
+                resourceId: decision.resourceId,
+                resourceName,
+                input: decision.input,
+                output: result,
+                success: true,
+                executionTime: Date.now() - startTime,
+                timestamp: new Date().toISOString(),
+                metadata: {
+                    reasoning: decision.reasoning,
+                    confidence: decision.confidence
+                }
+            };
+            context.executionHistory.push(executionStep);
+            // Update conversation state with results
+            if (result && typeof result === 'object') {
+                context.conversationState = {
+                    ...context.conversationState,
+                    [`${decision.resourceType}_${decision.resourceId}_result`]: result
+                };
+            }
+            // Update memory if configured
+            if ((_b = this.config.memory) === null || _b === void 0 ? void 0 : _b.persistent) {
+                context.memory.set(`step_${context.currentStep}`, result);
+            }
+        }
+        catch (error) {
+            // Record failed execution
+            const executionStep = {
+                stepId,
+                stepType: decision.resourceType,
+                resourceId: decision.resourceId || 'unknown',
+                resourceName: decision.resourceId || 'Unknown Resource',
+                input: decision.input,
+                output: null,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                executionTime: Date.now() - startTime,
+                timestamp: new Date().toISOString(),
+                metadata: {
+                    reasoning: decision.reasoning,
+                    confidence: decision.confidence
+                }
+            };
+            context.executionHistory.push(executionStep);
+            throw error; // Re-throw to be handled by main loop
+        }
+    }
+    /**
+     * Check if orchestration should stop
+     */
+    shouldStop(context) {
+        var _a, _b;
+        // Stop if max steps reached
+        if (context.currentStep >= context.maxSteps) {
+            return true;
+        }
+        // Stop if max execution time reached
+        const elapsed = Date.now() - new Date(context.startTime).getTime();
+        if (((_a = this.config.limits) === null || _a === void 0 ? void 0 : _a.maxExecutionTime) && elapsed > this.config.limits.maxExecutionTime) {
+            return true;
+        }
+        // Stop if memory limit reached
+        if ((_b = this.config.limits) === null || _b === void 0 ? void 0 : _b.maxMemoryUsage) {
+            const memoryUsage = this.estimateMemoryUsage(context);
+            if (memoryUsage > this.config.limits.maxMemoryUsage) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Estimate memory usage (simplified)
+     */
+    estimateMemoryUsage(context) {
+        return JSON.stringify(context).length * 2; // Rough estimate
+    }
+    /**
+     * Create successful orchestration result
+     */
+    createSuccessResult(context, totalExecutionTime) {
+        const metrics = this.calculateMetrics(context);
+        // Generate final response based on execution history
+        const finalResponse = this.generateFinalResponse(context);
+        return {
+            sessionId: context.sessionId,
+            success: true,
+            response: finalResponse,
+            executionSteps: context.executionHistory,
+            finalContext: context,
+            totalExecutionTime,
+            metrics
+        };
+    }
+    /**
+     * Create error orchestration result
+     */
+    createErrorResult(context, error, totalExecutionTime) {
+        const metrics = this.calculateMetrics(context);
+        return {
+            sessionId: context.sessionId,
+            success: false,
+            response: `Orchestration failed: ${error instanceof Error ? error.message : String(error)}`,
+            executionSteps: context.executionHistory,
+            finalContext: context,
+            totalExecutionTime,
+            error: error instanceof Error ? error.message : String(error),
+            metrics
+        };
+    }
+    /**
+     * Calculate orchestration metrics
+     */
+    calculateMetrics(context) {
+        const steps = context.executionHistory;
+        return {
+            totalSteps: steps.length,
+            agentsExecuted: steps.filter(s => s.stepType === 'agent').length,
+            workflowsExecuted: steps.filter(s => s.stepType === 'workflow').length,
+            toolsExecuted: steps.filter(s => s.stepType === 'tool').length,
+            decisionsMade: steps.filter(s => s.stepType === 'decision').length,
+            averageConfidence: this.calculateAverageConfidence(steps),
+            memoryOperations: context.memory.size
+        };
+    }
+    /**
+     * Calculate average confidence from decisions
+     */
+    calculateAverageConfidence(steps) {
+        const decisions = steps.filter(s => s.stepType === 'decision' && s.metadata.confidence);
+        if (decisions.length === 0)
+            return 0;
+        const totalConfidence = decisions.reduce((sum, step) => sum + step.metadata.confidence, 0);
+        return totalConfidence / decisions.length;
+    }
+    /**
+     * Generate final response based on execution history
+     */
+    generateFinalResponse(context) {
+        const successfulSteps = context.executionHistory.filter(s => s.success && s.stepType !== 'decision');
+        if (successfulSteps.length === 0) {
+            return "I wasn't able to complete any tasks successfully.";
+        }
+        const lastStep = successfulSteps[successfulSteps.length - 1];
+        // Extract meaningful response from the last successful step
+        if (lastStep.output && typeof lastStep.output === 'object') {
+            const output = lastStep.output;
+            if ('response' in output && typeof output.response === 'string') {
+                return output.response;
+            }
+            if ('result' in output && typeof output.result === 'string') {
+                return output.result;
+            }
+        }
+        return `Completed orchestration with ${successfulSteps.length} successful steps. The final step was executed by ${lastStep.resourceName}.`;
+    }
+    /**
+     * Add agent to orchestrator
+     */
+    addAgent(id, agent) {
+        this.config.agents[id] = agent;
+    }
+    /**
+     * Add workflow to orchestrator
+     */
+    addWorkflow(id, workflow) {
+        this.config.workflows[id] = workflow;
+    }
+    /**
+     * Add tool to orchestrator
+     */
+    addTool(id, tool) {
+        if (!this.config.tools) {
+            this.config.tools = {};
+        }
+        this.config.tools[id] = tool;
+    }
+    /**
+     * Get orchestrator configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update orchestrator configuration
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+    }
+}
+exports.UnifiedOrchestrator = UnifiedOrchestrator;
+// ================================
+// Factory Functions
+// ================================
+/**
+ * Create a new orchestrator instance
+ */
+function createOrchestrator(config, codebolt) {
+    return new UnifiedOrchestrator(config, codebolt);
+}
+/**
+ * Create runtime context
+ */
+function createRuntimeContext(options = {}) {
+    return {
+        sessionId: options.sessionId || `ctx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        userId: options.userId,
+        conversationState: options.conversationState || {},
+        executionHistory: options.executionHistory || [],
+        memory: options.memory || new Map(),
+        currentStep: options.currentStep || 0,
+        maxSteps: options.maxSteps || 20,
+        startTime: options.startTime || new Date().toISOString(),
+        customData: options.customData || {}
+    };
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/unified/team/team.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });