559 lines
18 KiB
TypeScript
559 lines
18 KiB
TypeScript
import * as plugins from './plugins.js';
|
|
import * as interfaces from './smartagent.interfaces.js';
|
|
import { BaseToolWrapper } from './smartagent.tools.base.js';
|
|
import { DriverAgent } from './smartagent.classes.driveragent.js';
|
|
import { GuardianAgent } from './smartagent.classes.guardianagent.js';
|
|
import { FilesystemTool } from './smartagent.tools.filesystem.js';
|
|
import { HttpTool } from './smartagent.tools.http.js';
|
|
import { ShellTool } from './smartagent.tools.shell.js';
|
|
import { BrowserTool } from './smartagent.tools.browser.js';
|
|
import { DenoTool } from './smartagent.tools.deno.js';
|
|
|
|
/**
|
|
* DualAgentOrchestrator - Coordinates Driver and Guardian agents
|
|
* Manages the complete lifecycle of task execution with tool approval
|
|
*/
|
|
export class DualAgentOrchestrator {
|
|
private options: interfaces.IDualAgentOptions;
|
|
private smartai: plugins.smartai.SmartAi;
|
|
private driverProvider: plugins.smartai.MultiModalModel;
|
|
private guardianProvider: plugins.smartai.MultiModalModel;
|
|
private driver: DriverAgent;
|
|
private guardian: GuardianAgent;
|
|
private tools: Map<string, BaseToolWrapper> = new Map();
|
|
private isRunning = false;
|
|
private conversationHistory: interfaces.IAgentMessage[] = [];
|
|
private ownsSmartAi = true; // true if we created the SmartAi instance, false if it was provided
|
|
|
|
constructor(options: interfaces.IDualAgentOptions) {
|
|
this.options = {
|
|
maxIterations: 20,
|
|
maxConsecutiveRejections: 3,
|
|
defaultProvider: 'openai',
|
|
maxResultChars: 15000,
|
|
maxHistoryMessages: 20,
|
|
...options,
|
|
};
|
|
|
|
// Use existing SmartAi instance if provided, otherwise create a new one
|
|
if (options.smartAiInstance) {
|
|
this.smartai = options.smartAiInstance;
|
|
this.ownsSmartAi = false; // Don't manage lifecycle of provided instance
|
|
} else {
|
|
this.smartai = new plugins.smartai.SmartAi(options);
|
|
this.ownsSmartAi = true;
|
|
}
|
|
// Note: Don't access providers here - they don't exist until start() is called
|
|
}
|
|
|
|
/**
|
|
* Get provider by name
|
|
*/
|
|
private getProviderByName(providerName: plugins.smartai.TProvider): plugins.smartai.MultiModalModel {
|
|
switch (providerName) {
|
|
case 'openai':
|
|
return this.smartai.openaiProvider;
|
|
case 'anthropic':
|
|
return this.smartai.anthropicProvider;
|
|
case 'perplexity':
|
|
return this.smartai.perplexityProvider;
|
|
case 'ollama':
|
|
return this.smartai.ollamaProvider;
|
|
case 'groq':
|
|
return this.smartai.groqProvider;
|
|
case 'xai':
|
|
return this.smartai.xaiProvider;
|
|
case 'exo':
|
|
return this.smartai.exoProvider;
|
|
default:
|
|
return this.smartai.openaiProvider;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Emit a progress event if callback is configured
|
|
*/
|
|
private emitProgress(event: Omit<interfaces.IProgressEvent, 'timestamp' | 'logLevel' | 'logMessage'>): void {
|
|
if (this.options.onProgress) {
|
|
const prefix = this.options.logPrefix ? `${this.options.logPrefix} ` : '';
|
|
const { logLevel, logMessage } = this.formatProgressEvent(event, prefix);
|
|
|
|
this.options.onProgress({
|
|
...event,
|
|
timestamp: new Date(),
|
|
logLevel,
|
|
logMessage,
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Format a progress event into a log level and message
|
|
*/
|
|
private formatProgressEvent(
|
|
event: Omit<interfaces.IProgressEvent, 'timestamp' | 'logLevel' | 'logMessage'>,
|
|
prefix: string
|
|
): { logLevel: interfaces.TLogLevel; logMessage: string } {
|
|
switch (event.type) {
|
|
case 'task_started':
|
|
return { logLevel: 'info', logMessage: `${prefix}Task started` };
|
|
case 'iteration_started':
|
|
return { logLevel: 'info', logMessage: `${prefix}Iteration ${event.iteration}/${event.maxIterations}` };
|
|
case 'tool_proposed':
|
|
return { logLevel: 'info', logMessage: `${prefix} → Proposing: ${event.toolName}.${event.action}` };
|
|
case 'guardian_evaluating':
|
|
return { logLevel: 'info', logMessage: `${prefix} ⏳ Guardian evaluating...` };
|
|
case 'tool_approved':
|
|
return { logLevel: 'info', logMessage: `${prefix} ✓ Approved: ${event.toolName}.${event.action}` };
|
|
case 'tool_rejected':
|
|
return { logLevel: 'warn', logMessage: `${prefix} ✗ Rejected: ${event.toolName}.${event.action} - ${event.reason}` };
|
|
case 'tool_executing':
|
|
return { logLevel: 'info', logMessage: `${prefix} ⚡ Executing: ${event.toolName}.${event.action}...` };
|
|
case 'tool_completed':
|
|
return { logLevel: 'info', logMessage: `${prefix} ✓ Completed: ${event.message}` };
|
|
case 'task_completed':
|
|
return { logLevel: 'success', logMessage: `${prefix}Task completed in ${event.iteration} iterations` };
|
|
case 'clarification_needed':
|
|
return { logLevel: 'warn', logMessage: `${prefix}Clarification needed from user` };
|
|
case 'max_iterations':
|
|
return { logLevel: 'error', logMessage: `${prefix}${event.message}` };
|
|
case 'max_rejections':
|
|
return { logLevel: 'error', logMessage: `${prefix}${event.message}` };
|
|
default:
|
|
return { logLevel: 'info', logMessage: `${prefix}${event.type}` };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a custom tool
|
|
*/
|
|
public registerTool(tool: BaseToolWrapper): void {
|
|
this.tools.set(tool.name, tool);
|
|
// Register with agents if they exist (they're created in start())
|
|
if (this.driver) {
|
|
this.driver.registerTool(tool);
|
|
}
|
|
if (this.guardian) {
|
|
this.guardian.registerTool(tool);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register all standard tools
|
|
*/
|
|
public registerStandardTools(): void {
|
|
const standardTools = [
|
|
new FilesystemTool(),
|
|
new HttpTool(),
|
|
new ShellTool(),
|
|
new BrowserTool(),
|
|
new DenoTool(),
|
|
];
|
|
|
|
for (const tool of standardTools) {
|
|
this.registerTool(tool);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a scoped filesystem tool that can only access files within the specified directory
|
|
* @param basePath The directory to scope filesystem operations to
|
|
*/
|
|
public registerScopedFilesystemTool(basePath: string): void {
|
|
const scopedTool = new FilesystemTool({ basePath });
|
|
this.registerTool(scopedTool);
|
|
}
|
|
|
|
/**
|
|
* Initialize all tools (eager loading)
|
|
*/
|
|
public async start(): Promise<void> {
|
|
// Start smartai only if we created it (external instances should already be started)
|
|
if (this.ownsSmartAi) {
|
|
await this.smartai.start();
|
|
}
|
|
|
|
// NOW get providers (after they've been initialized by smartai.start())
|
|
this.driverProvider = this.getProviderByName(this.options.defaultProvider!);
|
|
this.guardianProvider = this.options.guardianProvider
|
|
? this.getProviderByName(this.options.guardianProvider)
|
|
: this.driverProvider;
|
|
|
|
// NOW create agents with initialized providers
|
|
this.driver = new DriverAgent(this.driverProvider, {
|
|
systemMessage: this.options.driverSystemMessage,
|
|
maxHistoryMessages: this.options.maxHistoryMessages,
|
|
});
|
|
this.guardian = new GuardianAgent(this.guardianProvider, this.options.guardianPolicyPrompt);
|
|
|
|
// Register any tools that were added before start() with the agents
|
|
for (const tool of this.tools.values()) {
|
|
this.driver.registerTool(tool);
|
|
this.guardian.registerTool(tool);
|
|
}
|
|
|
|
// Initialize all tools
|
|
const initPromises: Promise<void>[] = [];
|
|
for (const tool of this.tools.values()) {
|
|
initPromises.push(tool.initialize());
|
|
}
|
|
|
|
await Promise.all(initPromises);
|
|
this.isRunning = true;
|
|
}
|
|
|
|
/**
|
|
* Cleanup all tools
|
|
*/
|
|
public async stop(): Promise<void> {
|
|
const cleanupPromises: Promise<void>[] = [];
|
|
|
|
for (const tool of this.tools.values()) {
|
|
cleanupPromises.push(tool.cleanup());
|
|
}
|
|
|
|
await Promise.all(cleanupPromises);
|
|
|
|
// Only stop smartai if we created it (don't stop external instances)
|
|
if (this.ownsSmartAi) {
|
|
await this.smartai.stop();
|
|
}
|
|
|
|
this.isRunning = false;
|
|
if (this.driver) {
|
|
this.driver.reset();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Run a task through the dual-agent system
|
|
*/
|
|
public async run(task: string): Promise<interfaces.IDualAgentRunResult> {
|
|
if (!this.isRunning) {
|
|
throw new Error('Orchestrator not started. Call start() first.');
|
|
}
|
|
|
|
this.conversationHistory = [];
|
|
let iterations = 0;
|
|
let consecutiveRejections = 0;
|
|
let completed = false;
|
|
let finalResult: string | null = null;
|
|
|
|
// Add initial task to history
|
|
this.conversationHistory.push({
|
|
role: 'user',
|
|
content: task,
|
|
});
|
|
|
|
// Start the driver with the task
|
|
let driverResponse = await this.driver.startTask(task);
|
|
this.conversationHistory.push(driverResponse);
|
|
|
|
// Emit task started event
|
|
this.emitProgress({
|
|
type: 'task_started',
|
|
message: task.length > 100 ? task.substring(0, 100) + '...' : task,
|
|
});
|
|
|
|
while (
|
|
iterations < this.options.maxIterations! &&
|
|
consecutiveRejections < this.options.maxConsecutiveRejections! &&
|
|
!completed
|
|
) {
|
|
iterations++;
|
|
|
|
// Emit iteration started event
|
|
this.emitProgress({
|
|
type: 'iteration_started',
|
|
iteration: iterations,
|
|
maxIterations: this.options.maxIterations,
|
|
});
|
|
|
|
// Check if task is complete
|
|
if (this.driver.isTaskComplete(driverResponse.content)) {
|
|
completed = true;
|
|
finalResult = this.driver.extractTaskResult(driverResponse.content) || driverResponse.content;
|
|
|
|
// Emit task completed event
|
|
this.emitProgress({
|
|
type: 'task_completed',
|
|
iteration: iterations,
|
|
message: 'Task completed successfully',
|
|
});
|
|
break;
|
|
}
|
|
|
|
// Check if driver needs clarification
|
|
if (this.driver.needsClarification(driverResponse.content)) {
|
|
// Emit clarification needed event
|
|
this.emitProgress({
|
|
type: 'clarification_needed',
|
|
iteration: iterations,
|
|
message: 'Driver needs clarification from user',
|
|
});
|
|
|
|
// Return with clarification needed status
|
|
return {
|
|
success: false,
|
|
completed: false,
|
|
result: driverResponse.content,
|
|
iterations,
|
|
history: this.conversationHistory,
|
|
status: 'clarification_needed',
|
|
};
|
|
}
|
|
|
|
// Parse tool call proposals
|
|
const proposals = this.driver.parseToolCallProposals(driverResponse.content);
|
|
|
|
if (proposals.length === 0) {
|
|
// No tool calls, continue the conversation
|
|
driverResponse = await this.driver.continueWithMessage(
|
|
'Please either use a tool to make progress on the task, or indicate that the task is complete with <task_complete>summary</task_complete>.'
|
|
);
|
|
this.conversationHistory.push(driverResponse);
|
|
continue;
|
|
}
|
|
|
|
// Process the first proposal (one at a time)
|
|
const proposal = proposals[0];
|
|
|
|
// Emit tool proposed event
|
|
this.emitProgress({
|
|
type: 'tool_proposed',
|
|
iteration: iterations,
|
|
toolName: proposal.toolName,
|
|
action: proposal.action,
|
|
message: `${proposal.toolName}.${proposal.action}`,
|
|
});
|
|
|
|
// Quick validation first
|
|
const quickDecision = this.guardian.quickValidate(proposal);
|
|
let decision: interfaces.IGuardianDecision;
|
|
|
|
if (quickDecision) {
|
|
decision = quickDecision;
|
|
} else {
|
|
// Emit guardian evaluating event
|
|
this.emitProgress({
|
|
type: 'guardian_evaluating',
|
|
iteration: iterations,
|
|
toolName: proposal.toolName,
|
|
action: proposal.action,
|
|
});
|
|
|
|
// Full AI evaluation
|
|
decision = await this.guardian.evaluate(proposal, task);
|
|
}
|
|
|
|
if (decision.decision === 'approve') {
|
|
consecutiveRejections = 0;
|
|
|
|
// Emit tool approved event
|
|
this.emitProgress({
|
|
type: 'tool_approved',
|
|
iteration: iterations,
|
|
toolName: proposal.toolName,
|
|
action: proposal.action,
|
|
});
|
|
|
|
// Execute the tool
|
|
const tool = this.tools.get(proposal.toolName);
|
|
if (!tool) {
|
|
const errorMessage = `Tool "${proposal.toolName}" not found.`;
|
|
driverResponse = await this.driver.continueWithMessage(
|
|
`TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`
|
|
);
|
|
this.conversationHistory.push(driverResponse);
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
// Emit tool executing event
|
|
this.emitProgress({
|
|
type: 'tool_executing',
|
|
iteration: iterations,
|
|
toolName: proposal.toolName,
|
|
action: proposal.action,
|
|
});
|
|
|
|
const result = await tool.execute(proposal.action, proposal.params);
|
|
|
|
// Emit tool completed event
|
|
this.emitProgress({
|
|
type: 'tool_completed',
|
|
iteration: iterations,
|
|
toolName: proposal.toolName,
|
|
action: proposal.action,
|
|
message: result.success ? 'success' : result.error,
|
|
});
|
|
|
|
// Build result message (prefer summary if provided, otherwise stringify result)
|
|
let resultMessage: string;
|
|
if (result.success) {
|
|
if (result.summary) {
|
|
// Use tool-provided summary
|
|
resultMessage = `TOOL RESULT (${proposal.toolName}.${proposal.action}):\n${result.summary}`;
|
|
} else {
|
|
// Stringify and potentially truncate
|
|
const resultStr = JSON.stringify(result.result, null, 2);
|
|
const maxChars = this.options.maxResultChars ?? 15000;
|
|
|
|
if (maxChars > 0 && resultStr.length > maxChars) {
|
|
// Truncate the result
|
|
const truncated = resultStr.substring(0, maxChars);
|
|
const omittedTokens = Math.round((resultStr.length - maxChars) / 4);
|
|
resultMessage = `TOOL RESULT (${proposal.toolName}.${proposal.action}):\n${truncated}\n\n[... output truncated, ~${omittedTokens} tokens omitted. Use more specific parameters to reduce output size.]`;
|
|
} else {
|
|
resultMessage = `TOOL RESULT (${proposal.toolName}.${proposal.action}):\n${resultStr}`;
|
|
}
|
|
}
|
|
} else {
|
|
resultMessage = `TOOL ERROR (${proposal.toolName}.${proposal.action}):\n${result.error}`;
|
|
}
|
|
|
|
this.conversationHistory.push({
|
|
role: 'system',
|
|
content: resultMessage,
|
|
toolCall: proposal,
|
|
toolResult: result,
|
|
});
|
|
|
|
driverResponse = await this.driver.continueWithMessage(resultMessage);
|
|
this.conversationHistory.push(driverResponse);
|
|
} catch (error) {
|
|
const errorMessage = `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`;
|
|
driverResponse = await this.driver.continueWithMessage(
|
|
`TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`
|
|
);
|
|
this.conversationHistory.push(driverResponse);
|
|
}
|
|
} else {
|
|
// Rejected
|
|
consecutiveRejections++;
|
|
|
|
// Emit tool rejected event
|
|
this.emitProgress({
|
|
type: 'tool_rejected',
|
|
iteration: iterations,
|
|
toolName: proposal.toolName,
|
|
action: proposal.action,
|
|
reason: decision.reason,
|
|
});
|
|
|
|
// Build rejection feedback
|
|
let feedback = `TOOL CALL REJECTED by Guardian:\n`;
|
|
feedback += `- Reason: ${decision.reason}\n`;
|
|
|
|
if (decision.concerns && decision.concerns.length > 0) {
|
|
feedback += `- Concerns:\n${decision.concerns.map(c => ` - ${c}`).join('\n')}\n`;
|
|
}
|
|
|
|
if (decision.suggestions) {
|
|
feedback += `- Suggestions: ${decision.suggestions}\n`;
|
|
}
|
|
|
|
feedback += `\nPlease adapt your approach based on this feedback.`;
|
|
|
|
this.conversationHistory.push({
|
|
role: 'system',
|
|
content: feedback,
|
|
toolCall: proposal,
|
|
guardianDecision: decision,
|
|
});
|
|
|
|
driverResponse = await this.driver.continueWithMessage(feedback);
|
|
this.conversationHistory.push(driverResponse);
|
|
}
|
|
}
|
|
|
|
// Determine final status
|
|
let status: interfaces.TDualAgentRunStatus = 'completed';
|
|
if (!completed) {
|
|
if (iterations >= this.options.maxIterations!) {
|
|
status = 'max_iterations_reached';
|
|
// Emit max iterations event
|
|
this.emitProgress({
|
|
type: 'max_iterations',
|
|
iteration: iterations,
|
|
maxIterations: this.options.maxIterations,
|
|
message: `Maximum iterations (${this.options.maxIterations}) reached`,
|
|
});
|
|
} else if (consecutiveRejections >= this.options.maxConsecutiveRejections!) {
|
|
status = 'max_rejections_reached';
|
|
// Emit max rejections event
|
|
this.emitProgress({
|
|
type: 'max_rejections',
|
|
iteration: iterations,
|
|
message: `Maximum consecutive rejections (${this.options.maxConsecutiveRejections}) reached`,
|
|
});
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: completed,
|
|
completed,
|
|
result: finalResult || driverResponse.content,
|
|
iterations,
|
|
history: this.conversationHistory,
|
|
status,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Continue an existing task with user input
|
|
*/
|
|
public async continueTask(userInput: string): Promise<interfaces.IDualAgentRunResult> {
|
|
if (!this.isRunning) {
|
|
throw new Error('Orchestrator not started. Call start() first.');
|
|
}
|
|
|
|
this.conversationHistory.push({
|
|
role: 'user',
|
|
content: userInput,
|
|
});
|
|
|
|
const driverResponse = await this.driver.continueWithMessage(userInput);
|
|
this.conversationHistory.push(driverResponse);
|
|
|
|
// Continue the run loop
|
|
// For simplicity, we return the current state - full continuation would need refactoring
|
|
return {
|
|
success: false,
|
|
completed: false,
|
|
result: driverResponse.content,
|
|
iterations: 1,
|
|
history: this.conversationHistory,
|
|
status: 'in_progress',
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get the conversation history
|
|
*/
|
|
public getHistory(): interfaces.IAgentMessage[] {
|
|
return [...this.conversationHistory];
|
|
}
|
|
|
|
/**
|
|
* Update the guardian policy
|
|
*/
|
|
public setGuardianPolicy(policyPrompt: string): void {
|
|
this.guardian.setPolicy(policyPrompt);
|
|
}
|
|
|
|
/**
|
|
* Check if orchestrator is running
|
|
*/
|
|
public isActive(): boolean {
|
|
return this.isRunning;
|
|
}
|
|
|
|
/**
|
|
* Get registered tool names
|
|
*/
|
|
public getToolNames(): string[] {
|
|
return Array.from(this.tools.keys());
|
|
}
|
|
}
|