@codebolt/agent 2.2.2 → 2.2.3

package/dist/unified/orchestrator/orchestrator.d.ts

@@ -0,0 +1,260 @@
+/**
+ * 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.
+ */
+import type { OpenAITool, CodeboltAPI, LLMConfig } from '../types/libTypes';
+import type { Processor } from '../types/processorTypes';
+import type { UnifiedWorkflow } from '../agent/workflow';
+import { Agent } from '../agent/agent';
+/**
+ * Runtime context for orchestrator execution
+ */
+export interface RuntimeContext {
+    /** Unique execution session ID */
+    sessionId: string;
+    /** User identifier */
+    userId?: string;
+    /** Current conversation state */
+    conversationState: Record<string, unknown>;
+    /** Execution history */
+    executionHistory: OrchestratorExecutionStep[];
+    /** Shared memory across executions */
+    memory: Map<string, unknown>;
+    /** Current step in the orchestration */
+    currentStep: number;
+    /** Maximum steps allowed */
+    maxSteps: number;
+    /** Execution start time */
+    startTime: string;
+    /** Custom context data */
+    customData: Record<string, unknown>;
+}
+/**
+ * Orchestrator execution step result
+ */
+export interface OrchestratorExecutionStep {
+    /** Step ID */
+    stepId: string;
+    /** Step type */
+    stepType: 'agent' | 'workflow' | 'tool' | 'decision' | 'memory';
+    /** Resource that was executed */
+    resourceId: string;
+    /** Resource name */
+    resourceName: string;
+    /** Input provided to the resource */
+    input: unknown;
+    /** Output from the resource */
+    output: unknown;
+    /** Whether execution was successful */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Execution time in milliseconds */
+    executionTime: number;
+    /** Timestamp */
+    timestamp: string;
+    /** Additional metadata */
+    metadata: Record<string, unknown>;
+}
+/**
+ * Orchestrator decision result
+ */
+export interface OrchestratorDecision {
+    /** What type of resource to execute next */
+    resourceType: 'agent' | 'workflow' | 'tool' | 'complete' | 'clarify';
+    /** ID of the resource to execute */
+    resourceId?: string;
+    /** Input to provide to the resource */
+    input?: unknown;
+    /** Reasoning behind the decision */
+    reasoning: string;
+    /** Confidence level (0-1) */
+    confidence: number;
+    /** Whether this completes the orchestration */
+    isComplete: boolean;
+    /** Follow-up actions needed */
+    followUpActions?: string[];
+}
+/**
+ * Orchestrator configuration
+ */
+export interface OrchestratorConfig {
+    /** Orchestrator name */
+    name: string;
+    /** Orchestrator description */
+    description?: string;
+    /** Instructions for decision making */
+    instructions: string;
+    /** LLM configuration for decision making */
+    llmConfig?: LLMConfig;
+    /** Available agents */
+    agents: Record<string, Agent>;
+    /** Available workflows */
+    workflows: Record<string, UnifiedWorkflow>;
+    /** Available tools (beyond agent/workflow tools) */
+    tools?: Record<string, OpenAITool>;
+    /** Memory configuration */
+    memory?: {
+        persistent?: boolean;
+        maxSize?: number;
+        ttl?: number;
+    };
+    /** Execution limits */
+    limits?: {
+        maxSteps?: number;
+        maxExecutionTime?: number;
+        maxMemoryUsage?: number;
+    };
+    /** Decision-making configuration */
+    decisionConfig?: {
+        /** Whether to explain decisions to user */
+        explainDecisions?: boolean;
+        /** Confidence threshold for auto-execution */
+        confidenceThreshold?: number;
+        /** Whether to ask for confirmation on low confidence */
+        askConfirmation?: boolean;
+    };
+    /** Processors for orchestrator enhancement */
+    processors?: Processor[];
+}
+/**
+ * Orchestrator execution result
+ */
+export interface OrchestratorResult {
+    /** Unique session ID */
+    sessionId: string;
+    /** Whether orchestration completed successfully */
+    success: boolean;
+    /** Final response to user */
+    response: string;
+    /** All execution steps */
+    executionSteps: OrchestratorExecutionStep[];
+    /** Final context state */
+    finalContext: RuntimeContext;
+    /** Total execution time */
+    totalExecutionTime: number;
+    /** Error message if failed */
+    error?: string;
+    /** Orchestration metrics */
+    metrics: OrchestratorMetrics;
+}
+/**
+ * Orchestrator performance metrics
+ */
+export interface OrchestratorMetrics {
+    /** Total steps executed */
+    totalSteps: number;
+    /** Agents executed */
+    agentsExecuted: number;
+    /** Workflows executed */
+    workflowsExecuted: number;
+    /** Tools executed */
+    toolsExecuted: number;
+    /** Decisions made */
+    decisionsMade: number;
+    /** Average decision confidence */
+    averageConfidence: number;
+    /** Memory operations */
+    memoryOperations: number;
+    /** Total tokens used (if available) */
+    totalTokens?: number;
+}
+/**
+ * Main Orchestrator class for coordinating agents, workflows, and tools
+ */
+export declare class UnifiedOrchestrator {
+    private config;
+    private codebolt?;
+    private decisionAgent;
+    constructor(config: OrchestratorConfig, codebolt?: CodeboltAPI);
+    /**
+     * Create the internal decision-making agent
+     */
+    private createDecisionAgent;
+    /**
+     * Execute orchestration loop
+     */
+    loop(userMessage: string, options?: {
+        runtimeContext?: Partial<RuntimeContext>;
+        maxSteps?: number;
+    }): Promise<OrchestratorResult>;
+    /**
+     * Initialize runtime context
+     */
+    private initializeRuntimeContext;
+    /**
+     * Generate unique session ID
+     */
+    private generateSessionId;
+    /**
+     * Apply orchestrator processors
+     */
+    private applyProcessors;
+    /**
+     * Make orchestration decision
+     */
+    private makeDecision;
+    /**
+     * Execute orchestration decision
+     */
+    private executeDecision;
+    /**
+     * Check if orchestration should stop
+     */
+    private shouldStop;
+    /**
+     * Estimate memory usage (simplified)
+     */
+    private estimateMemoryUsage;
+    /**
+     * Create successful orchestration result
+     */
+    private createSuccessResult;
+    /**
+     * Create error orchestration result
+     */
+    private createErrorResult;
+    /**
+     * Calculate orchestration metrics
+     */
+    private calculateMetrics;
+    /**
+     * Calculate average confidence from decisions
+     */
+    private calculateAverageConfidence;
+    /**
+     * Generate final response based on execution history
+     */
+    private generateFinalResponse;
+    /**
+     * Add agent to orchestrator
+     */
+    addAgent(id: string, agent: Agent): void;
+    /**
+     * Add workflow to orchestrator
+     */
+    addWorkflow(id: string, workflow: UnifiedWorkflow): void;
+    /**
+     * Add tool to orchestrator
+     */
+    addTool(id: string, tool: OpenAITool): void;
+    /**
+     * Get orchestrator configuration
+     */
+    getConfig(): Readonly<OrchestratorConfig>;
+    /**
+     * Update orchestrator configuration
+     */
+    updateConfig(updates: Partial<OrchestratorConfig>): void;
+}
+/**
+ * Create a new orchestrator instance
+ */
+export declare function createOrchestrator(config: OrchestratorConfig, codebolt?: CodeboltAPI): UnifiedOrchestrator;
+/**
+ * Create runtime context
+ */
+export declare function createRuntimeContext(options?: Partial<RuntimeContext>): RuntimeContext;