51e4c6d208
- Updated the `RunConfig` to include parameters for multi-turn conversation control, such as `ContinueOnFailure`, `ValidationThreshold`, and `MaxTurnsPerTask`. - Implemented a new multi-turn conversation flow for assistant tasks, allowing for iterative interactions until completion or maximum turns are reached. - Enhanced the `ValidationResult` structure to support multi-turn states, including fields for `Complete`, `NeedReply`, and `ReplyContent`. - Refined the `ExecuteWithRetry` method to accommodate the new conversation flow, ensuring proper handling of task execution and validation. - Revised the `Validator` to include logic for determining when to continue conversations based on validation results. - Updated documentation and tests to reflect the new multi-turn capabilities and validation mechanisms, ensuring comprehensive coverage of the changes.
119 lines
3.3 KiB
Go
119 lines
3.3 KiB
Go
package standard
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
robottypes "github.com/yaoapp/yao/agent/robot/types"
|
|
)
|
|
|
|
// RunConfig configures P3 execution behavior
|
|
type RunConfig struct {
|
|
// ContinueOnFailure continues to next task even if current task fails (default: false)
|
|
ContinueOnFailure bool
|
|
|
|
// ValidationThreshold is the minimum score to pass validation (default: 0.6)
|
|
ValidationThreshold float64
|
|
|
|
// MaxTurnsPerTask is the maximum conversation turns for multi-turn tasks (default: 10)
|
|
// This controls how many times the assistant can be called for a single task
|
|
// (including retries with validation feedback)
|
|
MaxTurnsPerTask int
|
|
}
|
|
|
|
// DefaultRunConfig returns the default P3 configuration
|
|
func DefaultRunConfig() *RunConfig {
|
|
return &RunConfig{
|
|
ContinueOnFailure: false,
|
|
ValidationThreshold: 0.6,
|
|
MaxTurnsPerTask: 10,
|
|
}
|
|
}
|
|
|
|
// RunExecution executes P3: Run phase
|
|
// Executes each task using the appropriate executor (Assistant, MCP, Process)
|
|
// with multi-turn conversation and validation
|
|
//
|
|
// Input:
|
|
// - Tasks (from P2)
|
|
//
|
|
// Output:
|
|
// - TaskResult for each task with output and validation
|
|
//
|
|
// Execution Flow (per task):
|
|
// 1. Call assistant/MCP/process and get result
|
|
// 2. Validate result using two-layer validation (rule-based + semantic)
|
|
// 3. If validation.NeedReply, continue conversation with validation.ReplyContent
|
|
// 4. Repeat until validation.Complete or max turns exceeded
|
|
// 5. Pass previous task results as context to next task
|
|
func (e *Executor) RunExecution(ctx *robottypes.Context, exec *robottypes.Execution, _ interface{}) error {
|
|
robot := exec.GetRobot()
|
|
if robot == nil {
|
|
return fmt.Errorf("robot not found in execution")
|
|
}
|
|
|
|
if len(exec.Tasks) == 0 {
|
|
return fmt.Errorf("no tasks to execute")
|
|
}
|
|
|
|
// Get run configuration
|
|
config := DefaultRunConfig()
|
|
|
|
// Initialize results slice
|
|
exec.Results = make([]robottypes.TaskResult, 0, len(exec.Tasks))
|
|
|
|
// Create task runner
|
|
runner := NewRunner(ctx, robot, config)
|
|
|
|
// Execute tasks sequentially
|
|
for i := range exec.Tasks {
|
|
task := &exec.Tasks[i]
|
|
|
|
// Update current state for tracking
|
|
exec.Current = &robottypes.CurrentState{
|
|
Task: task,
|
|
TaskIndex: i,
|
|
Progress: fmt.Sprintf("%d/%d tasks", i+1, len(exec.Tasks)),
|
|
}
|
|
|
|
// Mark task as running
|
|
task.Status = robottypes.TaskRunning
|
|
now := time.Now()
|
|
task.StartTime = &now
|
|
|
|
// Build task context with previous results
|
|
taskCtx := runner.BuildTaskContext(exec, i)
|
|
|
|
// Execute task with multi-turn conversation support
|
|
result := runner.ExecuteWithRetry(task, taskCtx)
|
|
|
|
// Update task status based on result
|
|
endTime := time.Now()
|
|
task.EndTime = &endTime
|
|
|
|
// Determine task status from result
|
|
// Note: result.Success is already set to (validation.Complete && validation.Passed) in runner
|
|
if result.Success {
|
|
task.Status = robottypes.TaskCompleted
|
|
} else {
|
|
task.Status = robottypes.TaskFailed
|
|
}
|
|
|
|
// Store result
|
|
exec.Results = append(exec.Results, *result)
|
|
|
|
// Check if we should continue on failure
|
|
if !result.Success && !config.ContinueOnFailure {
|
|
// Mark remaining tasks as skipped
|
|
for j := i + 1; j < len(exec.Tasks); j++ {
|
|
exec.Tasks[j].Status = robottypes.TaskSkipped
|
|
}
|
|
return fmt.Errorf("task %s failed: %s", task.ID, result.Error)
|
|
}
|
|
}
|
|
|
|
// Clear current state
|
|
exec.Current = nil
|
|
|
|
return nil
|
|
}
|