241 lines
8.6 KiB
Markdown
241 lines
8.6 KiB
Markdown
# Adaptive React Mode: Process-Focused Implementation
|
|
|
|
## Core Problem
|
|
|
|
Current React mode is **blind** - it doesn't understand what the user actually wants and can't learn from mistakes. It generates code when user wants data, and has no way to improve.
|
|
|
|
## How the Adaptive Engine Works
|
|
|
|
### The Process Flow
|
|
|
|
```
|
|
1. User Request → 2. Intent Analysis → 3. Action Planning → 4. Execution →
|
|
5. Content Validation → 6. Learning Update → 7. Progress Check → 8. Next Action
|
|
```
|
|
|
|
### Step-by-Step Process
|
|
|
|
#### Step 1: Intent Analysis
|
|
**What happens**: System analyzes what user actually wants
|
|
- **Input**: User prompt "Calculate first 1000 prime numbers"
|
|
- **Analysis**: User wants DATA (numbers), not CODE (algorithms)
|
|
- **Output**: Intent object with dataType="numbers", format="raw_data"
|
|
|
|
#### Step 2: Action Planning
|
|
**What happens**: System plans action based on intent
|
|
- **Input**: Intent analysis + learned strategies
|
|
- **Process**: "User wants numbers → use ai.process with data delivery prompt"
|
|
- **Output**: Action plan with specific parameters
|
|
|
|
#### Step 3: Execution
|
|
**What happens**: Execute the planned action
|
|
- **Input**: Action plan
|
|
- **Process**: Call ai.process with "Deliver the first 1000 prime numbers as a list"
|
|
- **Output**: ActionResult with documents
|
|
|
|
#### Step 4: Content Validation
|
|
**What happens**: Check if delivered content matches intent
|
|
- **Input**: ActionResult + Intent analysis
|
|
- **Process**: "Does content contain actual numbers? Is it code or data?"
|
|
- **Output**: Validation result (success/failure + specific issues)
|
|
|
|
#### Step 5: Learning Update
|
|
**What happens**: Learn from the result
|
|
- **Input**: Validation result + action taken
|
|
- **Process**: "This action worked/didn't work for this type of request"
|
|
- **Output**: Updated strategy for future similar requests
|
|
|
|
#### Step 6: Progress Check
|
|
**What happens**: Determine if task is complete
|
|
- **Input**: Validation result + progress state
|
|
- **Process**: "Did we deliver what user wanted? What's still missing?"
|
|
- **Output**: Continue/Stop decision + next action suggestions
|
|
|
|
### The Learning Mechanism
|
|
|
|
#### How Learning Works
|
|
1. **After each action**: System records what was attempted and how well it worked
|
|
2. **Pattern recognition**: System identifies successful vs failed approaches
|
|
3. **Strategy update**: System updates its approach for similar future requests
|
|
4. **Adaptive planning**: Next action is planned using learned strategies
|
|
|
|
#### Example Learning Process
|
|
```
|
|
Request: "Prime numbers"
|
|
Action 1: ai.process("Write code to generate primes") → Delivers code → FAIL
|
|
Learning: "For number requests, don't ask for code generation"
|
|
Action 2: ai.process("List the first 1000 prime numbers") → Delivers data → SUCCESS
|
|
Learning: "For number requests, ask for data delivery directly"
|
|
```
|
|
|
|
### The Validation Process
|
|
|
|
#### What Gets Validated
|
|
1. **Data type match**: Does content contain what user asked for?
|
|
2. **Format match**: Is it in the expected format?
|
|
3. **Quality check**: Is the content usable and complete?
|
|
4. **Success criteria**: Does it meet the specific requirements?
|
|
|
|
#### Example Validation
|
|
```
|
|
User wants: "First 1000 prime numbers"
|
|
Content delivered: "def generate_primes(n): ..."
|
|
Validation:
|
|
- Data type: FAIL (code instead of numbers)
|
|
- Format: FAIL (code instead of data)
|
|
- Quality: FAIL (not usable as requested)
|
|
Result: FAIL - "Deliver actual numbers, not code"
|
|
```
|
|
|
|
### The Progress Tracking
|
|
|
|
#### What Gets Tracked
|
|
1. **Completed objectives**: What has been successfully delivered
|
|
2. **Partial achievements**: What was partially successful
|
|
3. **Failed attempts**: What didn't work and why
|
|
4. **Learning insights**: What was learned from each attempt
|
|
|
|
#### Example Progress Tracking
|
|
```
|
|
Objective: "First 1000 prime numbers"
|
|
Attempt 1: Generated code → FAIL → Learned: Don't generate code for data requests
|
|
Attempt 2: Generated data → SUCCESS → Learned: Direct data delivery works
|
|
Progress: 100% complete, strategy updated for future number requests
|
|
```
|
|
|
|
## Implementation Plan
|
|
|
|
### Phase 1: Add Intent Analysis to React Mode
|
|
**Goal**: Make React mode understand what user actually wants
|
|
|
|
**Changes to existing code**:
|
|
1. **Modify `_observeBuild`** in `reactMode.py`:
|
|
- Add content analysis to observation
|
|
- Include actual content snippets, not just metadata
|
|
- Add intent match assessment
|
|
|
|
2. **Enhance `extractReviewContent`** in `promptFactoryPlaceholders.py`:
|
|
- Include content analysis in review
|
|
- Add specific validation against user intent
|
|
- Provide clear improvement suggestions
|
|
|
|
**New files**:
|
|
- `gateway/modules/workflows/processing/adaptive/intentAnalyzer.py`
|
|
- `gateway/modules/workflows/processing/adaptive/contentValidator.py`
|
|
|
|
### Phase 2: Add Learning to React Mode
|
|
**Goal**: Make React mode learn from mistakes and improve
|
|
|
|
**Changes to existing code**:
|
|
1. **Modify `_refineDecide`** in `reactMode.py`:
|
|
- Use learned strategies for action planning
|
|
- Apply learned patterns to avoid repeated failures
|
|
- Update strategies based on validation results
|
|
|
|
2. **Enhance action selection prompts**:
|
|
- Include learned strategies in AI prompts
|
|
- Add specific guidance based on past failures
|
|
- Adapt prompts based on user intent type
|
|
|
|
**New files**:
|
|
- `gateway/modules/workflows/processing/adaptive/learningEngine.py`
|
|
- `gateway/modules/workflows/processing/adaptive/strategyStore.py`
|
|
|
|
### Phase 3: Add Progress Tracking
|
|
**Goal**: Make React mode understand what has been accomplished
|
|
|
|
**Changes to existing code**:
|
|
1. **Modify `executeTask`** in `reactMode.py`:
|
|
- Track progress across steps
|
|
- Use progress to inform next actions
|
|
- Stop when objectives are actually met
|
|
|
|
2. **Enhance stopping logic**:
|
|
- Check if user intent has been fulfilled
|
|
- Consider partial achievements
|
|
- Make intelligent continue/stop decisions
|
|
|
|
**New files**:
|
|
- `gateway/modules/workflows/processing/adaptive/progressTracker.py`
|
|
|
|
## Integration with Existing Refactoring
|
|
|
|
### Follows Generic Workflow Processing Structure
|
|
```
|
|
gateway/modules/workflows/processing/
|
|
├── core/ # Common functionality
|
|
│ ├── actionExecutor.py # Enhanced with adaptive execution
|
|
│ └── messageCreator.py # Enhanced with adaptive messaging
|
|
├── modes/ # Mode-specific implementations
|
|
│ └── reactMode.py # Enhanced with adaptive capabilities
|
|
├── shared/ # Shared utilities
|
|
│ └── promptFactoryPlaceholders.py # Enhanced with adaptive prompts
|
|
└── adaptive/ # NEW: Adaptive components
|
|
├── intentAnalyzer.py
|
|
├── contentValidator.py
|
|
├── learningEngine.py
|
|
└── progressTracker.py
|
|
```
|
|
|
|
### Key Integration Points
|
|
|
|
1. **ActionExecutor**: Enhanced to use learned strategies
|
|
2. **MessageCreator**: Enhanced to show adaptive progress
|
|
3. **ReactMode**: Enhanced with adaptive process flow
|
|
4. **PromptFactory**: Enhanced with learned prompt patterns
|
|
|
|
## Implementation Steps
|
|
|
|
### Step 1: Create Adaptive Directory
|
|
```bash
|
|
mkdir -p gateway/modules/workflows/processing/adaptive
|
|
```
|
|
|
|
### Step 2: Implement Core Adaptive Components
|
|
1. Create `intentAnalyzer.py` - analyzes user intent
|
|
2. Create `contentValidator.py` - validates delivered content
|
|
3. Create `learningEngine.py` - learns from feedback
|
|
4. Create `progressTracker.py` - tracks progress
|
|
|
|
### Step 3: Integrate with Existing React Mode
|
|
1. Modify `reactMode.py` to use adaptive components
|
|
2. Enhance observation building with content analysis
|
|
3. Add learning to action planning
|
|
4. Add progress tracking to execution flow
|
|
|
|
### Step 4: Test and Validate
|
|
1. Test with various user intents
|
|
2. Validate learning effectiveness
|
|
3. Ensure integration with existing refactoring
|
|
|
|
## Expected Results
|
|
|
|
### Before (Current React Mode)
|
|
- Blind to user intent
|
|
- No learning from mistakes
|
|
- Fake success indicators
|
|
- No progress understanding
|
|
|
|
### After (Adaptive React Mode)
|
|
- Understands user intent
|
|
- Learns and improves over time
|
|
- Real validation and success assessment
|
|
- Tracks progress and makes intelligent decisions
|
|
|
|
### Example Improvement
|
|
```
|
|
User: "Calculate first 1000 prime numbers"
|
|
|
|
Current React Mode:
|
|
Step 1: ai.process("Write code to generate primes") → Code → FAIL
|
|
Step 2: ai.process("Write code to generate primes") → Code → FAIL
|
|
Step 3: ai.process("Write code to generate primes") → Code → FAIL
|
|
Result: User gets code, not numbers
|
|
|
|
Adaptive React Mode:
|
|
Step 1: ai.process("Write code to generate primes") → Code → FAIL
|
|
Learning: "For number requests, don't ask for code"
|
|
Step 2: ai.process("List the first 1000 prime numbers") → Numbers → SUCCESS
|
|
Learning: "For number requests, ask for data directly"
|
|
Result: User gets actual numbers
|
|
```
|